@gobing-ai/spur 0.4.8 → 0.4.9

package/plugins/sp/scripts/batch-preflight.ts

@@ -1,270 +0,0 @@
-/**
- * batch-preflight — planner adapter over the pure admission policy (task 0279; task 1176 move).
- *
- * The decisions — TABLE A STOP evaluation, quick command-aware readiness and feature-finding
- * classification — are application policy in `packages/app/src/services/planning-admission.ts`,
- * reached through the generated pure bundle. This entry keeps what belongs to the planner: the CLI
- * surface, its argv/usage/error contracts, and the one-shot recovery hints the batch driver prints.
- *
- * Recovery hints (one-shot after FAIL) map stuck statuses to a single /sp:dev-* hop per TABLE A; the
- * batch driver prints or dispatches at most once per WBS.
- */
-
-import {
-    classifyFeaturePreflightFindings,
-    type FeaturePreflightClassification,
-    type FeaturePreflightFinding,
-    NON_ABORTING_PREFLIGHT_CODES,
-    type PreflightInput,
-    type PreflightResult,
-    preflightTask,
-    type QuickReadinessInput,
-    type QuickReadinessResult,
-    quickReadiness,
-    type ReadinessOperation,
-    type TaskStatus,
-} from '../lib/plan-projection.generated.mjs';
-
-export type {
-    FeaturePreflightClassification,
-    FeaturePreflightFinding,
-    PreflightInput,
-    PreflightResult,
-    QuickReadinessInput,
-    QuickReadinessResult,
-    ReadinessOperation,
-    TaskStatus,
-};
-// R1: existing plugin callers keep their import path — the moved names are re-exported, not relocated
-// out from under them.
-export { classifyFeaturePreflightFindings, NON_ABORTING_PREFLIGHT_CODES, preflightTask, quickReadiness };
-
-/**
- * One-shot recovery hint after a non-PASS pipeline or stuck status (TABLE A primary hop).
- * Caller substitutes the real WBS; never loop this — at most one hop per WBS per batch.
- */
-export function recoveryHint(status: TaskStatus, wbs: string): { command: string; code: string } | null {
-    const st = (status ?? '').toLowerCase();
-    switch (st) {
-        case 'backlog':
-            return { code: 'A1', command: `/sp:dev-refine ${wbs} --auto --next` };
-        case 'todo':
-            return { code: 'A3', command: `/sp:dev-run ${wbs} --auto --next` };
-        case 'wip':
-            return { code: 'A5', command: `/sp:dev-run ${wbs} --mode implement --auto --next` };
-        case 'testing':
-            return { code: 'A6', command: `/sp:dev-verify ${wbs} --auto --next` };
-        case 'blocked':
-            return {
-                code: 'A7',
-                command: `/sp:dev-handover "blocked task ${wbs} — see Notes/History"`,
-            };
-        default:
-            return null;
-    }
-}
-
-// ── CLI for agents / dogfood (optional) ──────────────────────────────────────
-
-export interface PreflightCliArgs {
-    status: string | null;
-    deps: string[];
-    depStatuses: Record<string, string>;
-    wbs: string;
-    recovery: boolean;
-    help: boolean;
-    json: boolean;
-    /** Quick-readiness operation (run|refine|verify); when set, run quickReadiness. */
-    operation: ReadinessOperation | null;
-    /** Verify-only re-verification (R2 AC). */
-    force: boolean;
-    /** Status-filtered candidate set size; 0 = empty set. */
-    filteredCount: number | null;
-    /** Required planning sections (matrix-selected). */
-    requiredSections: string[];
-    /** Sections actually present in the task. */
-    presentSections: string[];
-    /** Feature findings to classify (1132 R4). */
-    classifyFeature: string | null;
-}
-
-export function parsePreflightCliArgs(argv: string[]): PreflightCliArgs {
-    let status: string | null = null;
-    let deps: string[] = [];
-    const depStatuses: Record<string, string> = {};
-    let wbs = '0000';
-    let recovery = false;
-    let help = false;
-    let json = false;
-    let operation: ReadinessOperation | null = null;
-    let force = false;
-    let filteredCount: number | null = null;
-    let requiredSections: string[] = [];
-    let presentSections: string[] = [];
-    let classifyFeature: string | null = null;
-
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i];
-        if (a === '--help' || a === '-h') help = true;
-        else if (a === '--json') json = true;
-        else if (a === '--recovery') recovery = true;
-        else if (a === '--force') force = true;
-        else if (a === '--operation') {
-            const v = argv[++i] ?? '';
-            operation = v === 'run' || v === 'refine' || v === 'verify' ? v : null;
-        } else if (a === '--filtered-count') {
-            const v = Number(argv[++i]);
-            filteredCount = Number.isFinite(v) ? v : null;
-        } else if (a === '--required-sections') {
-            const raw = argv[++i] ?? '';
-            requiredSections =
-                raw.length === 0
-                    ? []
-                    : raw
-                          .split(',')
-                          .map((s) => s.trim())
-                          .filter(Boolean);
-        } else if (a === '--present-sections') {
-            const raw = argv[++i] ?? '';
-            presentSections =
-                raw.length === 0
-                    ? []
-                    : raw
-                          .split(',')
-                          .map((s) => s.trim())
-                          .filter(Boolean);
-        } else if (a === '--wbs') wbs = argv[++i] ?? wbs;
-        else if (a === '--classify-feature') {
-            classifyFeature = argv[++i] ?? '[]';
-        } else if (a === '--status') status = argv[++i] ?? null;
-        else if (a === '--deps') {
-            const raw = argv[++i] ?? '';
-            deps =
-                raw.length === 0
-                    ? []
-                    : raw
-                          .split(',')
-                          .map((s) => s.trim())
-                          .filter(Boolean);
-        } else if (a === '--dep-status') {
-            // format: 0275:done,0276:todo
-            const raw = argv[++i] ?? '';
-            for (const part of raw.split(',')) {
-                const [k, v] = part.split(':');
-                if (k && v) depStatuses[k.trim()] = v.trim();
-            }
-        }
-    }
-    return {
-        status,
-        deps,
-        depStatuses,
-        wbs,
-        recovery,
-        help,
-        json,
-        operation,
-        force,
-        filteredCount,
-        requiredSections,
-        presentSections,
-        classifyFeature,
-    };
-}
-
-export const PREFLIGHT_CLI_USAGE = `Usage:
-  bun plugins/sp/scripts/batch-preflight.ts --wbs <wbs> --status <status> \\
-    [--deps 0275,0276] [--dep-status 0275:done,0276:todo] [--recovery] [--json]
-  bun plugins/sp/scripts/batch-preflight.ts --operation <run|refine|verify> --wbs <wbs> --status <status> \
-    [--filtered-count <n>] [--required-sections A,B] [--present-sections A,B] [--force] [--json]
-
-Exit: 0 = run (or recovery hint printed); 2 = skip; 1 = usage.`;
-
-export function runPreflightCli(argv: string[]): { exitCode: number; stdout: string; stderr: string } {
-    const args = parsePreflightCliArgs(argv);
-    if (args.help) return { exitCode: 0, stdout: '', stderr: PREFLIGHT_CLI_USAGE };
-
-    // Feature findings classification (1132 R4)
-    if (args.classifyFeature !== null) {
-        try {
-            const findings = JSON.parse(args.classifyFeature);
-            const res = classifyFeaturePreflightFindings(Array.isArray(findings) ? findings : []);
-            return {
-                exitCode: res.shouldAbort ? 1 : 0,
-                stdout: `${JSON.stringify(res, null, 2)}\n`,
-                stderr: '',
-            };
-        } catch (e) {
-            return {
-                exitCode: 1,
-                stdout: '',
-                stderr: `Invalid JSON for --classify-feature: ${String(e)}`,
-            };
-        }
-    }
-
-    if (!args.status) return { exitCode: 1, stdout: '', stderr: PREFLIGHT_CLI_USAGE };
-
-    if (args.recovery) {
-        const hint = recoveryHint(args.status, args.wbs);
-        const body = args.json
-            ? `${JSON.stringify({ recovery: hint }, null, 2)}\n`
-            : hint
-              ? `${hint.command}\n`
-              : 'no recovery hop\n';
-        return { exitCode: 0, stdout: body, stderr: '' };
-    }
-
-    // Quick command-aware readiness (0814 R2) — read-only admission decision.
-    if (args.operation !== null) {
-        const result = quickReadiness({
-            wbs: args.wbs,
-            status: args.status,
-            operation: args.operation,
-            dependencies: args.deps,
-            depStatuses: args.depStatuses,
-            ...(args.filteredCount !== null ? { filteredCount: args.filteredCount } : {}),
-            ...(args.requiredSections.length > 0 ? { requiredSections: args.requiredSections } : {}),
-            ...(args.presentSections.length > 0 ? { presentSections: args.presentSections } : {}),
-            ...(args.force ? { force: true } : {}),
-        });
-        const runnable = result.action === 'runnable' || result.action === 'needs-refinement';
-        if (args.json) {
-            return { exitCode: runnable ? 0 : 2, stdout: `${JSON.stringify(result, null, 2)}\n`, stderr: '' };
-        }
-        return {
-            exitCode: runnable ? 0 : 2,
-            stdout: `${result.action}${result.code ? ` ${result.code}` : ''}: ${result.reason}\n`,
-            stderr: '',
-        };
-    }
-
-    const result = preflightTask({
-        wbs: args.wbs,
-        status: args.status,
-        dependencies: args.deps,
-        depStatuses: args.depStatuses,
-    });
-    if (args.json) {
-        return {
-            exitCode: result.action === 'run' ? 0 : 2,
-            stdout: `${JSON.stringify(result, null, 2)}\n`,
-            stderr: '',
-        };
-    }
-    if (result.action === 'run') {
-        return { exitCode: 0, stdout: `run: ${result.reason ?? 'ok'}\n`, stderr: '' };
-    }
-    return {
-        exitCode: 2,
-        stdout: `skip ${result.code}: ${result.reason}\n`,
-        stderr: '',
-    };
-}
-
-if (import.meta.main) {
-    const { exitCode, stdout, stderr } = runPreflightCli(process.argv.slice(2));
-    if (stdout) process.stdout.write(stdout);
-    if (stderr) process.stderr.write(`${stderr}\n`);
-    process.exit(exitCode);
-}

package/plugins/sp/scripts/commit-guard.mjs

@@ -1,226 +0,0 @@
-#!/usr/bin/env node
-// @bun
-
-// plugins/sp/scripts/commit-guard.ts
-import { spawnSync } from "child_process";
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
-import { join } from "path";
-var COMMIT_GUARD_USAGE = "usage: commit-guard start --run <id> | stage --run <id> [--base <sha>] -- <paths\u2026> | check --run <id>";
-var isBookkeeping = (path) => path === ".spur" || path.startsWith(".spur/");
-var at = (options, rel) => options.cwd ? join(options.cwd, rel) : rel;
-var artifactPath = (run) => join(".spur", "run", `${run}-tree-start.json`);
-function gitOf(options) {
-  if (options.git)
-    return options.git;
-  return (args) => {
-    const run = spawnSync("git", args, { cwd: options.cwd, encoding: "utf8" });
-    return { status: run.status ?? 1, stdout: run.stdout ?? "" };
-  };
-}
-function hashPath(path, git) {
-  const run = git(["hash-object", "--", path]);
-  return run.status === 0 ? run.stdout.trim() : null;
-}
-function parsePorcelainZ(stdout) {
-  const tokens = stdout.split("\x00");
-  const paths = [];
-  for (let i = 0;i < tokens.length; i++) {
-    const entry = tokens[i] ?? "";
-    if (entry.length < 4)
-      continue;
-    const path = entry.slice(3);
-    if (!isBookkeeping(path))
-      paths.push(path);
-    if (/[RC]/.test(entry.slice(0, 2)))
-      i++;
-  }
-  return paths;
-}
-function conflictMarkerLine(content) {
-  let opener = false;
-  for (const line of content.split(`
-`)) {
-    if (/^<{7}( |$)/.test(line))
-      opener = true;
-    else if (/^={7}(\s|$)/.test(line) && opener)
-      return true;
-    else if (/^>{7}( |$)/.test(line))
-      return true;
-  }
-  return opener;
-}
-function changedSinceBase(base, git) {
-  const tracked = git(["diff", "--name-only", base]);
-  if (tracked.status !== 0)
-    throw new Error(`git diff --name-only failed (status ${tracked.status})`);
-  const others = git(["ls-files", "--others", "--exclude-standard", "-z"]);
-  if (others.status !== 0)
-    throw new Error(`git ls-files --others failed (status ${others.status})`);
-  const clean = (out, sep) => out.split(sep).map((p) => p.trim()).filter((p) => p.length > 0 && !isBookkeeping(p));
-  return new Set([...clean(tracked.stdout, `
-`), ...clean(others.stdout, "\x00")]);
-}
-function readTreeStart(run, options) {
-  try {
-    const parsed = JSON.parse(readFileSync(at(options, artifactPath(run)), "utf8"));
-    if (typeof parsed.head === "string" && Array.isArray(parsed.dirty))
-      return parsed;
-  } catch {}
-  return null;
-}
-function runContext(run, options) {
-  const git = gitOf(options);
-  const start = readTreeStart(run, options);
-  if (!start)
-    return null;
-  let base = options.base ?? "";
-  if (!base) {
-    try {
-      const anchored = readFileSync(at(options, join(".spur", "run", `${run}-base.sha`)), "utf8").trim();
-      if (/^[0-9a-f]{7,40}$/i.test(anchored))
-        base = anchored;
-    } catch {}
-  }
-  if (!base)
-    base = start.head.length > 0 ? start.head : "HEAD";
-  const written = changedSinceBase(base, git);
-  for (const entry of start.dirty)
-    if (hashPath(entry.path, git) === entry.sha)
-      written.delete(entry.path);
-  return { git, base, start, written };
-}
-function missingStart(run) {
-  process.stderr.write(`commit-guard: no ${artifactPath(run)} \u2014 run \`commit-guard start --run ${run}\` first
-`);
-  return 1;
-}
-function runStart(run, options = {}) {
-  const git = gitOf(options);
-  const head = git(["rev-parse", "HEAD"]);
-  const status = git(["status", "--porcelain=v1", "-z"]);
-  if (head.status !== 0 || status.status !== 0) {
-    process.stderr.write(`commit-guard: git probe failed (rev-parse HEAD / status) \u2014 is this a work tree?
-`);
-    return 1;
-  }
-  const snapshot = {
-    head: head.stdout.trim(),
-    dirty: parsePorcelainZ(status.stdout).map((path) => ({ path, sha: hashPath(path, git) }))
-  };
-  const abs = at(options, artifactPath(run));
-  mkdirSync(join(abs, ".."), { recursive: true });
-  writeFileSync(`${abs}.tmp`, `${JSON.stringify(snapshot, null, 2)}
-`);
-  renameSync(`${abs}.tmp`, abs);
-  return 0;
-}
-function conflictingTarget(paths, options, git) {
-  const probe = git(["diff", "--name-only", "--diff-filter=U"]);
-  if (probe.status !== 0)
-    throw new Error(`git diff --name-only --diff-filter=U failed (status ${probe.status})`);
-  const unmerged = new Set(probe.stdout.split(`
-`).map((p) => p.trim()));
-  for (const path of paths) {
-    if (unmerged.has(path))
-      return `${path} (unmerged)`;
-    try {
-      if (conflictMarkerLine(readFileSync(at(options, path), "utf8")))
-        return `${path} (conflict markers)`;
-    } catch {}
-  }
-  return null;
-}
-function usageError() {
-  process.stderr.write(`${COMMIT_GUARD_USAGE}
-`);
-  return 1;
-}
-function probeDiagnostic(err) {
-  const detail = err instanceof Error ? err.message : String(err);
-  return `commit-guard: git probe failed (${detail}) \u2014 tree state unproven, nothing staged or reported
-`;
-}
-function runStage(run, paths, options = {}) {
-  if (paths.length === 0)
-    return { staged: [], foreign: [], exitCode: usageError() };
-  let context, conflict;
-  try {
-    context = runContext(run, options);
-    if (!context)
-      return { staged: [], foreign: [], exitCode: missingStart(run) };
-    conflict = conflictingTarget(paths, options, context.git);
-  } catch (err) {
-    process.stderr.write(probeDiagnostic(err));
-    return { staged: [], foreign: [], exitCode: 1 };
-  }
-  if (conflict) {
-    process.stderr.write(`commit-guard: refusing to stage ${conflict}; nothing staged
-`);
-    return { staged: [], foreign: [], exitCode: 3 };
-  }
-  const dirtyAtStart = new Set(context.start.dirty.map((entry) => entry.path));
-  const staged = paths.filter((path) => context.written.has(path));
-  const refused = paths.filter((path) => !context.written.has(path));
-  for (const path of refused) {
-    const why = dirtyAtStart.has(path) ? "foreign \u2014 dirty at start, untouched by this run" : "unchanged since base";
-    process.stderr.write(`commit-guard: refused ${path} (${why})
-`);
-  }
-  if (staged.length > 0 && context.git(["add", "--", ...staged]).status !== 0) {
-    process.stderr.write(`commit-guard: git add failed \u2014 nothing staged
-`);
-    return { staged: [], foreign: [], exitCode: 1 };
-  }
-  const foreign = refused.filter((path) => dirtyAtStart.has(path));
-  process.stdout.write(`${JSON.stringify({ staged, foreign })}
-`);
-  return { staged, foreign, exitCode: refused.length > 0 ? 2 : 0 };
-}
-function runCheck(run, options = {}) {
-  try {
-    const context = runContext(run, options);
-    if (!context)
-      return missingStart(run);
-    const { base, git, written } = context;
-    const foreign = [...changedSinceBase(base, git)].filter((path) => !written.has(path)).sort();
-    process.stdout.write(`${JSON.stringify({ foreign })}
-`);
-    return 0;
-  } catch (err) {
-    process.stderr.write(probeDiagnostic(err));
-    return 1;
-  }
-}
-function takeFlag(args, name) {
-  const index = args.indexOf(name);
-  const value = index === -1 ? undefined : args[index + 1];
-  const missing = value === undefined || value.startsWith("--");
-  if (index !== -1)
-    args.splice(index, missing ? 1 : 2);
-  return missing ? undefined : value;
-}
-function main(argv, options = {}) {
-  const args = [...argv];
-  takeFlag(args, "--spur-bin");
-  const sub = args.shift();
-  const run = takeFlag(args, "--run"), base = takeFlag(args, "--base");
-  if (!run)
-    return usageError();
-  if (sub === "start")
-    return args.length === 0 ? runStart(run, options) : usageError();
-  if (sub === "check")
-    return args.length === 0 ? runCheck(run, { ...options, base }) : usageError();
-  if (sub === "stage")
-    return runStage(run, args.filter((arg) => arg !== "--"), { ...options, base }).exitCode;
-  return usageError();
-}
-process.exit(main(process.argv.slice(2)));
-export {
-  COMMIT_GUARD_USAGE,
-  conflictMarkerLine,
-  main,
-  parsePorcelainZ,
-  runCheck,
-  runStage,
-  runStart
-};