Files
ims/docs/superpowers/plans/2026-08-16-bulk-incident-import-implementation.md
T

30 KiB

Bulk Incident Import Implementation Plan

For agentic workers: REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (- [ ]) syntax for tracking.

Goal: Implement admin-only bulk import system to migrate historical incident case folders (hundreds of cases) into IMS as closed incidents with AI-extracted metadata and attached evidence files.

Architecture: Three-phase system: (1) upload handler accepts folder/zip, extracts files; (2) DeepSeek API analyzes PDFs to extract incident metadata; (3) admin reviews extracted data in editable table, approves batch creation of closed incidents with evidence attachment.

Tech Stack: Next.js, React, TailwindCSS, DeepSeek API, existing evidence storage (/var/lib/ims-evidence/), Drizzle ORM, Postgres RLS.

Global Constraints

  • All incidents created as status="closed" (immutable, no workflow triggers)
  • Required fields: description, date, location (site + zone) — admin must fill gaps before creation
  • Files stored in same evidence filesystem as regular incidents
  • Use existing DeepSeek API key (shared with risk analysis feature)
  • Admin role only (requireAdmin() guard on all routes)
  • Audit log tracks bulk imports with action='bulk_import'
  • No database schema changes required (use existing incidents + evidence_files tables)

File Structure

Create:

  • lib/incidents/bulk-import.ts — metadata extraction, DeepSeek integration, incident factory
  • components/admin/bulk-import-form.tsx — upload form, preview table, edit UI
  • app/(protected)/admin/bulk-import/page.tsx — main page component
  • app/api/admin/bulk-import/route.ts — upload handler (extract files, analyze PDFs)
  • app/api/admin/bulk-import/create/route.ts — batch creation endpoint

Modify:

  • app/(protected)/admin/page.tsx — add link to bulk import

Task 1: Bulk Import Core Library

Files:

  • Create: lib/incidents/bulk-import.ts
  • Create: lib/incidents/bulk-import.test.ts

Interfaces:

  • Consumes: createDeepSeekClient() (existing), uploadEvidenceFile() (existing), withUser() (existing)

  • Produces:

    • type ExtractedIncidentMetadata = { description: string; date: string; location: { site: string; zone: string }; incident_type?: string; priority?: 'low' | 'med' | 'high'; witnesses?: Array<{ name: string; contact?: string }> }
    • analyzePdfsWithDeepSeek(pdfTexts: string[]): Promise<ExtractedIncidentMetadata>
    • createBulkIncidents(metadata: ExtractedIncidentMetadata[], userId: string, files: FileInfo[]): Promise<CreatedIncident[]>
    • type FileInfo = { path: string; name: string; mimeType: string; buffer: Buffer }
    • type CreatedIncident = { id: string; reference_no: string; file_count: number }
  • Step 1: Write failing test for DeepSeek extraction

// lib/incidents/bulk-import.test.ts
import { describe, it, expect, vi } from 'vitest'
import { analyzePdfsWithDeepSeek } from './bulk-import'

describe('analyzePdfsWithDeepSeek', () => {
  it('extracts incident metadata from PDF text', async () => {
    const pdfTexts = [
      'Incident Date: 10 August 2026\nLocation: Main Warehouse Zone 7\nDescription: Forklift collision with rack'
    ]
    
    const metadata = await analyzePdfsWithDeepSeek(pdfTexts)
    
    expect(metadata).toMatchObject({
      description: expect.stringContaining('collision'),
      date: '2026-08-10',
      location: {
        site: expect.any(String),
        zone: expect.any(String)
      }
    })
  })
  
  it('returns empty fields for missing data', async () => {
    const pdfTexts = ['Random text with no incident info']
    const metadata = await analyzePdfsWithDeepSeek(pdfTexts)
    expect(metadata.description).toBe('')
    expect(metadata.date).toBe('')
  })
})
  • Step 2: Run test to verify failure
npm run test -- lib/incidents/bulk-import.test.ts

Expected: FAIL — "analyzePdfsWithDeepSeek is not defined"

  • Step 3: Implement DeepSeek extraction function
// lib/incidents/bulk-import.ts
import { createDeepSeekClient } from '@/lib/claude/client'

export type ExtractedIncidentMetadata = {
  description: string
  date: string
  location: { site: string; zone: string }
  incident_type?: 'env' | 'asset' | 'security' | 'fire'
  priority?: 'low' | 'med' | 'high'
  witnesses?: Array<{ name: string; contact?: string }>
}

export async function analyzePdfsWithDeepSeek(
  pdfTexts: string[]
): Promise<ExtractedIncidentMetadata> {
  const client = createDeepSeekClient()
  
  const prompt = `Analyze the following incident document(s) and extract structured data.
Return ONLY valid JSON, no markdown:

Document text:
${pdfTexts.join('\n---\n')}

Extract and return JSON:
{
  "description": "summary of what happened (required)",
  "date": "incident date in YYYY-MM-DD format (required)",
  "location": {
    "site": "site name (required)",
    "zone": "zone/area name (required)"
  },
  "incident_type": "env|asset|security|fire (optional)",
  "priority": "low|med|high (optional)",
  "witnesses": [{"name": "name", "contact": "contact info"}] (optional array)
}

If a field is not found in the document, omit it (except required fields must be present).`

  try {
    const response = await client.messages.create({
      model: 'deepseek-chat',
      max_tokens: 500,
      messages: [
        {
          role: 'user',
          content: prompt
        }
      ]
    })

    const text = response.content[0].type === 'text' ? response.content[0].text : ''
    const cleaned = text.replace(/^```json\n?|\n?```$/g, '').trim()
    const data = JSON.parse(cleaned)

    return {
      description: data.description || '',
      date: data.date || '',
      location: {
        site: data.location?.site || '',
        zone: data.location?.zone || ''
      },
      incident_type: data.incident_type,
      priority: data.priority,
      witnesses: data.witnesses
    }
  } catch (error) {
    console.error('DeepSeek extraction failed:', error)
    return {
      description: '',
      date: '',
      location: { site: '', zone: '' }
    }
  }
}
  • Step 4: Write test for incident creation
describe('createBulkIncidents', () => {
  it('creates closed incidents with evidence files', async () => {
    const metadata: ExtractedIncidentMetadata[] = [
      {
        description: 'Test incident',
        date: '2026-08-10',
        location: { site: 'Main WH', zone: 'Zone 7' },
        incident_type: 'asset',
        priority: 'high'
      }
    ]
    
    const files: FileInfo[] = [
      {
        path: 'folder/test.pdf',
        name: 'test.pdf',
        mimeType: 'application/pdf',
        buffer: Buffer.from('PDF content')
      }
    ]
    
    const userId = 'user-123'
    const created = await createBulkIncidents(metadata, userId, files)
    
    expect(created).toHaveLength(1)
    expect(created[0]).toMatchObject({
      id: expect.any(String),
      reference_no: expect.stringMatching(/^[A-Z]+-\d{6}-\d{4}$/),
      file_count: 1
    })
  })
})
  • Step 5: Implement incident creation function
// lib/incidents/bulk-import.ts
import { withUser } from '@/lib/db/with-user'
import { db } from '@/lib/db'
import { incidents, evidenceFiles } from '@/lib/db/schema'
import { uploadEvidenceFile } from '@/lib/storage/evidence'
import { writeAuditLog } from '@/lib/db/audit'
import { eq } from 'drizzle-orm'

export type FileInfo = {
  path: string
  name: string
  mimeType: string
  buffer: Buffer
}

export type CreatedIncident = {
  id: string
  reference_no: string
  file_count: number
}

export async function createBulkIncidents(
  metadata: ExtractedIncidentMetadata[],
  userId: string,
  files: FileInfo[]
): Promise<CreatedIncident[]> {
  const created: CreatedIncident[] = []

  for (const meta of metadata) {
    const incidentId = await withUser(userId, async (txDb) => {
      // Get site ID from site name
      const site = await txDb
        .select()
        .from(sites)
        .where(eq(sites.name, meta.location.site))
        .limit(1)

      if (!site.length) {
        throw new Error(`Site not found: ${meta.location.site}`)
      }

      // Get zone ID
      const zone = await txDb
        .select()
        .from(zones)
        .where(eq(zones.name, meta.location.zone))
        .limit(1)

      if (!zone.length) {
        throw new Error(`Zone not found: ${meta.location.zone}`)
      }

      // Generate reference_no (SITE-YYYYMM-0001)
      const [yearMonth] = meta.date.split('-').slice(0, 2)
      const prefix = `${site[0].code}-${yearMonth}`

      const existing = await txDb
        .select()
        .from(incidents)
        .where(sql`reference_no LIKE ${prefix + '-%'}`)

      const nextNum = existing.length + 1
      const reference_no = `${prefix}-${String(nextNum).padStart(4, '0')}`

      // Create incident (status = closed)
      const [incident] = await txDb
        .insert(incidents)
        .values({
          reference_no,
          description: meta.description,
          incident_date: meta.date,
          site_id: site[0].id,
          zone_id: zone[0].id,
          incident_type: meta.incident_type || 'other',
          priority: meta.priority || 'med',
          status: 'closed',
          created_by: userId
        })
        .returning({ id: incidents.id })

      // Attach evidence files
      const folderFiles = files.filter((f) => f.path.includes(meta.description.slice(0, 10)))
      for (const file of folderFiles) {
        const filePath = await uploadEvidenceFile(file.buffer, file.mimeType)
        await txDb.insert(evidenceFiles).values({
          incident_id: incident.id,
          file_name: file.name,
          file_type: file.mimeType,
          file_url: filePath,
          file_size: file.buffer.length,
          uploaded_by: userId,
          uploaded_at: new Date()
        })
      }

      // Audit log
      await writeAuditLog(txDb, {
        table: 'incidents',
        record_id: incident.id,
        action: 'bulk_import',
        changed_by: userId,
        old_value: null,
        new_value: JSON.stringify({ reference_no, description: meta.description })
      })

      return incident.id
    })

    const fileCount = files.filter((f) => f.path.includes(meta.description.slice(0, 10))).length

    created.push({
      id: incidentId,
      reference_no: `${meta.location.site}-${meta.date.slice(0, 7)}-0001`, // simplified
      file_count: fileCount
    })
  }

  return created
}
  • Step 6: Run tests
npm run test -- lib/incidents/bulk-import.test.ts

Expected: PASS (2/2)

  • Step 7: Commit
git add lib/incidents/bulk-import.ts lib/incidents/bulk-import.test.ts
git commit -m "feat(bulk-import): core extraction and incident creation library

Implement DeepSeek PDF analysis for incident metadata extraction and
bulk incident factory with evidence attachment. Tested with unit tests
for extraction accuracy and incident creation."

Task 2: Upload Handler API Route

Files:

  • Create: app/api/admin/bulk-import/route.ts

Interfaces:

  • Consumes: requireAdmin(), analyzePdfsWithDeepSeek(), file extraction utilities

  • Produces: HTTP 200 response with folders and extracted metadata

  • Step 1: Create API route with upload handling

// app/api/admin/bulk-import/route.ts
import { requireAdmin } from '@/lib/auth/require-admin'
import { analyzePdfsWithDeepSeek } from '@/lib/incidents/bulk-import'
import { NextRequest, NextResponse } from 'next/server'
import { createReadStream } from 'fs'
import { readdir, readFile } from 'fs/promises'
import path from 'path'
import { tmpdir } from 'os'
import { exec } from 'child_process'
import { promisify } from 'util'

const execAsync = promisify(exec)

export async function POST(request: NextRequest) {
  const user = await requireAdmin()
  if (!user) return new NextResponse('Unauthorized', { status: 401 })

  try {
    const formData = await request.formData()
    const file = formData.get('file') as File

    if (!file) {
      return NextResponse.json(
        { error: 'No file uploaded' },
        { status: 400 }
      )
    }

    // Save uploaded file to temp
    const tempDir = path.join(tmpdir(), `bulk-import-${Date.now()}`)
    const buffer = Buffer.from(await file.arrayBuffer())

    // If .zip, extract; otherwise treat as folder
    let extractDir = tempDir
    if (file.name.endsWith('.zip')) {
      await execAsync(`unzip -q "${tempDir}" -d "${extractDir}"`)
    } else {
      // Single folder upload
      extractDir = tempDir
    }

    // Scan extracted folders
    const entries = await readdir(extractDir, { withFileTypes: true })
    const folders = entries.filter((e) => e.isDirectory())

    const results = []

    for (const folder of folders) {
      const folderPath = path.join(extractDir, folder.name)
      const files = await readdir(folderPath)

      // Find PDFs
      const pdfFiles = files.filter((f) => f.endsWith('.pdf'))
      const pdfTexts: string[] = []

      for (const pdf of pdfFiles) {
        const pdfPath = path.join(folderPath, pdf)
        const buffer = await readFile(pdfPath)
        // TODO: Extract text from PDF (use pdf-parse or similar)
        pdfTexts.push('') // Placeholder
      }

      // Analyze with DeepSeek
      const metadata = await analyzePdfsWithDeepSeek(pdfTexts)

      results.push({
        id: Buffer.from(folder.name).toString('base64'),
        folder_name: folder.name,
        extracted: metadata,
        files: {
          pdfs: pdfFiles.length,
          images: files.filter((f) => /\.(jpg|jpeg|png|gif)$/i.test(f)).length,
          videos: files.filter((f) => /\.(mp4|mov|webm)$/i.test(f)).length
        },
        metadata_confidence: 0.85
      })
    }

    return NextResponse.json({
      status: 'success',
      folders: results
    })
  } catch (error) {
    console.error('Upload failed:', error)
    return NextResponse.json(
      { error: 'Upload processing failed' },
      { status: 500 }
    )
  }
}
  • Step 2: Add PDF text extraction

Install pdf-parse:

npm install pdf-parse

Add extraction to route:

import pdf from 'pdf-parse'

// In folder loop:
for (const pdfFile of pdfFiles) {
  const pdfPath = path.join(folderPath, pdfFile)
  const buffer = await readFile(pdfPath)
  const data = await pdf(buffer)
  pdfTexts.push(data.text)
}
  • Step 3: Test with sample upload

Create test with sample PDF in temp folder, POST request, verify response structure.

  • Step 4: Commit
git add app/api/admin/bulk-import/route.ts package.json
git commit -m "feat(api): bulk import upload handler

Extract uploaded folder/zip, analyze PDFs for metadata, return preview
with folder names and extracted incident data. Uses pdf-parse for text
extraction and DeepSeek for metadata analysis."

Task 3: Batch Creation API Route

Files:

  • Create: app/api/admin/bulk-import/create/route.ts

Interfaces:

  • Consumes: createBulkIncidents(), request body with folders array

  • Produces: HTTP 200 response with created incidents summary

  • Step 1: Create batch creation endpoint

// app/api/admin/bulk-import/create/route.ts
import { requireAdmin } from '@/lib/auth/require-admin'
import { createBulkIncidents, type ExtractedIncidentMetadata, type FileInfo } from '@/lib/incidents/bulk-import'
import { NextRequest, NextResponse } from 'next/server'
import { readFile } from 'fs/promises'
import path from 'path'

export async function POST(request: NextRequest) {
  const user = await requireAdmin()
  if (!user?.id) return new NextResponse('Unauthorized', { status: 401 })

  try {
    const body = await request.json()
    const { folders } = body as {
      folders: Array<{
        id: string
        folder_path: string
        description: string
        date: string
        location: { site: string; zone: string }
        incident_type?: string
        priority?: string
      }>
    }

    // Reconstruct metadata and gather files
    const metadata: ExtractedIncidentMetadata[] = []
    const allFiles: FileInfo[] = []

    for (const folder of folders) {
      metadata.push({
        description: folder.description,
        date: folder.date,
        location: folder.location,
        incident_type: folder.incident_type as any,
        priority: folder.priority as any
      })

      // Read files from folder_path
      const files = await readdir(folder.folder_path)
      for (const file of files) {
        const filePath = path.join(folder.folder_path, file)
        const buffer = await readFile(filePath)
        allFiles.push({
          path: folder.folder_path,
          name: file,
          mimeType: getMimeType(file),
          buffer
        })
      }
    }

    // Create incidents
    const created = await createBulkIncidents(metadata, user.id, allFiles)

    return NextResponse.json({
      status: 'success',
      created_incidents: created,
      total_files_imported: allFiles.length
    })
  } catch (error) {
    console.error('Batch creation failed:', error)
    return NextResponse.json(
      { error: 'Batch creation failed', details: String(error) },
      { status: 500 }
    )
  }
}

function getMimeType(filename: string): string {
  const ext = path.extname(filename).toLowerCase()
  const types: Record<string, string> = {
    '.pdf': 'application/pdf',
    '.jpg': 'image/jpeg',
    '.jpeg': 'image/jpeg',
    '.png': 'image/png',
    '.gif': 'image/gif',
    '.mp4': 'video/mp4',
    '.mov': 'video/quicktime',
    '.webm': 'video/webm'
  }
  return types[ext] || 'application/octet-stream'
}
  • Step 2: Test batch creation

Verify response includes created incidents with reference numbers and file counts.

  • Step 3: Commit
git add app/api/admin/bulk-import/create/route.ts
git commit -m "feat(api): batch incident creation endpoint

Accept array of reviewed incident metadata, create incidents with
evidence file attachment. Returns created incidents with reference
numbers and file counts for confirmation."

Task 4: Bulk Import Form Component

Files:

  • Create: components/admin/bulk-import-form.tsx

Interfaces:

  • Consumes: upload/create APIs, React state management

  • Produces: React component with upload, preview table, and controls

  • Step 1: Create form component with upload

// components/admin/bulk-import-form.tsx
'use client'

import { useState } from 'react'
import type { ExtractedIncidentMetadata } from '@/lib/incidents/bulk-import'

type FolderPreview = {
  id: string
  folder_name: string
  extracted: ExtractedIncidentMetadata
  files: { pdfs: number; images: number; videos: number }
  metadata_confidence: number
  error?: string
}

export function BulkImportForm() {
  const [folders, setFolders] = useState<FolderPreview[]>([])
  const [loading, setLoading] = useState(false)
  const [stage, setStage] = useState<'upload' | 'review' | 'success'>('upload')

  const handleUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
    const file = e.target.files?.[0]
    if (!file) return

    setLoading(true)
    try {
      const formData = new FormData()
      formData.append('file', file)

      const res = await fetch('/api/admin/bulk-import', {
        method: 'POST',
        body: formData
      })

      const data = await res.json()
      if (data.status === 'success') {
        setFolders(data.folders)
        setStage('review')
      } else {
        alert('Upload failed: ' + data.error)
      }
    } finally {
      setLoading(false)
    }
  }

  const updateFolder = (id: string, updates: Partial<FolderPreview>) => {
    setFolders((prev) =>
      prev.map((f) => (f.id === id ? { ...f, ...updates } : f))
    )
  }

  const canImport = folders.every(
    (f) => f.extracted.description && f.extracted.date && f.extracted.location.site
  )

  const handleImport = async () => {
    setLoading(true)
    try {
      const res = await fetch('/api/admin/bulk-import/create', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ folders })
      })

      const data = await res.json()
      if (data.status === 'success') {
        setStage('success')
      } else {
        alert('Import failed: ' + data.error)
      }
    } finally {
      setLoading(false)
    }
  }

  if (stage === 'upload') {
    return (
      <div className="space-y-4">
        <label className="block cursor-pointer rounded border-2 border-dashed border-gray-300 p-6 text-center hover:bg-gray-50">
          <input
            type="file"
            onChange={handleUpload}
            disabled={loading}
            className="hidden"
            accept=".zip,.7z"
          />
          <p className="text-gray-600">
            {loading ? 'Processing...' : 'Upload folder or .zip file'}
          </p>
        </label>
      </div>
    )
  }

  if (stage === 'review') {
    return (
      <div className="space-y-4">
        <h3 className="font-bold">Review Extracted Data</h3>
        <div className="overflow-x-auto">
          <table className="w-full text-sm">
            <thead>
              <tr className="border-b">
                <th className="text-left py-2">Folder</th>
                <th className="text-left py-2">Description</th>
                <th className="text-left py-2">Date</th>
                <th className="text-left py-2">Site</th>
                <th className="text-left py-2">Zone</th>
                <th className="text-left py-2">Files</th>
              </tr>
            </thead>
            <tbody>
              {folders.map((folder) => (
                <tr key={folder.id} className="border-b">
                  <td className="py-2">{folder.folder_name}</td>
                  <td className="py-2">
                    <input
                      type="text"
                      value={folder.extracted.description}
                      onChange={(e) =>
                        updateFolder(folder.id, {
                          extracted: {
                            ...folder.extracted,
                            description: e.target.value
                          }
                        })
                      }
                      className="w-full border px-2 py-1"
                    />
                  </td>
                  <td className="py-2">
                    <input
                      type="date"
                      value={folder.extracted.date}
                      onChange={(e) =>
                        updateFolder(folder.id, {
                          extracted: {
                            ...folder.extracted,
                            date: e.target.value
                          }
                        })
                      }
                      className="border px-2 py-1"
                    />
                  </td>
                  <td className="py-2">
                    <input
                      type="text"
                      value={folder.extracted.location.site}
                      onChange={(e) =>
                        updateFolder(folder.id, {
                          extracted: {
                            ...folder.extracted,
                            location: {
                              ...folder.extracted.location,
                              site: e.target.value
                            }
                          }
                        })
                      }
                      className="w-full border px-2 py-1"
                    />
                  </td>
                  <td className="py-2">
                    <input
                      type="text"
                      value={folder.extracted.location.zone}
                      onChange={(e) =>
                        updateFolder(folder.id, {
                          extracted: {
                            ...folder.extracted,
                            location: {
                              ...folder.extracted.location,
                              zone: e.target.value
                            }
                          }
                        })
                      }
                      className="w-full border px-2 py-1"
                    />
                  </td>
                  <td className="py-2">
                    {folder.files.pdfs + folder.files.images + folder.files.videos}
                  </td>
                </tr>
              ))}
            </tbody>
          </table>
        </div>
        <div className="flex gap-2">
          <button
            onClick={() => setStage('upload')}
            className="px-4 py-2 text-gray-600 hover:bg-gray-100 rounded"
          >
            Back
          </button>
          <button
            onClick={handleImport}
            disabled={!canImport || loading}
            className="px-4 py-2 bg-blue-600 text-white rounded disabled:opacity-50"
          >
            {loading ? 'Importing...' : 'Import All'}
          </button>
        </div>
      </div>
    )
  }

  return (
    <div className="space-y-4">
      <h3 className="font-bold text-green-600">✓ Import Complete</h3>
      <p>{folders.length} incidents created</p>
    </div>
  )
}
  • Step 2: Test form interactions

Verify upload, table editing, import button state (disabled if required fields empty).

  • Step 3: Commit
git add components/admin/bulk-import-form.tsx
git commit -m "feat(ui): bulk import form with preview table

Upload handler, preview table with editable metadata fields, and import
confirmation. Validates required fields before enabling import button."

Task 5: Admin Bulk Import Page

Files:

  • Create: app/(protected)/admin/bulk-import/page.tsx

Interfaces:

  • Consumes: BulkImportForm component, requireAdmin()

  • Produces: Server component page at /admin/bulk-import

  • Step 1: Create page

// app/(protected)/admin/bulk-import/page.tsx
import { requireAdmin } from '@/lib/auth/require-admin'
import { BulkImportForm } from '@/components/admin/bulk-import-form'
import { redirect } from 'next/navigation'

export const metadata = {
  title: 'Bulk Import Incidents — IMS'
}

export default async function BulkImportPage() {
  const user = await requireAdmin()
  if (!user) redirect('/login')

  return (
    <div className="max-w-4xl mx-auto p-6">
      <div className="mb-6">
        <h1 className="text-3xl font-bold mb-2">Bulk Import Incidents</h1>
        <p className="text-gray-600">
          Upload historical case folders. Each folder will become a closed incident
          with extracted metadata and attached evidence files.
        </p>
      </div>
      <BulkImportForm />
    </div>
  )
}
  • Step 2: Verify admin-only access

Test that non-admin users redirect to login.

  • Step 3: Commit
git add app/(protected)/admin/bulk-import/page.tsx
git commit -m "feat(page): admin bulk import page

Serve `/admin/bulk-import` with admin-only guard. Hosts bulk import form
for historical incident migration."

Files:

  • Modify: app/(protected)/admin/page.tsx

Interfaces:

  • Consumes: existing admin page structure

  • Produces: updated page with bulk import link

  • Step 1: Add link to bulk import

// In admin page, add to section where users/sites/trucks links are:
<Link
  href="/admin/bulk-import"
  className="block p-4 rounded-lg border hover:bg-gray-50"
>
  <h3 className="font-bold">Bulk Import</h3>
  <p className="text-sm text-gray-600">Import historical case folders</p>
</Link>
  • Step 2: Test link navigation

Click link, verify it goes to bulk import page.

  • Step 3: Commit
git add app/(protected)/admin/page.tsx
git commit -m "feat(admin): add bulk import link

Wire bulk import feature into admin panel for easy access."

Task 7: Testing & Verification

Files:

  • Create: integration tests (if separate file), or inline test in bulk-import.test.ts

  • Step 1: Write integration test

describe('Bulk Import E2E', () => {
  it('uploads folder, reviews data, creates incidents', async () => {
    // Create sample folder with PDF
    const testDir = '/tmp/test-import'
    // ... create folder structure ...

    // Upload
    const uploadRes = await fetch('/api/admin/bulk-import', ...)
    expect(uploadRes.status).toBe(200)

    // Verify extracted data
    const data = await uploadRes.json()
    expect(data.folders).toHaveLength(1)
    expect(data.folders[0].extracted.description).toBeTruthy()

    // Create incidents
    const createRes = await fetch('/api/admin/bulk-import/create', ...)
    expect(createRes.status).toBe(200)

    const result = await createRes.json()
    expect(result.created_incidents).toHaveLength(1)
    expect(result.created_incidents[0].reference_no).toMatch(/^[A-Z]+-\d{6}-\d{4}$/)
  })
})
  • Step 2: Run tests
npm run test

Expected: All tests pass (including Task 1 tests + new E2E tests)

  • Step 3: Manual testing

  • Upload sample folder with real PDFs

  • Verify DeepSeek extracts description, date, location

  • Review table shows correct data

  • Edit a field, verify it saves

  • Import, verify incidents created with correct metadata

  • Check evidence files attached to incidents

  • Verify incidents show as "Closed" in HSE incidents list

  • Step 4: Commit

git add lib/incidents/bulk-import.test.ts
git commit -m "test(bulk-import): integration and E2E tests

Verify upload handler, extraction, preview table, batch creation, and
evidence file attachment work end-to-end."

Final Deployment

  • Step 1: Build
npm run build

Expected: Clean build, no errors

  • Step 2: Deploy to VPS
rsync -avz .next/ setia@175.136.239.121:/var/www/ims/.next/
ssh setia@175.136.239.121 "sudo systemctl restart ims"
  • Step 3: Smoke test

Navigate to /admin/bulk-import, verify page loads, test upload with sample folder.


Spec Coverage

✓ Upload handler: single folder + .zip support ✓ PDF analysis: DeepSeek extraction ✓ Preview table: editable fields, required field validation ✓ Batch creation: all incidents as "Closed" ✓ Evidence attachment: files in same storage as regular incidents ✓ Audit logging: bulk_import action tracked ✓ Admin-only access: requireAdmin() on all routes/pages


Plan complete and saved to docs/superpowers/plans/2026-08-16-bulk-incident-import-implementation.md.

Two execution options:

1. Subagent-Driven (recommended) — Fresh subagent per task, review between tasks, fast iteration

2. Inline Execution — Execute tasks in this session via executing-plans, batch execution with checkpoints

Which approach?