@gobing-ai/spur 0.3.99 → 0.4.1

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

@@ -0,0 +1,28 @@
+/**
+ * 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 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,255 @@
+// 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;
+}
+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,
+  planLetter,
+  planChild,
+  insertOnEntry,
+  hostText,
+  hostStatus,
+  buildPhasedPlan,
+  buildBatchPlan
+};

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

@@ -10,6 +10,18 @@ export declare const LOCKED_PATTERN: RegExp;
 export declare const FINDINGS_PATTERN: RegExp;
 export declare const COVERAGE_ROW_PATTERN: RegExp;
 export declare const RECEIPT_SCHEMA_VERSION: 'check-receipt/v1';
+export declare const GATE_LOCK_DIR_ENV: string;
+export declare const GATE_LOCK_POLL_MS_ENV: string;
+export declare const GATE_LOCK_OFF_ENV: string;
+export declare const GATE_LOCK_TOKEN_ENV: string;
+export declare const GATE_LOCK_POLL_MS_DEFAULT: number;
+export declare const GATE_LOCK_MKDIR_HOLD_MS_ENV: string;
+export declare interface GateLock {
+    release(): void;
+    queueWaitMs: number;
+    token: string;
+}
+export declare function acquireGateLock(env: QualityGateEnv, logLine?: (line: string) => void): GateLock;
 export declare interface QualityGateEnv {
     wbs: string;
     qualityGateCmd?: string;
@@ -20,6 +32,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 +91,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 +132,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,