@gobing-ai/spur 0.4.0 → 0.4.2

package/plugins/sp/lib/plan-projection.generated.d.mts

@@ -0,0 +1,47 @@
+/**
+ * GENERATED by scripts/commands/bundle-plugin-lib.ts — do not edit.
+ * Source of truth: packages/app/src/workflow/plan-projection.ts (task 1104).
+ */
+export declare interface PhasedPlanItem {
+    label: string;
+    id: string;
+    outcome: 'pending' | 'active' | 'completed' | 'skipped' | 'failed' | 'blocked' | 'unattempted';
+    note?: string;
+    text: string;
+    parent?: string;
+    title?: string;
+}
+export declare interface BatchTask {
+    wbs: string;
+    name: string;
+}
+export declare function planLetter(index: number): string;
+export declare function planChild(parent: string, index: number): string;
+export declare function buildPhasedPlan(def: unknown): PhasedPlanItem[] | null;
+export declare function validatePhaseTable(def: unknown): string[];
+export declare function insertOnEntry(items: PhasedPlanItem[], stateId: string, def: unknown): PhasedPlanItem[];
+export declare function buildBatchPlan(tasks: BatchTask[]): PhasedPlanItem[][];
+export declare interface ScheduleTask {
+    wbs: string;
+    dependencies?: string[];
+    files?: string[];
+}
+export declare interface ScheduleOverlap {
+    before: string;
+    after: string;
+    files: string[];
+}
+export declare interface BatchSchedule {
+    order: string[];
+    waves: string[][];
+    cycle: string[] | null;
+    overlaps: ScheduleOverlap[];
+    mode: 'sequential' | 'parallel';
+    reason: string;
+}
+export declare function scheduleBatch(tasks: ScheduleTask[], opts?: { concurrency?: number }): BatchSchedule;
+export declare function taskPhaseChildren(taskLetter: string, plan: PhasedPlanItem[]): PhasedPlanItem[];
+export declare function hostStatus(
+    outcome: 'pending' | 'active' | 'completed' | 'skipped' | 'failed' | 'blocked' | 'unattempted',
+): 'completed' | 'in_progress' | 'pending';
+export declare function hostText(item: PhasedPlanItem): string;

package/plugins/sp/lib/plan-projection.generated.mjs

@@ -0,0 +1,368 @@
+// packages/app/src/workflow/plan-projection.ts
+function planLetter(index) {
+  if (!Number.isInteger(index) || index < 0 || index > 25) {
+    throw new Error(`plan letter out of range: ${index} (expected 0..25)`);
+  }
+  return String.fromCharCode(65 + index);
+}
+function planChild(parent, index) {
+  if (!Number.isInteger(index) || index < 0 || index > 8) {
+    throw new Error(`plan child index out of range: ${index} (expected 0..8 under ${parent})`);
+  }
+  if (parent.length !== 1 || !/[A-Z]/.test(parent)) {
+    throw new Error(`plan child parent must be a single letter: ${parent}`);
+  }
+  return `${parent}${index + 1}`;
+}
+var PREPARE_ID = "prepare";
+var REPORT_ID = "report";
+var PHASE_ID_PREFIX = "phase.";
+var TASK_ID_PREFIX = "task.";
+var WAVE_SIZE = 24;
+var TITLE_CAP = 60;
+function isStateMachine(def) {
+  return def.kind !== "transition-flow" && def.kind !== "dag";
+}
+function hasDisplay(s) {
+  return s.display !== undefined;
+}
+function resolvePhaseTitle(states, phase) {
+  for (const s of states) {
+    if (s.display?.phase === phase && s.display.phaseTitle !== undefined)
+      return s.display.phaseTitle;
+  }
+  return phase;
+}
+function childText(label, title, id) {
+  return id.startsWith("prepare.") || id.startsWith("task.") || id === PREPARE_ID || id === REPORT_ID ? `${label} ${title}` : `${label} ${title} · ${id}`;
+}
+function buildPhasedPlan(def) {
+  if (!isStateMachine(def))
+    return null;
+  const annotated = def.states.filter(hasDisplay);
+  if (annotated.length === 0)
+    return null;
+  const items = [
+    { label: "A", id: PREPARE_ID, outcome: "pending", title: "Prepare", text: "A Prepare" },
+    {
+      label: "A1",
+      id: "prepare.1",
+      outcome: "pending",
+      parent: "A",
+      title: "Quick readiness",
+      text: "A1 Quick readiness"
+    },
+    { label: "A2", id: "prepare.2", outcome: "pending", parent: "A", title: "Prepare Git", text: "A2 Prepare Git" },
+    {
+      label: "A3",
+      id: "prepare.3",
+      outcome: "pending",
+      parent: "A",
+      title: "Publish plan",
+      text: "A3 Publish plan"
+    }
+  ];
+  const phases = [];
+  for (const s of def.states) {
+    if (s.display !== undefined && !phases.includes(s.display.phase))
+      phases.push(s.display.phase);
+  }
+  for (const [phaseIndex, phase] of phases.entries()) {
+    const letter = planLetter(phaseIndex + 1);
+    const phaseTitle = resolvePhaseTitle(def.states, phase);
+    items.push({
+      label: letter,
+      id: `${PHASE_ID_PREFIX}${phase}`,
+      outcome: "pending",
+      title: phaseTitle,
+      text: `${letter} ${phaseTitle}`
+    });
+    let childIndex = 0;
+    for (const s of def.states) {
+      if (s.display?.phase !== phase || s.display.show === "on-entry")
+        continue;
+      const label = planChild(letter, childIndex++);
+      const title = s.display.title ?? s.id;
+      items.push({
+        label,
+        id: s.id,
+        outcome: "pending",
+        parent: letter,
+        title,
+        text: childText(label, title, s.id)
+      });
+    }
+  }
+  return items;
+}
+function validatePhaseTable(def) {
+  if (!isStateMachine(def))
+    return [];
+  const annotated = def.states.filter(hasDisplay);
+  if (annotated.length === 0)
+    return [];
+  const errors = [];
+  const terminals = new Set(def.terminalStates ?? []);
+  for (const s of def.states) {
+    if (s.display === undefined && !terminals.has(s.id)) {
+      errors.push(`state "${s.id}" has no display phase — every non-terminal state must declare display when any state does`);
+    }
+    if (s.display !== undefined && terminals.has(s.id)) {
+      errors.push(`terminal state "${s.id}" must not declare display`);
+    }
+  }
+  const phases = [];
+  for (const s of annotated) {
+    if (!phases.includes(s.display.phase))
+      phases.push(s.display.phase);
+  }
+  if (phases.length > 25) {
+    errors.push(`${phases.length} phases exceed the 25 plan letters (B-Z); split the workflow or drop phase rows`);
+  }
+  for (const phase of phases) {
+    const members = annotated.filter((s) => s.display.phase === phase);
+    if (members.length > 9) {
+      errors.push(`phase "${phase}" has ${members.length} states — at most 9 digit children fit under one letter`);
+    }
+    const titles = [...new Set(members.map((s) => s.display.phaseTitle).filter((t) => t !== undefined))];
+    if (titles.length > 1) {
+      errors.push(`phase "${phase}" has conflicting phaseTitle values: ${titles.map((t) => `"${t}"`).join(", ")}`);
+    }
+  }
+  return errors;
+}
+function insertOnEntry(items, stateId, def) {
+  if (!isStateMachine(def))
+    return items;
+  if (items.some((i) => i.id === stateId))
+    return items;
+  const display = def.states.find((s) => s.id === stateId)?.display;
+  if (display === undefined || (def.terminalStates ?? []).includes(stateId))
+    return items;
+  const phaseRow = items.find((i) => i.id === `${PHASE_ID_PREFIX}${display.phase}`);
+  if (phaseRow === undefined)
+    return items;
+  const children = items.filter((i) => i.parent === phaseRow.label);
+  const label = planChild(phaseRow.label, children.length);
+  const title = display.title ?? stateId;
+  const item = {
+    label,
+    id: stateId,
+    outcome: "pending",
+    parent: phaseRow.label,
+    title,
+    text: childText(label, title, stateId)
+  };
+  const last = children.at(-1) ?? phaseRow;
+  const at = items.indexOf(last) + 1;
+  return [...items.slice(0, at), item, ...items.slice(at)];
+}
+function truncateTitle(name) {
+  if (name.length <= TITLE_CAP)
+    return name;
+  return `${name.slice(0, TITLE_CAP - 1).replace(/[\uD800-\uDBFF]$/, "")}…`;
+}
+function buildBatchPlan(tasks) {
+  const waves = [];
+  for (let offset = 0;offset < tasks.length; offset += WAVE_SIZE) {
+    const items = [
+      { label: "A", id: PREPARE_ID, outcome: "pending", title: "Prepare batch", text: "A Prepare batch" },
+      {
+        label: "A1",
+        id: "prepare.1",
+        outcome: "pending",
+        parent: "A",
+        title: "Resolve and freeze task set",
+        text: "A1 Resolve and freeze task set"
+      },
+      {
+        label: "A2",
+        id: "prepare.2",
+        outcome: "pending",
+        parent: "A",
+        title: "Order by dependencies",
+        text: "A2 Order by dependencies"
+      },
+      {
+        label: "A3",
+        id: "prepare.3",
+        outcome: "pending",
+        parent: "A",
+        title: "Prepare Git",
+        text: "A3 Prepare Git"
+      },
+      {
+        label: "A4",
+        id: "prepare.4",
+        outcome: "pending",
+        parent: "A",
+        title: "Publish plan",
+        text: "A4 Publish plan"
+      }
+    ];
+    tasks.slice(offset, offset + WAVE_SIZE).forEach((task, i) => {
+      const label = planLetter(i + 1);
+      const title = `${task.wbs} ${truncateTitle(task.name)}`;
+      items.push({
+        label,
+        id: `${TASK_ID_PREFIX}${task.wbs}`,
+        outcome: "pending",
+        title,
+        text: `${label} ${title}`
+      });
+    });
+    items.push({ label: "Z", id: REPORT_ID, outcome: "pending", title: "Batch report", text: "Z Batch report" });
+    waves.push(items);
+  }
+  return waves;
+}
+var byWbs = (a, b) => a.localeCompare(b, "en", { numeric: true });
+function kahnOrder(nodes, preds) {
+  const indegree = new Map(nodes.map((n) => [n, preds.get(n)?.size ?? 0]));
+  const succ = new Map(nodes.map((n) => [n, []]));
+  for (const [n, ps] of preds)
+    for (const p of ps)
+      succ.get(p)?.push(n);
+  const ready = nodes.filter((n) => indegree.get(n) === 0).sort(byWbs);
+  const order = [];
+  for (let n = ready.shift();n !== undefined; n = ready.shift()) {
+    order.push(n);
+    for (const s of succ.get(n) ?? []) {
+      const d = (indegree.get(s) ?? 0) - 1;
+      indegree.set(s, d);
+      if (d === 0) {
+        ready.push(s);
+        ready.sort(byWbs);
+      }
+    }
+  }
+  return order;
+}
+function findCycle(remaining, preds) {
+  const state = new Map;
+  const stack = [];
+  const visit = (n) => {
+    state.set(n, "visiting");
+    stack.push(n);
+    for (const p of [...preds.get(n) ?? []].sort(byWbs)) {
+      if (!remaining.has(p))
+        continue;
+      if (state.get(p) === "visiting")
+        return [...stack.slice(stack.indexOf(p)), p];
+      if (!state.has(p)) {
+        const cycle = visit(p);
+        if (cycle)
+          return cycle;
+      }
+    }
+    stack.pop();
+    state.set(n, "done");
+    return null;
+  };
+  for (const n of [...remaining].sort(byWbs)) {
+    if (state.has(n))
+      continue;
+    const cycle = visit(n);
+    if (cycle)
+      return cycle;
+  }
+  return [];
+}
+function scheduleBatch(tasks, opts = {}) {
+  const byId = new Map;
+  for (const t of tasks)
+    if (!byId.has(t.wbs))
+      byId.set(t.wbs, t);
+  const nodes = [...byId.keys()].sort(byWbs);
+  const preds = new Map(nodes.map((n) => [n, new Set((byId.get(n)?.dependencies ?? []).filter((d) => byId.has(d)))]));
+  const depOrder = kahnOrder(nodes, preds);
+  if (depOrder.length < nodes.length) {
+    const cycle = findCycle(new Set(nodes.filter((n) => !depOrder.includes(n))), preds);
+    return {
+      order: [],
+      waves: [],
+      cycle,
+      overlaps: [],
+      mode: "sequential",
+      reason: `dependency cycle ${cycle.join(" → ")}`
+    };
+  }
+  const files = new Map(nodes.map((n) => [n, new Set((byId.get(n)?.files ?? []).map(normalizeTaskPath))]));
+  const overlaps = [];
+  for (let i = 0;i < depOrder.length; i++) {
+    const before = depOrder[i];
+    const beforeFiles = files.get(before) ?? new Set;
+    for (const after of depOrder.slice(i + 1)) {
+      const shared = [...beforeFiles].filter((f) => files.get(after)?.has(f)).sort();
+      if (shared.length === 0)
+        continue;
+      overlaps.push({ before, after, files: shared });
+      preds.get(after)?.add(before);
+    }
+  }
+  const order = kahnOrder(nodes, preds);
+  const level = new Map;
+  for (const n of order) {
+    let l = 0;
+    for (const p of preds.get(n) ?? [])
+      l = Math.max(l, (level.get(p) ?? 0) + 1);
+    level.set(n, l);
+  }
+  const waves = [];
+  for (const n of order) {
+    const l = level.get(n) ?? 0;
+    waves[l] = [...waves[l] ?? [], n].sort(byWbs);
+  }
+  const widest = Math.max(0, ...waves.map((w) => w.length));
+  const concurrency = opts.concurrency ?? 2;
+  let reason = `widest wave holds ${widest} independent tasks`;
+  if (nodes.length < 2)
+    reason = "fewer than two tasks";
+  else if (concurrency < 2)
+    reason = "concurrency is 1";
+  else if (widest < 2)
+    reason = "every wave holds one task (dependency or file-overlap chain)";
+  const mode = nodes.length >= 2 && concurrency >= 2 && widest >= 2 ? "parallel" : "sequential";
+  return { order, waves, cycle: null, overlaps, mode, reason };
+}
+function normalizeTaskPath(path) {
+  return path.trim().replace(/^\.\//, "");
+}
+function taskPhaseChildren(taskLetter, plan) {
+  if (!Array.isArray(plan))
+    return [];
+  return plan.filter((i) => i.id.startsWith(PHASE_ID_PREFIX) && i.label.length === 1).map((row, i) => {
+    const label = planChild(taskLetter, i);
+    return {
+      label,
+      id: row.id,
+      outcome: row.outcome,
+      parent: taskLetter,
+      title: row.title,
+      text: `${label} ${row.title}`
+    };
+  });
+}
+function hostStatus(outcome) {
+  if (outcome === "completed")
+    return "completed";
+  if (outcome === "active")
+    return "in_progress";
+  return "pending";
+}
+function hostText(item) {
+  const hostDecided = item.outcome === "skipped" || item.outcome === "failed" || item.outcome === "unattempted" || item.outcome === "blocked";
+  return hostDecided ? `${item.text} [${item.outcome}]` : item.text;
+}
+export {
+  validatePhaseTable,
+  taskPhaseChildren,
+  scheduleBatch,
+  planLetter,
+  planChild,
+  insertOnEntry,
+  hostText,
+  hostStatus,
+  buildPhasedPlan,
+  buildBatchPlan
+};

package/plugins/sp/lib/quality-gate.generated.d.mts

@@ -20,6 +20,10 @@ export declare interface QualityGateEnv {
 }
 export declare interface QualityGateOptions {
     cwd?: string;
+    recomputeFingerprint?: (
+        cwd: string,
+        env: QualityGateEnv,
+    ) => { ok: true; digest: string } | { ok: false; error: string };
 }
 export declare interface QualityGateResult {
     status: 'PASS' | 'FAIL';
@@ -75,12 +79,32 @@ export declare interface BuildReceiptInput {
 export declare function buildReceipt(input: BuildReceiptInput): CheckReceipt;
 export declare function receiptFailsAtDigest(receipt: CheckReceipt | null, currentDigest: string): boolean;
 export declare function readReceiptStatus(receiptPath: string, currentDigest: string): ReceiptReadStatus;
+export declare interface ReceiptReuseDecision {
+    reuse: boolean;
+    receiptStatus: ReceiptReadStatus;
+    refusal?: string;
+    recomputedDigest?: string;
+}
+export declare function resolveReceiptReuse(
+    receiptPath: string,
+    env: QualityGateEnv,
+    cwd: string,
+    recomputeFn?: (
+        cwd: string,
+        env: QualityGateEnv,
+    ) => { ok: true; digest: string } | { ok: false; error: string },
+): ReceiptReuseDecision;
+export declare function recomputeGateProofFingerprint(
+    cwd: string,
+    env: QualityGateEnv,
+): { ok: true; digest: string } | { ok: false; error: string };
 export declare interface LightScope {
     files: string[];
     workspaces: string[];
     tests: string[];
 }
 export declare function lightScope(changedFiles: string[], exists?: (p: string) => boolean): LightScope;
+export declare const scopeFromFiles: typeof lightScope;
 export declare function shQuote(arg: string): string;
 export declare interface LightCheckPlan {
     id: string;
@@ -96,7 +120,17 @@ export declare interface LightGateResult {
     receiptFile: string;
 }
 export declare function runLightGate(env: QualityGateEnv, options?: QualityGateOptions): LightGateResult;
-export declare function runShellCommand(cmd: string, cwd: string | undefined): { output: string; code: number };
+export declare interface DeferredGateResult {
+    status: 'DEFERRED' | 'FAIL';
+    light: LightGateResult;
+    statusFile: string;
+}
+export declare function runDeferredGate(env: QualityGateEnv, options?: QualityGateOptions): DeferredGateResult;
+export declare function runShellCommand(
+    cmd: string,
+    cwd: string | undefined,
+    extraEnv?: Record<string, string>,
+): { output: string; code: number };
 export declare function runQualityGate(
     mode: 'run' | 'recheck',
     env: QualityGateEnv,