jorgex-stack 1.0.2 → 1.0.4

package/stack/plugins/opencode/goal/command.ts

@@ -0,0 +1,255 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { GoalRecord, GoalStatus, GoalStore, NextAction } from "./types.js";
+import { assertSafeArtifactPath, createMasterArtifacts } from "./artifacts.js";
+
+const COMMANDS = new Set(["status", "plan", "history", "pause", "resume", "cancel", "merged"]);
+const EXPLICITLY_UNSUPPORTED = new Set(["quick", "work"]);
+
+export interface GoalCommandHandlersOptions {
+  store: GoalStore;
+  project: string;
+  artifactsRootDir?: string;
+}
+
+export interface GoalCommandResponse {
+  message: string;
+}
+
+export interface GoalCommandHandlers {
+  handleGoalCommand(input: string): GoalCommandResponse;
+}
+
+export function createGoalCommandHandlers(options: GoalCommandHandlersOptions): GoalCommandHandlers {
+  let currentGoalId: string | undefined;
+
+  const currentGoal = () => {
+    const byId = currentGoalId ? options.store.getGoal(currentGoalId) : undefined;
+    const active = byId ?? options.store.getCurrentGoal(options.project);
+    currentGoalId = active?.id ?? currentGoalId;
+    return active;
+  };
+
+  const requireCurrentGoal = () => {
+    const goal = currentGoal();
+    if (!goal) {
+      throw new Error("No active goal found. Start one with /goal <objective>.");
+    }
+    return goal;
+  };
+
+  return {
+    handleGoalCommand(rawInput: string): GoalCommandResponse {
+      const input = rawInput.trim();
+      const [firstToken = "", ...args] = input.split(/\s+/);
+      const firstLower = firstToken.toLowerCase();
+      const normalized = firstLower === "merged" ? "merged" : input.toLowerCase();
+
+      if (input.length === 0) {
+        throw new Error("Goal objective cannot be empty.");
+      }
+
+      if (EXPLICITLY_UNSUPPORTED.has(normalized)) {
+        throw new Error("/goal quick and /goal work are not supported. Use /goal <objective> for large goals.");
+      }
+
+      if (!COMMANDS.has(normalized)) {
+        let artifactRootDir: string | undefined;
+        const goal = options.store.transaction(() => {
+          const createdGoal = options.store.createGoal({
+            objective: input,
+            project: options.project,
+          });
+          artifactRootDir = options.artifactsRootDir
+            ? path.join(options.artifactsRootDir, createdGoal.id)
+            : undefined;
+          try {
+            if (artifactRootDir) {
+              createMasterArtifacts({
+                store: options.store,
+                goalId: createdGoal.id,
+                rootDir: artifactRootDir,
+                allowedRootDir: options.artifactsRootDir,
+              });
+            }
+            options.store.appendEvent(createdGoal.id, {
+              type: "goal.created",
+              message: `Goal created: ${createdGoal.objective}`,
+              data: { objective: createdGoal.objective, project: createdGoal.project },
+            });
+          } catch (error) {
+            let cleanupFailure: string | undefined;
+            if (artifactRootDir && options.artifactsRootDir) {
+              cleanupFailure = cleanupBootstrappedArtifactDir(artifactRootDir, options.artifactsRootDir);
+            }
+            const rootCause = error instanceof Error ? error.message : String(error);
+            throw new Error(
+              `Goal bootstrap failed: ${rootCause}${cleanupFailure ? ` Cleanup also failed: ${cleanupFailure}` : ""}`,
+            );
+          }
+          return createdGoal;
+        });
+        currentGoalId = goal.id;
+
+        return {
+          message: `Goal created: ${goal.objective}\nStatus: ${goal.status}\nNext action: ${formatNextAction(options.store.nextAction(goal.id))}`,
+        };
+      }
+
+      if (normalized === "status") return statusResponse(currentGoal(), options.store);
+      if (normalized === "plan") {
+        return planResponse(requireCurrentGoal(), options.store, options.artifactsRootDir);
+      }
+      if (normalized === "history") return historyResponse(requireCurrentGoal(), options.store);
+
+      const goal = requireCurrentGoal();
+      if (normalized === "pause") {
+        return transitionResponse(options.store, goal, "paused", "Goal paused by user.");
+      }
+      if (normalized === "resume") {
+        if (goal.status === "waiting_for_merge") {
+          throw new Error("Cannot resume while the goal is waiting for an external PR merge.");
+        }
+
+        const nextStatus = options.store.getOpenPullRequest(goal.id) ? "waiting_for_merge" : "active";
+        return transitionResponse(options.store, goal, nextStatus, "Goal resumed by user.");
+      }
+      if (normalized === "cancel") {
+        return transitionResponse(options.store, goal, "cancelled", "Goal cancelled by user.");
+      }
+      if (normalized === "merged") {
+        return mergedResponse(options.store, goal, args.join(" "));
+      }
+
+      throw new Error(`Unsupported /goal command: ${input}`);
+    },
+  };
+}
+
+function statusResponse(goal: GoalRecord | undefined, store: GoalStore): GoalCommandResponse {
+  if (!goal) {
+    return { message: "No active goal. Start one with /goal <objective>." };
+  }
+
+  const lines = [
+      `Goal: ${goal.objective}`,
+      `Status: ${goal.status}`,
+      `Next action: ${formatNextAction(store.nextAction(goal.id))}`,
+    ];
+  const issue = latestAutoContinueIssue(store, goal.id);
+  if (issue) lines.push(`Operational issue: ${issue.message}`);
+
+  return {
+    message: lines.join("\n"),
+  };
+}
+
+function planResponse(goal: GoalRecord, store: GoalStore, artifactsRootDir: string | undefined): GoalCommandResponse {
+  const plan = store.getArtifact(goal.id, "plan");
+  if (plan) {
+    if (!fs.existsSync(plan.path)) {
+      throw new Error(`Registered goal plan is not readable at ${plan.path}. Recreate or fix the artifact path.`);
+    }
+    if (artifactsRootDir) {
+      assertSafeArtifactPath(plan.path, artifactsRootDir, "Registered goal plan");
+    }
+    return {
+      message: [`Plan for goal: ${goal.objective}`, fs.readFileSync(plan.path, "utf8")].join("\n\n"),
+    };
+  }
+
+  if (artifactsRootDir) {
+    throw new Error("Goal master plan artifact is not registered. Recreate or repair the goal artifacts.");
+  }
+
+  return {
+    message: [
+      `Plan for goal: ${goal.objective}`,
+      "Phases: master PRD/plan generation, slice execution, PR review, waiting for merge, final verification.",
+      "Detailed master artifacts are created by the next Goal Mode slice.",
+    ].join("\n"),
+  };
+}
+
+function cleanupBootstrappedArtifactDir(rootDir: string, allowedRootDir: string): string | undefined {
+  try {
+    assertSafeArtifactPath(rootDir, allowedRootDir, "Goal artifact cleanup path");
+    fs.rmSync(rootDir, { recursive: true, force: true });
+    return undefined;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+
+function mergedResponse(store: GoalStore, goal: GoalRecord, mergeCommit: string): GoalCommandResponse {
+  const pullRequest = store.getOpenPullRequest(goal.id);
+  if (!pullRequest) {
+    throw new Error("No open pull request is waiting for merge.");
+  }
+
+  const merged = store.recordPullRequestMerged(pullRequest.id, {
+    mergedAt: new Date().toISOString(),
+    mergeCommit: mergeCommit.trim() || "manual",
+  });
+
+  return {
+    message: `Pull request #${merged.number} marked as merged. Goal status: ${store.getGoal(goal.id)?.status ?? "unknown"}`,
+  };
+}
+
+function historyResponse(goal: GoalRecord, store: GoalStore): GoalCommandResponse {
+  const events = store.listEvents(goal.id);
+  const lines = events.length === 0
+    ? ["No history events recorded yet."]
+    : events.map((event) => `- ${event.createdAt} ${event.type}: ${event.message}`);
+
+  return {
+    message: [`History for goal: ${goal.objective}`, ...lines].join("\n"),
+  };
+}
+
+function transitionResponse(
+  store: GoalStore,
+  goal: GoalRecord,
+  status: GoalStatus,
+  reason: string,
+): GoalCommandResponse {
+  const updated = store.transitionGoal(goal.id, status, { reason });
+  return {
+    message: `Goal ${updated.status}: ${updated.objective}`,
+  };
+}
+
+function latestAutoContinueIssue(store: GoalStore, goalId: string) {
+  const events = store.listEvents(goalId);
+  const currentStateSequence = Math.max(
+    0,
+    ...events
+      .filter((event) => !event.type.startsWith("goal.auto_continue_"))
+      .map((event) => event.sequence),
+  );
+  return events
+    .filter((event) =>
+      (
+        event.type === "goal.auto_continue_unavailable" ||
+        event.type === "goal.auto_continue_failed" ||
+        event.type === "goal.auto_continue_skipped"
+      ) &&
+      readEventStateSequence(event.data) === currentStateSequence,
+    )
+    .at(-1);
+}
+
+function readEventStateSequence(data: unknown): number | undefined {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return undefined;
+  const value = (data as { stateSequence?: unknown }).stateSequence;
+  return typeof value === "number" ? value : undefined;
+}
+
+function formatNextAction(action: NextAction): string {
+  if (action.type === "wait_for_merge") {
+    return `waiting for external merge of ${action.pullRequestId}`;
+  }
+
+  return "continue";
+}

package/stack/plugins/opencode/goal/db.ts

@@ -0,0 +1,68 @@
+import path from "node:path";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+
+type SqliteRow = Record<string, unknown>;
+
+interface SqliteStatement {
+  run(...params: unknown[]): unknown;
+  get(...params: unknown[]): SqliteRow | undefined;
+  all(...params: unknown[]): SqliteRow[];
+}
+
+interface SqliteDatabase {
+  exec(sql: string): void;
+  close(): void;
+  prepare?(sql: string): SqliteStatement;
+  query?(sql: string): SqliteStatement;
+}
+
+const require = createRequire(import.meta.url);
+
+function loadDatabaseCtor(): new (databasePath: string, options?: Record<string, unknown>) => SqliteDatabase {
+  if (typeof (globalThis as { Bun?: unknown }).Bun !== "undefined") {
+    return require("bun:sqlite").Database;
+  }
+
+  return require("node:sqlite").DatabaseSync;
+}
+
+export class GoalDb {
+  private readonly db: SqliteDatabase;
+
+  constructor(databasePath: string) {
+    fs.mkdirSync(path.dirname(databasePath), { recursive: true });
+    const Database = loadDatabaseCtor();
+    this.db = new Database(databasePath, { create: true });
+    this.exec("PRAGMA foreign_keys = ON;");
+    this.exec("PRAGMA busy_timeout = 5000;");
+  }
+
+  exec(sql: string): void {
+    this.db.exec(sql);
+  }
+
+  prepare(sql: string): SqliteStatement {
+    const statement = this.db.prepare?.(sql) ?? this.db.query?.(sql);
+    if (!statement) {
+      throw new Error("SQLite runtime does not expose prepare/query.");
+    }
+    return statement;
+  }
+
+  get(sql: string, ...params: unknown[]): SqliteRow | undefined {
+    return this.prepare(sql).get(...params);
+  }
+
+  all(sql: string, ...params: unknown[]): SqliteRow[] {
+    return this.prepare(sql).all(...params);
+  }
+
+  run(sql: string, ...params: unknown[]): unknown {
+    return this.prepare(sql).run(...params);
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}

package/stack/plugins/opencode/goal/opencode-hooks.ts

@@ -0,0 +1,272 @@
+import { randomUUID } from "node:crypto";
+import type { GoalStore } from "./types.js";
+import { createGoalCommandHandlers } from "./command.js";
+import {
+  GOAL_MODE_MARKER_END,
+  GOAL_MODE_MARKER_START,
+  createGoalSupervisor,
+} from "./supervisor.js";
+
+type HookOutput = Record<string, unknown>;
+
+interface GoalSessionClient {
+  promptAsync?: (input: { prompt: string; sessionID?: string }) => Promise<unknown> | unknown;
+}
+
+interface GoalLogger {
+  warn?: (message: string, details?: unknown) => void;
+  error?: (message: string, details?: unknown) => void;
+}
+
+export interface OpenCodeGoalHooksDeps {
+  store: GoalStore;
+  project: string;
+  artifactsRootDir?: string;
+  sessionClient?: GoalSessionClient;
+  logger?: GoalLogger;
+}
+
+export interface OpenCodeGoalHooks {
+  event?: (input: { event: { type: string; properties?: unknown } }) => Promise<void>;
+  "command.execute.before"?: (input: unknown, output: HookOutput) => Promise<void>;
+  "experimental.chat.system.transform"?: (input: unknown, output: { system: string[] }) => Promise<void>;
+  "experimental.session.compacting"?: (input: { sessionID?: string }, output: { context: string[] }) => Promise<void>;
+}
+
+export function createOpenCodeGoalHooks(deps: OpenCodeGoalHooksDeps): OpenCodeGoalHooks {
+  const commands = createGoalCommandHandlers({
+    store: deps.store,
+    project: deps.project,
+    artifactsRootDir: deps.artifactsRootDir,
+  });
+  const supervisor = createGoalSupervisor({
+    store: deps.store,
+    project: deps.project,
+  });
+
+  return {
+    "command.execute.before": async (input, output) => {
+      const command = extractCommandName(input);
+      if (command !== "goal") return;
+
+      const response = commands.handleGoalCommand(extractCommandArguments(input));
+      appendHookText(input, output, response.message);
+    },
+
+    "experimental.chat.system.transform": async (_input, output) => {
+      const block = supervisor.renderSystemContext();
+      if (!block) return;
+
+      if (output.system.length === 0) {
+        output.system.push(block);
+        return;
+      }
+
+      const lastIndex = output.system.length - 1;
+      output.system[lastIndex] = upsertMarkedBlock(output.system[lastIndex]!, block);
+    },
+
+    "experimental.session.compacting": async (_input, output) => {
+      const block = supervisor.renderSystemContext();
+      if (!block) return;
+
+      if (!output.context.some((entry) => entry.includes(GOAL_MODE_MARKER_START))) {
+        output.context.push(block);
+      }
+    },
+
+    event: async ({ event }) => {
+      if (event.type !== "session.idle") return;
+
+      const decision = supervisor.decide();
+      if (!decision || decision.type === "pause_for_merge") return;
+      if (decision.state.goal.status !== "active") return;
+      const sessionID = extractSessionID(event.properties);
+      const stateSequence = latestNonAutoContinueSequence(decision.state.events);
+      if (hasAutoContinueEventForState(decision.state.events, "goal.auto_continue_requested", stateSequence)) {
+        if (!hasAutoContinueEventForState(decision.state.events, "goal.auto_continue_deduped", stateSequence)) {
+          deps.store.appendEvent(decision.state.goal.id, {
+            type: "goal.auto_continue_deduped",
+            message: "Auto-continue skipped because this goal state already requested a continuation.",
+            data: { sessionID, stateSequence },
+          });
+        }
+        return;
+      }
+      if (!deps.sessionClient?.promptAsync) {
+        if (!hasAutoContinueEventForState(decision.state.events, "goal.auto_continue_unavailable", stateSequence)) {
+          deps.store.appendEvent(decision.state.goal.id, {
+            type: "goal.auto_continue_unavailable",
+            message: "Auto-continue unavailable: session prompt client missing.",
+            data: { sessionID, stateSequence },
+          });
+          deps.logger?.warn?.("Goal Mode auto-continue unavailable", {
+            goalId: decision.state.goal.id,
+            sessionID,
+            stateSequence,
+          });
+        }
+        return;
+      }
+      const prompt = supervisor.renderContinuationPrompt(decision.state.goal.id);
+      if (!prompt?.trim()) {
+        deps.store.appendEvent(decision.state.goal.id, {
+          type: "goal.auto_continue_skipped",
+          message: "Auto-continue skipped because the continuation prompt was empty.",
+        });
+        return;
+      }
+      const dedupeKey = `${decision.state.goal.id}:${sessionID ?? "unknown"}:${stateSequence}`;
+      if (autoContinueInFlight.has(dedupeKey)) {
+        deps.store.appendEvent(decision.state.goal.id, {
+          type: "goal.auto_continue_deduped",
+          message: "Auto-continue skipped because a continuation is already in flight.",
+          data: { sessionID, stateSequence },
+        });
+        return;
+      }
+      autoContinueInFlight.add(dedupeKey);
+
+      try {
+        deps.store.appendEvent(decision.state.goal.id, {
+          type: "goal.auto_continue_requested",
+          message: `Auto-continue requested for session ${sessionID ?? "unknown"}.`,
+          data: { sessionID, stateSequence },
+        });
+        await deps.sessionClient.promptAsync({
+          sessionID,
+          prompt,
+        });
+      } catch (error) {
+        deps.store.appendEvent(decision.state.goal.id, {
+          type: "goal.auto_continue_failed",
+          message: `Auto-continue failed for session ${sessionID ?? "unknown"}.`,
+          data: { error: error instanceof Error ? error.message : String(error), sessionID, stateSequence },
+        });
+        deps.logger?.error?.("Goal Mode auto-continue failed", error);
+      } finally {
+        autoContinueInFlight.delete(dedupeKey);
+      }
+    },
+  };
+}
+
+const autoContinueInFlight = new Set<string>();
+
+function extractCommandName(input: unknown): string {
+  if (!isRecord(input)) return "";
+  const command = input.command ?? input.name;
+  return typeof command === "string" ? command.trim().toLowerCase() : "";
+}
+
+function extractCommandArguments(input: unknown): string {
+  if (!isRecord(input)) return "";
+  const direct = input.arguments ?? input.argument ?? input.input;
+  if (typeof direct === "string") return direct;
+  const args = input.args;
+  if (!isRecord(args)) return "";
+  const nested = args.arguments ?? args.argument ?? args.input;
+  return typeof nested === "string" ? nested : "";
+}
+
+function appendHookText(input: unknown, output: HookOutput, text: string): void {
+  if (Array.isArray(output.parts)) {
+    output.parts.push({
+      id: `part_${randomUUID()}`,
+      sessionID: extractHookSessionID(input, output),
+      messageID: extractHookMessageID(input, output),
+      type: "text",
+      text,
+      synthetic: true,
+    });
+    return;
+  }
+  if (typeof output.message === "string") {
+    output.message = output.message ? `${output.message}\n\n${text}` : text;
+    return;
+  }
+  if (typeof output.output === "string") {
+    output.output = output.output ? `${output.output}\n\n${text}` : text;
+    return;
+  }
+  if (Array.isArray(output.content)) {
+    output.content.push({ type: "text", text });
+    return;
+  }
+  throw new Error("Unsupported OpenCode command output contract for Goal Mode.");
+}
+
+function extractHookSessionID(input: unknown, output: HookOutput): string {
+  const inputRecord = isRecord(input) ? input : undefined;
+  const outputRecord = output;
+  const direct = inputRecord?.sessionID ?? inputRecord?.sessionId ?? outputRecord.sessionID ?? outputRecord.sessionId;
+  if (typeof direct === "string" && direct.trim()) return direct;
+
+  const message = outputRecord.message ?? outputRecord.info;
+  if (isRecord(message)) {
+    const sessionID = message.sessionID ?? message.sessionId;
+    if (typeof sessionID === "string" && sessionID.trim()) return sessionID;
+  }
+
+  return `session_${randomUUID()}`;
+}
+
+function extractHookMessageID(input: unknown, output: HookOutput): string {
+  const inputRecord = isRecord(input) ? input : undefined;
+  const outputRecord = output;
+  const direct = inputRecord?.messageID ?? inputRecord?.messageId ?? outputRecord.messageID ?? outputRecord.messageId;
+  if (typeof direct === "string" && direct.trim()) return direct;
+
+  const message = outputRecord.message ?? outputRecord.info;
+  if (isRecord(message)) {
+    const id = message.id ?? message.messageID ?? message.messageId;
+    if (typeof id === "string" && id.trim()) return id;
+  }
+
+  return `msg_${randomUUID()}`;
+}
+
+function upsertMarkedBlock(text: string, block: string): string {
+  const start = text.indexOf(GOAL_MODE_MARKER_START);
+  const end = text.indexOf(GOAL_MODE_MARKER_END);
+  if (start !== -1 && end !== -1 && end > start) {
+    return `${text.slice(0, start).trimEnd()}\n\n${block}${text.slice(end + GOAL_MODE_MARKER_END.length)}`;
+  }
+  return `${text.trimEnd()}\n\n${block}`;
+}
+
+function extractSessionID(properties: unknown): string | undefined {
+  if (!isRecord(properties)) return undefined;
+  if (typeof properties.sessionID === "string") return properties.sessionID;
+  const info = properties.info;
+  if (isRecord(info) && typeof info.id === "string") return info.id;
+  return undefined;
+}
+
+const AUTO_CONTINUE_EVENT_PREFIX = "goal.auto_continue_";
+
+function latestNonAutoContinueSequence(events: Array<{ type: string; sequence: number }>): number {
+  return Math.max(
+    0,
+    ...events
+      .filter((event) => !event.type.startsWith(AUTO_CONTINUE_EVENT_PREFIX))
+      .map((event) => event.sequence),
+  );
+}
+
+function hasAutoContinueEventForState(
+  events: Array<{ type: string; data?: unknown }>,
+  type: string,
+  stateSequence: number,
+): boolean {
+  return events.some((event) => event.type === type && readEventStateSequence(event.data) === stateSequence);
+}
+
+function readEventStateSequence(data: unknown): number | undefined {
+  if (!isRecord(data)) return undefined;
+  return typeof data.stateSequence === "number" ? data.stateSequence : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/stack/plugins/opencode/goal/state.ts

@@ -0,0 +1,85 @@
+import {
+  GOAL_STORE_SCHEMA_VERSION,
+  type GoalStatus,
+  type GoalStoreSnapshot,
+} from "./types.js";
+
+export const GOAL_STATUSES: readonly GoalStatus[] = [
+  "active",
+  "paused",
+  "blocked",
+  "waiting_for_merge",
+  "budget_limited",
+  "failed",
+  "complete",
+  "cancelled",
+];
+
+export const TERMINAL_GOAL_STATUSES = new Set<GoalStatus>([
+  "failed",
+  "complete",
+  "cancelled",
+]);
+
+const ALLOWED_TRANSITIONS: Record<GoalStatus, readonly GoalStatus[]> = {
+  active: [
+    "paused",
+    "blocked",
+    "waiting_for_merge",
+    "budget_limited",
+    "failed",
+    "complete",
+    "cancelled",
+  ],
+  paused: [
+    "active",
+    "blocked",
+    "waiting_for_merge",
+    "budget_limited",
+    "failed",
+    "cancelled",
+  ],
+  blocked: [
+    "active",
+    "paused",
+    "waiting_for_merge",
+    "budget_limited",
+    "failed",
+    "complete",
+    "cancelled",
+  ],
+  waiting_for_merge: ["active", "blocked", "budget_limited", "failed", "cancelled"],
+  budget_limited: ["active", "blocked", "waiting_for_merge", "failed", "cancelled"],
+  failed: [],
+  complete: [],
+  cancelled: [],
+};
+
+export function createEmptyGoalStoreSnapshot(): GoalStoreSnapshot {
+  return {
+    schemaVersion: GOAL_STORE_SCHEMA_VERSION,
+    nextEventSequence: 1,
+    goals: [],
+    events: [],
+    phases: [],
+    worktrees: [],
+    pullRequests: [],
+  };
+}
+
+export function isTerminalGoalStatus(status: GoalStatus): boolean {
+  return TERMINAL_GOAL_STATUSES.has(status);
+}
+
+export function assertGoalTransition(from: GoalStatus, to: GoalStatus): void {
+  if (from === to) return;
+
+  if (isTerminalGoalStatus(from)) {
+    throw new Error(`Cannot transition terminal goal from ${from} to ${to}.`);
+  }
+
+  const allowed = ALLOWED_TRANSITIONS[from];
+  if (!allowed.includes(to)) {
+    throw new Error(`Invalid transition from ${from} to ${to}.`);
+  }
+}