@duypham93/openkit 0.2.0

package/.opencode/tests/work-item-store.test.js

@@ -0,0 +1,380 @@
+const test = require("node:test")
+const assert = require("node:assert/strict")
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+
+const {
+  bootstrapLegacyWorkflowState,
+  deriveWorkItemId,
+  readWorkItemIndex,
+  readWorkItemState,
+  refreshCompatibilityMirror,
+  resolveWorkItemPaths,
+  setActiveWorkItem,
+  validateActiveMirror,
+  writeWorkItemIndex,
+  writeWorkItemState,
+} = require("../lib/work-item-store")
+
+function makeTempProject() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "openkit-work-item-store-"))
+}
+
+function createFixtureState(overrides = {}) {
+  return {
+    feature_id: "FEATURE-001",
+    feature_slug: "task-intake-dashboard",
+    mode: "full",
+    mode_reason: "Feature-sized workflow example with full artifact chain and approvals",
+    routing_profile: {
+      work_intent: "feature",
+      behavior_delta: "extend",
+      dominant_uncertainty: "product",
+      scope_shape: "cross_boundary",
+      selection_reason: "Feature-sized workflow example with full artifact chain and approvals",
+    },
+    current_stage: "full_done",
+    status: "done",
+    current_owner: "MasterOrchestrator",
+    artifacts: {
+      task_card: null,
+      brief: "docs/briefs/2026-03-20-task-intake-dashboard.md",
+      spec: "docs/specs/2026-03-20-task-intake-dashboard.md",
+      architecture: "docs/architecture/2026-03-20-task-intake-dashboard.md",
+      plan: "docs/plans/2026-03-20-task-intake-dashboard.md",
+      migration_report: null,
+      qa_report: "docs/qa/2026-03-20-task-intake-dashboard.md",
+      adr: [],
+    },
+    approvals: {
+      pm_to_ba: { status: "approved", approved_by: "user", approved_at: "2026-03-20", notes: null },
+      ba_to_architect: { status: "approved", approved_by: "user", approved_at: "2026-03-20", notes: null },
+      architect_to_tech_lead: { status: "approved", approved_by: "user", approved_at: "2026-03-20", notes: null },
+      tech_lead_to_fullstack: { status: "approved", approved_by: "user", approved_at: "2026-03-20", notes: null },
+      fullstack_to_qa: { status: "approved", approved_by: "system", approved_at: "2026-03-20", notes: null },
+      qa_to_done: { status: "approved", approved_by: "user", approved_at: "2026-03-20", notes: null },
+    },
+    issues: [],
+    retry_count: 0,
+    escalated_from: null,
+    escalation_reason: null,
+    updated_at: "2026-03-20",
+    ...overrides,
+  }
+}
+
+function setupLegacyState(projectRoot, overrides = {}) {
+  const opencodeDir = path.join(projectRoot, ".opencode")
+  fs.mkdirSync(opencodeDir, { recursive: true })
+
+  const state = createFixtureState(overrides)
+  const statePath = path.join(opencodeDir, "workflow-state.json")
+  fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8")
+
+  return {
+    state,
+    statePath,
+  }
+}
+
+test("deriveWorkItemId uses a persisted id when present and otherwise derives a stable slug from feature_id", () => {
+  assert.equal(deriveWorkItemId({ work_item_id: "existing-item", feature_id: "FEATURE-001" }), "existing-item")
+  assert.equal(deriveWorkItemId({ feature_id: "FEATURE-001" }), "feature-001")
+  assert.equal(deriveWorkItemId({ feature_id: "Feature 001 / Alpha" }), "feature-001-alpha")
+})
+
+test("bootstrapLegacyWorkflowState creates index and per-item state from the compatibility file without duplicates", () => {
+  const projectRoot = makeTempProject()
+  const { state } = setupLegacyState(projectRoot)
+
+  const firstResult = bootstrapLegacyWorkflowState(projectRoot)
+  const secondResult = bootstrapLegacyWorkflowState(projectRoot)
+
+  assert.equal(firstResult.workItemId, "feature-001")
+  assert.equal(secondResult.workItemId, "feature-001")
+
+  const index = readWorkItemIndex(projectRoot)
+  assert.equal(index.active_work_item_id, "feature-001")
+  assert.equal(index.work_items.length, 1)
+  assert.deepEqual(index.work_items[0], {
+    work_item_id: "feature-001",
+    feature_id: state.feature_id,
+    feature_slug: state.feature_slug,
+    mode: state.mode,
+    status: state.status,
+    state_path: ".opencode/work-items/feature-001/state.json",
+  })
+
+  const perItemState = readWorkItemState(projectRoot, "feature-001")
+  assert.equal(perItemState.work_item_id, "feature-001")
+  assert.equal(perItemState.feature_id, state.feature_id)
+
+  const mirrorState = JSON.parse(
+    fs.readFileSync(path.join(projectRoot, ".opencode", "workflow-state.json"), "utf8"),
+  )
+  assert.equal(mirrorState.work_item_id, "feature-001")
+  assert.deepEqual(mirrorState, perItemState)
+})
+
+test("readWorkItemIndex and writeWorkItemIndex round-trip the minimal index shape", () => {
+  const projectRoot = makeTempProject()
+
+  writeWorkItemIndex(projectRoot, {
+    active_work_item_id: "feature-900",
+    work_items: [
+      {
+        work_item_id: "feature-900",
+        feature_id: "FEATURE-900",
+        feature_slug: "runtime-updates",
+        mode: "full",
+        status: "in_progress",
+        state_path: ".opencode/work-items/feature-900/state.json",
+      },
+    ],
+  })
+
+  assert.deepEqual(readWorkItemIndex(projectRoot), {
+    active_work_item_id: "feature-900",
+    work_items: [
+      {
+        work_item_id: "feature-900",
+        feature_id: "FEATURE-900",
+        feature_slug: "runtime-updates",
+        mode: "full",
+        status: "in_progress",
+        state_path: ".opencode/work-items/feature-900/state.json",
+      },
+    ],
+  })
+})
+
+test("readWorkItemState and writeWorkItemState round-trip one work item state file", () => {
+  const projectRoot = makeTempProject()
+  const state = createFixtureState({
+    work_item_id: "feature-777",
+    feature_id: "FEATURE-777",
+    feature_slug: "isolated-store-helper",
+    status: "in_progress",
+  })
+
+  writeWorkItemState(projectRoot, "feature-777", state)
+
+  const persistedState = readWorkItemState(projectRoot, "feature-777")
+  assert.deepEqual(persistedState, state)
+
+  const paths = resolveWorkItemPaths(projectRoot, "feature-777")
+  assert.equal(fs.existsSync(paths.statePath), true)
+})
+
+test("writeWorkItemState persists the stable work_item_id for general state writes", () => {
+  const projectRoot = makeTempProject()
+
+  writeWorkItemState(projectRoot, "feature-888", createFixtureState({
+    feature_id: "FEATURE-888",
+    feature_slug: "stable-id-write",
+    status: "in_progress",
+  }))
+
+  const persistedState = readWorkItemState(projectRoot, "feature-888")
+  assert.equal(persistedState.work_item_id, "feature-888")
+  assert.equal(persistedState.feature_id, "FEATURE-888")
+})
+
+test("setActiveWorkItem updates the active pointer independently of mirror refresh", () => {
+  const projectRoot = makeTempProject()
+  setupLegacyState(projectRoot)
+  bootstrapLegacyWorkflowState(projectRoot)
+
+  writeWorkItemState(projectRoot, "feature-002", createFixtureState({
+    work_item_id: "feature-002",
+    feature_id: "FEATURE-002",
+    feature_slug: "parallel-runtime",
+    status: "in_progress",
+  }))
+  writeWorkItemIndex(projectRoot, {
+    active_work_item_id: "feature-001",
+    work_items: [
+      {
+        work_item_id: "feature-001",
+        feature_id: "FEATURE-001",
+        feature_slug: "task-intake-dashboard",
+        mode: "full",
+        status: "done",
+        state_path: ".opencode/work-items/feature-001/state.json",
+      },
+      {
+        work_item_id: "feature-002",
+        feature_id: "FEATURE-002",
+        feature_slug: "parallel-runtime",
+        mode: "full",
+        status: "in_progress",
+        state_path: ".opencode/work-items/feature-002/state.json",
+      },
+    ],
+  })
+
+  setActiveWorkItem(projectRoot, "feature-002")
+
+  const index = readWorkItemIndex(projectRoot)
+  const mirrorState = JSON.parse(
+    fs.readFileSync(path.join(projectRoot, ".opencode", "workflow-state.json"), "utf8"),
+  )
+
+  assert.equal(index.active_work_item_id, "feature-002")
+  assert.equal(mirrorState.work_item_id, "feature-001")
+})
+
+test("setActiveWorkItem rejects an index entry whose state file is missing", () => {
+  const projectRoot = makeTempProject()
+  setupLegacyState(projectRoot)
+  bootstrapLegacyWorkflowState(projectRoot)
+
+  writeWorkItemIndex(projectRoot, {
+    active_work_item_id: "feature-001",
+    work_items: [
+      {
+        work_item_id: "feature-001",
+        feature_id: "FEATURE-001",
+        feature_slug: "task-intake-dashboard",
+        mode: "full",
+        status: "done",
+        state_path: ".opencode/work-items/feature-001/state.json",
+      },
+      {
+        work_item_id: "feature-404",
+        feature_id: "FEATURE-404",
+        feature_slug: "missing-state",
+        mode: "full",
+        status: "in_progress",
+        state_path: ".opencode/work-items/feature-404/state.json",
+      },
+    ],
+  })
+
+  assert.throws(() => setActiveWorkItem(projectRoot, "feature-404"), /Work-item state missing/)
+  assert.equal(readWorkItemIndex(projectRoot).active_work_item_id, "feature-001")
+})
+
+test("refreshCompatibilityMirror writes from the active per-item state and validateActiveMirror reports stale or missing mirrors", () => {
+  const projectRoot = makeTempProject()
+  setupLegacyState(projectRoot)
+  bootstrapLegacyWorkflowState(projectRoot)
+
+  writeWorkItemState(projectRoot, "feature-001", createFixtureState({
+    work_item_id: "feature-001",
+    feature_id: "FEATURE-001",
+    feature_slug: "task-intake-dashboard",
+    status: "in_progress",
+    updated_at: "2026-03-21",
+  }))
+
+  assert.throws(() => validateActiveMirror(projectRoot), /Compatibility mirror diverged/)
+
+  refreshCompatibilityMirror(projectRoot)
+  assert.doesNotThrow(() => validateActiveMirror(projectRoot))
+
+  fs.rmSync(path.join(projectRoot, ".opencode", "workflow-state.json"))
+  assert.throws(() => validateActiveMirror(projectRoot), /Compatibility mirror missing/)
+})
+
+test("validateActiveMirror accepts reordered but semantically equivalent JSON content", () => {
+  const projectRoot = makeTempProject()
+  setupLegacyState(projectRoot)
+  bootstrapLegacyWorkflowState(projectRoot)
+
+  const activeState = readWorkItemState(projectRoot, "feature-001")
+  const reorderedMirrorState = {
+    updated_at: activeState.updated_at,
+    escalation_reason: activeState.escalation_reason,
+    escalated_from: activeState.escalated_from,
+    retry_count: activeState.retry_count,
+    issues: activeState.issues,
+    approvals: {
+      qa_to_done: activeState.approvals.qa_to_done,
+      fullstack_to_qa: activeState.approvals.fullstack_to_qa,
+      tech_lead_to_fullstack: activeState.approvals.tech_lead_to_fullstack,
+      architect_to_tech_lead: activeState.approvals.architect_to_tech_lead,
+      ba_to_architect: activeState.approvals.ba_to_architect,
+      pm_to_ba: activeState.approvals.pm_to_ba,
+    },
+    artifacts: {
+      adr: activeState.artifacts.adr,
+      qa_report: activeState.artifacts.qa_report,
+      migration_report: activeState.artifacts.migration_report,
+      plan: activeState.artifacts.plan,
+      architecture: activeState.artifacts.architecture,
+      spec: activeState.artifacts.spec,
+      brief: activeState.artifacts.brief,
+      task_card: activeState.artifacts.task_card,
+    },
+    current_owner: activeState.current_owner,
+    status: activeState.status,
+    current_stage: activeState.current_stage,
+    routing_profile: {
+      selection_reason: activeState.routing_profile.selection_reason,
+      scope_shape: activeState.routing_profile.scope_shape,
+      dominant_uncertainty: activeState.routing_profile.dominant_uncertainty,
+      behavior_delta: activeState.routing_profile.behavior_delta,
+      work_intent: activeState.routing_profile.work_intent,
+    },
+    mode_reason: activeState.mode_reason,
+    mode: activeState.mode,
+    feature_slug: activeState.feature_slug,
+    feature_id: activeState.feature_id,
+    work_item_id: activeState.work_item_id,
+  }
+
+  fs.writeFileSync(
+    path.join(projectRoot, ".opencode", "workflow-state.json"),
+    `${JSON.stringify(reorderedMirrorState, null, 2)}\n`,
+    "utf8",
+  )
+
+  assert.doesNotThrow(() => validateActiveMirror(projectRoot))
+})
+
+test("activating a different work item and refreshing the mirror rewrites compatibility state from the new active item", () => {
+  const projectRoot = makeTempProject()
+  setupLegacyState(projectRoot)
+  bootstrapLegacyWorkflowState(projectRoot)
+
+  writeWorkItemState(projectRoot, "feature-002", createFixtureState({
+    feature_id: "FEATURE-002",
+    feature_slug: "parallel-runtime",
+    status: "in_progress",
+    updated_at: "2026-03-21",
+  }))
+  writeWorkItemIndex(projectRoot, {
+    active_work_item_id: "feature-001",
+    work_items: [
+      {
+        work_item_id: "feature-001",
+        feature_id: "FEATURE-001",
+        feature_slug: "task-intake-dashboard",
+        mode: "full",
+        status: "done",
+        state_path: ".opencode/work-items/feature-001/state.json",
+      },
+      {
+        work_item_id: "feature-002",
+        feature_id: "FEATURE-002",
+        feature_slug: "parallel-runtime",
+        mode: "full",
+        status: "in_progress",
+        state_path: ".opencode/work-items/feature-002/state.json",
+      },
+    ],
+  })
+
+  setActiveWorkItem(projectRoot, "feature-002")
+  refreshCompatibilityMirror(projectRoot)
+
+  const mirrorState = JSON.parse(
+    fs.readFileSync(path.join(projectRoot, ".opencode", "workflow-state.json"), "utf8"),
+  )
+  assert.equal(mirrorState.work_item_id, "feature-002")
+  assert.equal(mirrorState.feature_id, "FEATURE-002")
+  assert.equal(mirrorState.feature_slug, "parallel-runtime")
+  assert.equal(mirrorState.updated_at, "2026-03-21")
+})

package/.opencode/tests/workflow-behavior.test.js

@@ -0,0 +1,149 @@
+const test = require("node:test")
+const assert = require("node:assert/strict")
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { spawnSync } = require("child_process")
+
+const {
+  advanceStage,
+  routeRework,
+  startTask,
+  validateState,
+} = require("../lib/workflow-state-controller")
+
+function makeTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "openkit-workflow-behavior-"))
+}
+
+function loadFixtureState() {
+  const fixturePath = path.resolve(__dirname, "../workflow-state.json")
+  return JSON.parse(fs.readFileSync(fixturePath, "utf8"))
+}
+
+function createTempStateFile() {
+  const dir = makeTempDir()
+  const opencodeDir = path.join(dir, ".opencode")
+  fs.mkdirSync(opencodeDir, { recursive: true })
+  const statePath = path.join(opencodeDir, "workflow-state.json")
+  fs.writeFileSync(statePath, `${JSON.stringify(loadFixtureState(), null, 2)}\n`, "utf8")
+  return statePath
+}
+
+function writeManifest(projectRoot) {
+  const opencodeDir = path.join(projectRoot, ".opencode")
+  fs.mkdirSync(opencodeDir, { recursive: true })
+  fs.writeFileSync(
+    path.join(opencodeDir, "opencode.json"),
+    `${JSON.stringify({
+      kit: {
+        name: "OpenKit AI Software Factory",
+        version: "0.1.0",
+        entryAgent: "MasterOrchestrator",
+      },
+    }, null, 2)}\n`,
+    "utf8",
+  )
+}
+
+test("quick requirement gaps escalate to full_intake with full-mode approvals", () => {
+  const statePath = createTempStateFile()
+
+  startTask("quick", "TASK-300", "needs-clarification", "Started as a bounded quick task", statePath)
+  const result = routeRework("requirement_gap", false, statePath)
+
+  assert.equal(result.state.mode, "full")
+  assert.equal(result.state.current_stage, "full_intake")
+  assert.equal(result.state.current_owner, "MasterOrchestrator")
+  assert.equal(result.state.escalated_from, "quick")
+  assert.match(result.state.escalation_reason, /requirement_gap/)
+  assert.equal(Object.hasOwn(result.state.approvals, "quick_verified"), false)
+  assert.equal(result.state.approvals.pm_to_ba.status, "pending")
+  assert.equal(result.state.approvals.qa_to_done.status, "pending")
+})
+
+test("quick stage advancement preserves the canonical owner chain", () => {
+  const statePath = createTempStateFile()
+
+  startTask("quick", "TASK-301", "owner-chain", "Follow quick-stage ownership", statePath)
+  let result = validateState(statePath)
+  assert.equal(result.state.current_stage, "quick_intake")
+  assert.equal(result.state.current_owner, "MasterOrchestrator")
+
+  result = advanceStage("quick_plan", statePath)
+  assert.equal(result.state.current_stage, "quick_plan")
+  assert.equal(result.state.current_owner, "MasterOrchestrator")
+
+  result = advanceStage("quick_build", statePath)
+  assert.equal(result.state.current_stage, "quick_build")
+  assert.equal(result.state.current_owner, "FullstackAgent")
+
+  result = advanceStage("quick_verify", statePath)
+  assert.equal(result.state.current_stage, "quick_verify")
+  assert.equal(result.state.current_owner, "QAAgent")
+})
+
+test("full workflows start in full_intake with full-mode state", () => {
+  const statePath = createTempStateFile()
+
+  startTask("full", "FEATURE-301", "full-workflow", "Feature-sized workflow", statePath)
+  const result = validateState(statePath)
+
+  assert.equal(result.state.mode, "full")
+  assert.equal(result.state.current_stage, "full_intake")
+  assert.notEqual(result.state.current_stage, "quick_intake")
+  assert.equal(result.state.escalated_from, null)
+})
+
+test("migration workflows start in migration_intake with migration-mode state", () => {
+  const statePath = createTempStateFile()
+
+  startTask("migration", "MIGRATE-301", "react-refresh", "Framework upgrade workflow", statePath)
+  const result = validateState(statePath)
+
+  assert.equal(result.state.mode, "migration")
+  assert.equal(result.state.current_stage, "migration_intake")
+  assert.notEqual(result.state.current_stage, "quick_intake")
+  assert.notEqual(result.state.current_stage, "full_intake")
+  assert.equal(result.state.escalated_from, null)
+})
+
+test("session-start resume hints stay aligned with full stage names", () => {
+  const projectRoot = makeTempDir()
+  const opencodeDir = path.join(projectRoot, ".opencode")
+  fs.mkdirSync(opencodeDir, { recursive: true })
+  writeManifest(projectRoot)
+
+  const state = loadFixtureState()
+  state.feature_id = "FEATURE-302"
+  state.feature_slug = "full-qa-resume"
+  state.mode = "full"
+  state.routing_profile = {
+    work_intent: "feature",
+    behavior_delta: "extend",
+    dominant_uncertainty: "product",
+    scope_shape: "cross_boundary",
+    selection_reason: "full qa resume",
+  }
+  state.current_stage = "full_qa"
+  state.current_owner = "QAAgent"
+  state.status = "in_progress"
+  fs.writeFileSync(path.join(opencodeDir, "workflow-state.json"), `${JSON.stringify(state, null, 2)}\n`, "utf8")
+
+  const result = spawnSync(path.resolve(__dirname, "../../hooks/session-start"), {
+    cwd: projectRoot,
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      OPENKIT_PROJECT_ROOT: projectRoot,
+      OPENKIT_SESSION_START_NO_SKILL: "1",
+      OPENKIT_WORKFLOW_STATE: path.join(projectRoot, ".opencode", "workflow-state.json"),
+    },
+  })
+
+  assert.equal(result.status, 0)
+  assert.match(result.stdout, /mode: full/)
+  assert.match(result.stdout, /stage: full_qa/)
+  assert.match(result.stdout, /owner: QAAgent/)
+  assert.match(result.stdout, /work item: FEATURE-302 \(full-qa-resume\)/)
+})