@brainervirus/workit-core 0.6.0 → 0.7.0

package/src/core/git.ts

@@ -2,7 +2,13 @@ import { execFileSync } from "node:child_process";
 
 const run = (cwd: string, args: string[]): { stdout: string; stderr: string; exitCode: number } => {
   try {
-    const stdout = execFileSync("git", args, { cwd, encoding: "utf8" });
+    const stdout = execFileSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      // AR-14: expected negative fixtures (non-repo dirs, unborn HEADs, bogus
+      // shas) must not inherit raw git usage/fatal stderr into the suite output.
+      stdio: ["pipe", "pipe", "pipe"],
+    });
     return { stdout: stdout.trimEnd(), stderr: "", exitCode: 0 };
   } catch (error) {
     const e = error as { stdout?: string; stderr?: string; status?: number };
@@ -16,8 +22,18 @@ const run = (cwd: string, args: string[]): { stdout: string; stderr: string; exi
 
 export const gitContext = (workspaceRoot: string, paths: string[] = []) => {
   const cwd = workspaceRoot;
-  const branch = run(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]).stdout || "unknown";
-  const status_short = run(cwd, ["status", "--porcelain"]).stdout;
+  let failure: { stderr: string; exitCode: number } | undefined;
+
+  const runHere = (args: string[]) => {
+    const result = run(cwd, args);
+    if (!failure && result.exitCode !== 0) {
+      failure = { stderr: result.stderr, exitCode: result.exitCode };
+    }
+    return result.stdout;
+  };
+
+  const branch = runHere(["rev-parse", "--abbrev-ref", "HEAD"]) || "unknown";
+  const status_short = runHere(["status", "--porcelain"]);
 
   const staged: string[] = [];
   const unstaged: string[] = [];
@@ -35,8 +51,8 @@ export const gitContext = (workspaceRoot: string, paths: string[] = []) => {
   }
 
   const pathArgs = paths.length ? ["--", ...paths] : [];
-  const diff_stat = run(cwd, ["diff", "--stat", ...pathArgs]).stdout;
-  const cached_stat = run(cwd, ["diff", "--cached", "--stat", ...pathArgs]).stdout;
+  const diff_stat = runHere(["diff", "--stat", ...pathArgs]);
+  const cached_stat = runHere(["diff", "--cached", "--stat", ...pathArgs]);
 
   const stagedSet = new Set(staged);
   const unstagedSet = new Set(unstaged);
@@ -52,5 +68,6 @@ export const gitContext = (workspaceRoot: string, paths: string[] = []) => {
     diff_stat: [diff_stat, cached_stat].filter(Boolean).join("\n"),
     partial_staged: partial_staged.length > 0,
     partial_staged_files: partial_staged,
+    ...(failure ? { stderr: failure.stderr, exitCode: failure.exitCode } : {}),
   };
 };

package/src/core/gitignore.ts

@@ -25,7 +25,12 @@ export const ensureProjectGitignore = (
   if (!confirmed) return { ok: false, error: "confirmed: true required" };
   const file = path.join(workspaceRoot, ".gitignore");
   const existing = existsSync(file) ? readFileSync(file, "utf8") : "";
-  const existingLines = new Set(existing.split("\n").map((l) => l.trim()).filter(Boolean));
+  const existingLines = new Set(
+    existing
+      .split("\n")
+      .map((l) => l.trim())
+      .filter(Boolean),
+  );
   const added: string[] = [];
   const append: string[] = [];
   for (const entry of GITIGNORE_ENTRIES) {
@@ -35,7 +40,11 @@ export const ensureProjectGitignore = (
   }
   if (append.length) {
     const separator = existing && !existing.endsWith("\n") ? "\n" : "";
-    writeFileSync(file, existing + separator + (existing ? "\n" : "") + append.join("\n") + "\n", "utf8");
+    writeFileSync(
+      file,
+      existing + separator + (existing ? "\n" : "") + append.join("\n") + "\n",
+      "utf8",
+    );
   } else if (!existsSync(file)) {
     writeFileSync(file, "", "utf8");
   }

package/src/core/handoff-context.ts

@@ -25,7 +25,8 @@ const resolveFromMessagePaths = (root: string, message: string): Resolved => {
   const paths = extractMessagePaths(message);
   if (paths.length === 0) return { error: "no paths" };
   const slugs = [...new Set(paths.map((p) => p.split("/")[1]))];
-  if (slugs.length !== 1) return { error: "multiple features in message — use exactly one docs/<slug>/ pair" };
+  if (slugs.length !== 1)
+    return { error: "multiple features in message — use exactly one docs/<slug>/ pair" };
   const slug = slugs[0];
   const plan = `docs/${slug}/plan.md`;
   const spec = `docs/${slug}/spec.md`;
@@ -49,8 +50,15 @@ const resolveActivePair = (root: string): Resolved => {
     const plan = path.join("docs", slug, "plan.md");
     const spec = path.join("docs", slug, "spec.md");
     if (!existsSync(path.join(root, plan)) || !existsSync(path.join(root, spec))) continue;
-    const score = Math.max(statSync(path.join(root, spec)).mtimeMs, statSync(path.join(root, plan)).mtimeMs);
-    if (best === null || score > best.score || (score === best.score && slug < best.spec.split("/")[1])) {
+    const score = Math.max(
+      statSync(path.join(root, spec)).mtimeMs,
+      statSync(path.join(root, plan)).mtimeMs,
+    );
+    if (
+      best === null ||
+      score > best.score ||
+      (score === best.score && slug < best.spec.split("/")[1])
+    ) {
       best = { score, spec, plan, source: "active_pair" };
     }
   }
@@ -69,7 +77,10 @@ export const resolveWorkflowPaths = (root: string, message: string): Resolved =>
   if (!existsSync(docsDir) || listMd(docsDir).length === 0) {
     return { error: "no docs/<slug>/ features found under docs/" };
   }
-  return { error: "could not resolve spec and plan — mention docs/<slug>/plan.md or create docs/<slug>/{spec.md,plan.md}" };
+  return {
+    error:
+      "could not resolve spec and plan — mention docs/<slug>/plan.md or create docs/<slug>/{spec.md,plan.md}",
+  };
 };
 
 export const buildHandoffContract = ({
@@ -85,7 +96,9 @@ export const buildHandoffContract = ({
 }): { prompt: string } | { error: string } => {
   const validated = docsValidate({ spec_path: spec, plan_path: plan, workspace_root: root });
   if (validated.ok === false) {
-    return { error: `docs validation failed\n${JSON.stringify({ ok: false, errors: validated.errors })}` };
+    return {
+      error: `docs validation failed\n${JSON.stringify({ ok: false, errors: validated.errors })}`,
+    };
   }
   const branchResolved = resolveBranch({ spec_path: spec, plan_path: plan, workspace_root: root });
   if ("error" in branchResolved) return { error: branchResolved.error as string };

package/src/{tools/handoff.ts → core/handoff-tools.ts}

@@ -1,10 +1,7 @@
 import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { tool, type PluginInput } from "@opencode-ai/plugin";
 import { fail, ok, type Result } from "../core";
-import { assertFlowGates } from "../core/flow-state";
-import { resolveWorkflowPaths, buildHandoffContract } from "../core/handoff-context";
-import { WorkflowStateStore } from "../state";
+import { resolveWorkflowPaths, buildHandoffContract } from "./handoff-context";
+import { assetRoot } from "./package-root";
 
 type ApiResponse<T> = { data?: T; error?: unknown };
 type ApiResult<T> = Promise<ApiResponse<T>>;
@@ -31,19 +28,6 @@ export type HandoffClient = {
   };
 };
 
-export const adaptPluginHandoffClient = (client: PluginInput["client"]): HandoffClient => ({
-  session: {
-    create: (input) => client.session.create(input),
-    promptAsync: (input) => client.session.promptAsync(input),
-  },
-  tui: {
-    selectSession: ({ body, query }) => client.tui.publish({
-      body: { type: "tui.session.select", properties: { sessionID: body.sessionID } } as never,
-      query,
-    }),
-  },
-});
-
 export type HandoffRequest = {
   directory: string;
   title: string;
@@ -58,12 +42,13 @@ type HandoffData = {
   stage?: "create" | "seed" | "select";
 };
 
-const message = (error: unknown) => error instanceof Error
-  ? error.message
-  : typeof error === "object" && error !== null && "message" in error
-    ? String(error.message)
-    : String(error);
-const apiError = (response: ApiResponse<unknown> | void) => response?.error;
+export const message = (error: unknown) =>
+  error instanceof Error
+    ? error.message
+    : typeof error === "object" && error !== null && "message" in error
+      ? String(error.message)
+      : String(error);
+export const apiError = (response: ApiResponse<unknown> | void) => response?.error;
 
 export async function handoffSession(
   client: HandoffClient,
@@ -108,8 +93,6 @@ export async function handoffSession(
   }
 }
 
-const output = (value: unknown) => JSON.stringify(value, null, 2);
-
 export type HandoffContextResult =
   | { prompt: string; spec: string; plan: string; sdd: string }
   | { error: string };
@@ -117,44 +100,14 @@ export type HandoffContextResult =
 export const buildHandoffPrompt = (root: string, message: string): HandoffContextResult => {
   const resolved = resolveWorkflowPaths(root, message);
   if ("error" in resolved) return { error: resolved.error };
-  const templatePath = path.resolve(
-    path.dirname(fileURLToPath(import.meta.url)),
-    "../../templates/execution-contract.md",
-  );
-  const contract = buildHandoffContract({ root, spec: resolved.spec, plan: resolved.plan, templatePath });
+  const templatePath = path.join(assetRoot(), "templates", "execution-contract.md");
+  const contract = buildHandoffContract({
+    root,
+    spec: resolved.spec,
+    plan: resolved.plan,
+    templatePath,
+  });
   if ("error" in contract) return { error: contract.error };
   const sdd = `docs/${path.basename(path.dirname(resolved.plan))}/sdd`;
   return { prompt: contract.prompt, spec: resolved.spec, plan: resolved.plan, sdd };
 };
-
-
-
-export function createHandoffTools(
-  client: HandoffClient,
-  state: WorkflowStateStore,
-) {
-  return {
-    workflow_handoff_session: tool({
-      description: "Create, seed, and select a continuation session; --stay in the message skips selection",
-      args: { message: tool.schema.string() },
-      execute: async ({ message: userMessage }, context) => {
-        const built = buildHandoffPrompt(context.directory, userMessage);
-        if ("error" in built) return output(fail(built.error));
-        const active = built;
-        try {
-          const gate = assertFlowGates(context.directory, active.plan);
-          if (!gate.ok) return output(fail(gate.error));
-          state.set(context.sessionID, { spec: active.spec, plan: active.plan, sdd: active.sdd });
-          return output(await handoffSession(client, {
-            directory: context.directory,
-            title: `Continue ${path.basename(path.dirname(active.plan))}`,
-            prompt: active.prompt,
-            stay: /(?:^|\s)--stay(?:\s|$)/.test(userMessage),
-          }));
-        } catch (error) {
-          return output(fail(message(error)));
-        }
-      },
-    }),
-  };
-}

package/src/core/hygiene.ts

@@ -1,17 +1,27 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { changelogUnreleasedStats } from "./changelog";
+import { assetRoot } from "./package-root";
 
-export type HygieneFile = "CHANGELOG.md" | "README.md" | ".editorconfig" | ".gitattributes" | "LICENSE" | "CONTRIBUTING.md";
+export type HygieneFile =
+  | "CHANGELOG.md"
+  | "README.md"
+  | ".editorconfig"
+  | ".gitattributes"
+  | "LICENSE"
+  | "CONTRIBUTING.md";
 type State = "missing" | "invalid" | "ok" | "skip";
 
-const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const repoRoot = assetRoot();
 const templatesDir = () => path.join(repoRoot, "templates", "hygiene");
 
 const packageJson = (root: string): Record<string, unknown> | null => {
   if (!existsSync(path.join(root, "package.json"))) return null;
-  try { return JSON.parse(readFileSync(path.join(root, "package.json"), "utf8")); } catch { return null; }
+  try {
+    return JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
 };
 
 const isOpenSource = (root: string): boolean => {
@@ -34,15 +44,27 @@ const licenseHolder = (root: string): string => {
   return "";
 };
 
-export const hygieneFiles = (root: string): { state: Record<HygieneFile, State>; openSource: boolean } => {
+export const hygieneFiles = (
+  root: string,
+): { state: Record<HygieneFile, State>; openSource: boolean } => {
   const openSource = isOpenSource(root);
   const state = {} as Record<HygieneFile, State>;
-  for (const file of ["CHANGELOG.md", "README.md", ".editorconfig", ".gitattributes", "LICENSE", "CONTRIBUTING.md"] as HygieneFile[]) {
+  for (const file of [
+    "CHANGELOG.md",
+    "README.md",
+    ".editorconfig",
+    ".gitattributes",
+    "LICENSE",
+    "CONTRIBUTING.md",
+  ] as HygieneFile[]) {
     if (file === "LICENSE" || file === "CONTRIBUTING.md") {
       state[file] = openSource ? (existsSync(path.join(root, file)) ? "ok" : "missing") : "skip";
       continue;
     }
-    if (!existsSync(path.join(root, file))) { state[file] = "missing"; continue; }
+    if (!existsSync(path.join(root, file))) {
+      state[file] = "missing";
+      continue;
+    }
     if (file === "CHANGELOG.md") {
       const stats = changelogUnreleasedStats(root);
       state[file] = stats.exists && stats.has_unreleased ? "ok" : "invalid";
@@ -53,25 +75,39 @@ export const hygieneFiles = (root: string): { state: Record<HygieneFile, State>;
   return { state, openSource };
 };
 
-export const ensureHygieneFiles = (
+// Pure planner: which hygiene files would be created and with what content,
+// without touching the filesystem. Drives the wizard preview (WZ-08) and the
+// apply path; ensureHygieneFiles is just "plan then write".
+export const planHygieneFiles = (
   root: string,
-  opts: { confirmed: boolean; includeOpenSource?: boolean },
-): { ok: true; created: string[] } | { ok: false; error: string } => {
-  if (!opts.confirmed) return { ok: false, error: "confirmed: true required" };
+  opts: { includeOpenSource?: boolean } = {},
+): Array<{ path: string; content: string }> => {
+  const openSource = opts.includeOpenSource ?? isOpenSource(root);
   const files = ["CHANGELOG.md", "README.md", ".editorconfig", ".gitattributes"] as HygieneFile[];
-  if (opts.includeOpenSource) files.push("LICENSE", "CONTRIBUTING.md");
-  const created: string[] = [];
-  const tplDir = templatesDir();
+  if (openSource) files.push("LICENSE", "CONTRIBUTING.md");
+  const planned: Array<{ path: string; content: string }> = [];
   for (const file of files) {
     if (existsSync(path.join(root, file))) continue;
-    const tpl = path.join(tplDir, file);
+    const tpl = path.join(templatesDir(), file);
     if (!existsSync(tpl)) continue; // skip missing template, never fail
     const content = readFileSync(tpl, "utf8")
       .replace(/<PROJECT>/g, path.basename(root))
       .replace(/<YEAR>/g, String(new Date().getFullYear()))
       .replace(/<HOLDER>\s*/g, licenseHolder(root));
-    writeFileSync(path.join(root, file), content, "utf8");
-    created.push(file);
+    planned.push({ path: path.join(root, file), content });
+  }
+  return planned;
+};
+
+export const ensureHygieneFiles = (
+  root: string,
+  opts: { confirmed: boolean; includeOpenSource?: boolean },
+): { ok: true; created: string[] } | { ok: false; error: string } => {
+  if (!opts.confirmed) return { ok: false, error: "confirmed: true required" };
+  const created: string[] = [];
+  for (const planned of planHygieneFiles(root, opts)) {
+    writeFileSync(planned.path, planned.content, "utf8");
+    created.push(path.basename(planned.path));
   }
   return { ok: true, created };
 };