ostacky 0.4.0 → 0.5.0

package/assets/mcp/ostacky-controller/controller.test.mjs

@@ -0,0 +1,447 @@
+import { mkdtemp, rm, writeFile, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  OstackyController,
+  buildExecutionSnapshot,
+  RESULTS,
+  STATES,
+} from "./index.js";
+
+describe("OstackyController", () => {
+  let stateDir;
+
+  beforeEach(async () => {
+    stateDir = await mkdtemp(join(tmpdir(), "ostacky-controller-"));
+  });
+
+  afterEach(async () => {
+    await rm(stateDir, { recursive: true, force: true });
+  });
+
+  it("consumes the route decision once and authorizes the selected route", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    const started = await controller.startRequest({ requestId: "req-1" });
+    const discovered = await controller.recordDiscovery({
+      level: "0+1",
+      routeDecisionId: "route-1",
+    });
+
+    assert.strictEqual(started.state, STATES.INTERPRETATION_PENDING);
+    assert.strictEqual(discovered.state, STATES.ROUTE_DECISION_PENDING);
+
+    const selected = await controller.consumeRouteDecision({
+      decisionId: "route-1",
+      choice: "SPEC",
+    });
+
+    assert.strictEqual(selected.status, RESULTS.OK);
+    assert.strictEqual(selected.state, STATES.SPECIFICATION);
+    assert.strictEqual((await controller.authorize("openspec-propose")).status, RESULTS.OK);
+
+    const repeated = await controller.consumeRouteDecision({
+      decisionId: "route-1",
+      choice: "DIRECT",
+    });
+
+    assert.strictEqual(repeated.status, RESULTS.DECISION_ALREADY_CONSUMED);
+    assert.strictEqual(repeated.state, STATES.SPECIFICATION);
+  });
+
+  it("rejects side effects before a valid route decision", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    await controller.startRequest({ requestId: "req-2" });
+
+    const result = await controller.authorize("openspec-propose");
+
+    assert.strictEqual(result.status, RESULTS.INVALID_TRANSITION);
+  });
+
+  it("validates editable, already-applied, and conflicting edits", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+
+    assert.strictEqual(
+      controller.validateEdit({
+        oldString: "old",
+        newString: "new",
+        content: "before old after",
+      }).status,
+      RESULTS.EDITABLE,
+    );
+
+    assert.strictEqual(
+      controller.validateEdit({
+        oldString: "same",
+        newString: "same",
+        content: "same",
+      }).status,
+      RESULTS.ALREADY_APPLIED,
+    );
+
+    assert.strictEqual(
+      controller.validateEdit({
+        oldString: "old",
+        newString: "new",
+        content: "before new after",
+      }).status,
+      RESULTS.ALREADY_APPLIED,
+    );
+
+    assert.strictEqual(
+      controller.validateEdit({
+        oldString: "old",
+        newString: "new",
+        content: "unchanged",
+      }).status,
+      RESULTS.CONFLICT,
+    );
+  });
+
+  it("persists state and restores it in a new controller instance", async () => {
+    const statePath = join(stateDir, "state.json");
+    const first = new OstackyController({ statePath });
+    await first.startRequest({ requestId: "req-3", changeId: "change-3" });
+    await first.recordDiscovery({ level: "1+", routeDecisionId: "route-3" });
+    await first.consumeRouteDecision({ decisionId: "route-3", choice: "DIRECT" });
+
+    const restored = new OstackyController({ statePath });
+    const state = await restored.getState();
+
+    assert.strictEqual(state.requestId, "req-3");
+    assert.strictEqual(state.changeId, "change-3");
+    assert.strictEqual(state.state, STATES.EXECUTION_ANALYSIS);
+  });
+
+  it("resumes active flow without resetting on repeated startRequest", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    await controller.startRequest({ requestId: "req-4" });
+    await controller.recordDiscovery({ level: "0+1", routeDecisionId: "route-4" });
+    await controller.consumeRouteDecision({ decisionId: "route-4", choice: "SPEC" });
+
+    // Second startRequest on existing flow — should resume, not reset
+    const resume = await controller.startRequest({ requestId: "req-5" });
+
+    assert.strictEqual(resume.state, STATES.SPECIFICATION);
+    assert.strictEqual(resume.requestId, "req-4"); // preserved original
+  });
+
+  it("rejects duplicate route decision consumption with same decisionId", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    await controller.startRequest({ requestId: "req-6" });
+    await controller.recordDiscovery({ level: "0+1", routeDecisionId: "route-6" });
+
+    const first = await controller.consumeRouteDecision({ decisionId: "route-6", choice: "SPEC" });
+    assert.strictEqual(first.status, RESULTS.OK);
+
+    const second = await controller.consumeRouteDecision({ decisionId: "route-6", choice: "SPEC" });
+    assert.strictEqual(second.status, RESULTS.DECISION_ALREADY_CONSUMED);
+
+    const third = await controller.consumeRouteDecision({ decisionId: "route-6", choice: "DIRECT" });
+    assert.strictEqual(third.status, RESULTS.DECISION_ALREADY_CONSUMED);
+    assert.strictEqual(third.state, STATES.SPECIFICATION); // still SPEC
+  });
+
+  it("rejects consumeRouteDecision with wrong decision ID", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    await controller.startRequest({ requestId: "req-7" });
+    await controller.recordDiscovery({ level: "0+1", routeDecisionId: "route-7" });
+
+    const result = await controller.consumeRouteDecision({ decisionId: "wrong-id", choice: "SPEC" });
+    assert.strictEqual(result.status, RESULTS.INVALID_TRANSITION);
+    assert.match(result.reason, /Decision ID mismatch/);
+  });
+
+  it("supports clarification flow: interpret → clarify → discover", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    await controller.startRequest({ requestId: "req-8" });
+
+    const clarified = await controller.requestClarification({ question: "What area?" });
+    assert.strictEqual(clarified.state, STATES.CLARIFICATION_PENDING);
+
+    const answered = await controller.recordClarification();
+    assert.strictEqual(answered.state, STATES.DISCOVERY);
+
+    const discovered = await controller.recordDiscovery({ level: "1+", routeDecisionId: "route-8" });
+    assert.strictEqual(discovered.state, STATES.ROUTE_DECISION_PENDING);
+  });
+
+  it("supports cancel flow via block", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    await controller.startRequest({ requestId: "req-9" });
+
+    const blocked = await controller.block({ reason: "Cancelled by user" });
+    assert.strictEqual(blocked.state, STATES.BLOCKED);
+
+    const state = await controller.getState();
+    assert.strictEqual(state.error, "Cancelled by user");
+  });
+
+  it("supports replan from BLOCKED back to INTERPRETATION_PENDING", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    await controller.startRequest({ requestId: "req-10", changeId: "change-10" });
+    await controller.block({ reason: "Blocked" });
+
+    const replanned = await controller.replan({ reason: "Retry with new approach" });
+    assert.strictEqual(replanned.state, STATES.INTERPRETATION_PENDING);
+
+    const state = await controller.getState();
+    // Replan preserves requestId and changeId but resets workflow
+    assert.strictEqual(state.requestId, "req-10");
+    assert.strictEqual(state.changeId, "change-10");
+    assert.strictEqual(state.routeDecisionId, null);
+    assert.strictEqual(state.routeChoice, null);
+  });
+
+  it("records execution analysis and consumes execution decision", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    await controller.startRequest({ requestId: "req-11" });
+    await controller.recordDiscovery({ level: "0+1", routeDecisionId: "route-11" });
+    await controller.consumeRouteDecision({ decisionId: "route-11", choice: "DIRECT" });
+
+    // Now in EXECUTION_ANALYSIS
+    const analysis = await controller.recordExecutionAnalysis({
+      executionDecisionId: "exec-11",
+      snapshot: {
+        recommendation: "INLINE",
+        sharedFiles: ["assets/agents/ostacky.md"],
+        estimatedLines: 30,
+        reasons: ["Single file change, no subagent overhead"],
+      },
+    });
+    assert.strictEqual(analysis.state, STATES.EXECUTION_DECISION_PENDING);
+    assert.strictEqual(analysis.executionDecisionId, "exec-11");
+
+    const confirmed = await controller.consumeExecutionDecision({
+      decisionId: "exec-11",
+      mode: "INLINE",
+    });
+    assert.strictEqual(confirmed.status, RESULTS.OK);
+    assert.strictEqual(confirmed.state, STATES.EXECUTING_INLINE);
+    assert.strictEqual(confirmed.executionMode, "INLINE");
+    assert.ok(confirmed.allowedActions.includes("execution-start"));
+  });
+
+  it("rejects stale revisions via validateSnapshot", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    const before = await controller.getState();
+    const revBefore = before.revision;
+
+    await controller.startRequest({ requestId: "req-12" });
+
+    const after = await controller.getState();
+    const revAfter = after.revision;
+
+    // Revision changed after mutation
+    assert.notStrictEqual(revAfter, revBefore);
+
+    // Old revision should be stale
+    const valid = await controller.validateSnapshot(revBefore);
+    assert.strictEqual(valid.valid, false);
+    assert.strictEqual(valid.currentRevision, revAfter);
+  });
+
+  it("enforces recommendation → user confirmation → execution mode consistency (cannot diverge)", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    await controller.startRequest({ requestId: "req-14" });
+    await controller.recordDiscovery({ level: "0+1", routeDecisionId: "route-14" });
+    await controller.consumeRouteDecision({ decisionId: "route-14", choice: "DIRECT" });
+
+    // Record analysis with INLINE recommendation
+    await controller.recordExecutionAnalysis({
+      executionDecisionId: "exec-14",
+      snapshot: buildExecutionSnapshot({
+        recommendation: "INLINE",
+        filesPerTask: { "1": ["a.ts"] },
+        sharedFiles: {},
+        fileClusters: [["1"]],
+        taskCount: 1,
+        clusterCount: 1,
+        estLines: 5,
+        reasons: ["Single task, no shared files"],
+      }),
+    });
+
+    // User confirms SUBAGENT_DRIVEN despite INLINE recommendation — user is the authority
+    const confirmed = await controller.consumeExecutionDecision({
+      decisionId: "exec-14",
+      mode: "SUBAGENT_DRIVEN",
+    });
+    assert.strictEqual(confirmed.status, RESULTS.OK);
+    assert.strictEqual(confirmed.state, STATES.EXECUTING_SUBAGENTS);
+    assert.strictEqual(confirmed.executionMode, "SUBAGENT_DRIVEN");
+
+    // Verify persisted mode matches confirmed mode (not recommendation)
+    const state = await controller.getState();
+    assert.strictEqual(state.executionMode, "SUBAGENT_DRIVEN");
+    // The recommendation is still stored in the snapshot
+    assert.strictEqual(state.snapshots.execution.recommendation, "INLINE");
+  });
+
+  it("prevents execution start without an execution decision", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    await controller.startRequest({ requestId: "req-15" });
+    await controller.recordDiscovery({ level: "1+", routeDecisionId: "route-15" });
+    await controller.consumeRouteDecision({ decisionId: "route-15", choice: "SPEC" });
+    await controller.specComplete();
+    // In EXECUTION_ANALYSIS now — no decision consumed yet
+
+    // Try to authorize execution-start before confirmation
+    const auth = await controller.authorize("execution-start");
+    assert.strictEqual(auth.status, RESULTS.INVALID_TRANSITION);
+    assert.strictEqual(auth.allowed, false);
+  });
+
+  it("gates edit authorization on EDITABLE validation result", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    await controller.startRequest({ requestId: "req-16" });
+    await controller.recordDiscovery({ level: "0+1", routeDecisionId: "route-16" });
+    await controller.consumeRouteDecision({ decisionId: "route-16", choice: "DIRECT" });
+    await controller.recordExecutionAnalysis({
+      executionDecisionId: "exec-16",
+      snapshot: { recommendation: "INLINE", sharedFiles: {}, estLines: 5, reasons: [] },
+    });
+    await controller.consumeExecutionDecision({ decisionId: "exec-16", mode: "INLINE" });
+
+    // Authorize with ALREADY_APPLIED — should be rejected
+    const badAuth = await controller.authorize("edit", { editResult: RESULTS.ALREADY_APPLIED });
+    assert.strictEqual(badAuth.status, RESULTS.ACTION_NOT_AUTHORIZED);
+    assert.strictEqual(badAuth.allowed, false);
+
+    // Authorize with EDITABLE — should pass
+    const goodAuth = await controller.authorize("edit", { editResult: RESULTS.EDITABLE });
+    assert.strictEqual(goodAuth.status, RESULTS.OK);
+    assert.strictEqual(goodAuth.allowed, true);
+
+    // Authorize without editResult — should be rejected
+    const noResultAuth = await controller.authorize("edit");
+    assert.strictEqual(noResultAuth.status, RESULTS.ACTION_NOT_AUTHORIZED);
+
+
+    // Authorize with CONFLICT — should be rejected
+    const conflictAuth = await controller.authorize("edit", { editResult: RESULTS.CONFLICT });
+    assert.strictEqual(conflictAuth.status, RESULTS.ACTION_NOT_AUTHORIZED);
+  });
+
+  it("authorizes task-complete and sync only from correct states", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    // From INTERPRETATION_PENDING — no ops authorized
+    assert.strictEqual((await controller.authorize("task-complete")).status, RESULTS.INVALID_TRANSITION);
+    assert.strictEqual((await controller.authorize("sync")).status, RESULTS.INVALID_TRANSITION);
+  });
+
+  it("buildExecutionSnapshot validates recommendation field", () => {
+    assert.throws(
+      () => buildExecutionSnapshot({ recommendation: "INVALID" }),
+      /Invalid recommendation/,
+    );
+
+    const valid = buildExecutionSnapshot({ recommendation: "INLINE", estLines: 10 });
+    assert.strictEqual(valid.recommendation, "INLINE");
+    assert.strictEqual(valid.estLines, 10);
+    assert.strictEqual(valid.taskCount, 0); // default
+    assert.deepStrictEqual(valid.filesPerTask, {});
+  });
+
+  it("records and retrieves CodeGraph snapshots for phase reuse", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+
+    await controller.recordCodegraphSnapshot({
+      context: { symbols: ["AuthService"], files: ["src/auth.ts"] },
+      calls: ["codegraph_context"],
+    });
+
+    const snapshot = await controller.getCodegraphSnapshot();
+    assert.ok(snapshot);
+    assert.ok(snapshot.capturedAt);
+    assert.deepStrictEqual(snapshot.data.context.symbols, ["AuthService"]);
+  });
+
+  it("detects stale file fingerprints and returns REPLAN_REQUIRED", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    // Use the revision after a state transition (startRequest increments revision)
+    await controller.startRequest({ requestId: "req-fp" });
+    const rev = (await controller.getState()).revision;
+
+    // Record fingerprints for a file
+    await controller.recordFileFingerprints({
+      "src/auth.ts": { mtime: 1000, size: 500 },
+    });
+
+    // Same fingerprints — valid
+    const valid = await controller.validateSnapshot(rev, {
+      "src/auth.ts": { mtime: 1000, size: 500 },
+    });
+    assert.strictEqual(valid.valid, true);
+
+    // Changed mtime — stale
+    const stale = await controller.validateSnapshot(rev, {
+      "src/auth.ts": { mtime: 2000, size: 500 },
+    });
+    assert.strictEqual(stale.valid, false);
+    assert.strictEqual(stale.status, RESULTS.REPLAN_REQUIRED);
+    assert.deepStrictEqual(stale.staleFingerprints, ["src/auth.ts"]);
+  });
+
+  it("records and retrieves Engram keys for boundary persistence", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+
+    await controller.recordEngramKey({
+      changeKey: "change/redesign-ostacky-orchestration",
+      taskKey: "task/controller-core",
+    });
+
+    const keys = await controller.getEngramKeys();
+    assert.strictEqual(keys.changeKey, "change/redesign-ostacky-orchestration");
+    assert.strictEqual(keys.taskKey, "task/controller-core");
+  });
+
+  it("increments and retrieves instrumentation counters", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+
+    const val1 = await controller.incrementCounter("codegraph_calls");
+    assert.strictEqual(val1, 1);
+
+    const val2 = await controller.incrementCounter("codegraph_calls");
+    assert.strictEqual(val2, 2);
+
+    const val3 = await controller.incrementCounter("subagent_dispatches", 3);
+    assert.strictEqual(val3, 3);
+
+    const counters = await controller.getCounters();
+    assert.strictEqual(counters.codegraph_calls, 2);
+    assert.strictEqual(counters.subagent_dispatches, 3);
+
+    await controller.resetCounters();
+    const empty = await controller.getCounters();
+    assert.deepStrictEqual(empty, {});
+  });
+
+  it("supports complete task lifecycle: execute, complete task, sync, done", async () => {
+    const controller = new OstackyController({ statePath: join(stateDir, "state.json") });
+    await controller.startRequest({ requestId: "req-13" });
+    await controller.recordDiscovery({ level: "0+1", routeDecisionId: "route-13" });
+    await controller.consumeRouteDecision({ decisionId: "route-13", choice: "DIRECT" });
+    await controller.recordExecutionAnalysis({
+      executionDecisionId: "exec-13",
+      snapshot: { recommendation: "INLINE", sharedFiles: [], estimatedLines: 10, reasons: [] },
+    });
+    await controller.consumeExecutionDecision({ decisionId: "exec-13", mode: "INLINE" });
+
+    const taskResult = await controller.completeTask({ taskId: "task-1", note: "Implemented controller" });
+    assert.strictEqual(taskResult.status, RESULTS.OK);
+    assert.ok(taskResult.taskState.completedAt);
+
+    const tasks = await controller.getTasks();
+    assert.ok(tasks["task-1"]);
+    assert.strictEqual(tasks["task-1"].note, "Implemented controller");
+
+    // Complete implementation, sync, mark done
+    const implDone = await controller.implementationComplete();
+    assert.strictEqual(implDone.state, STATES.SYNC);
+
+    const syncDone = await controller.syncComplete();
+    assert.strictEqual(syncDone.state, STATES.DONE);
+  });
+});