@getpipher/armory-fleet 0.3.0 → 0.5.0

package/src/vendor/cron-parser/types.d.ts

@@ -0,0 +1,12 @@
+// Type declarations for the vendored cron-parser lib (v1.1.1, CJS, dep-free).
+declare module "../vendor/cron-parser/lib/parser.js" {
+  export interface CronExpressionIter {
+    next(): Date;
+    prev(): Date;
+    hasNext(): boolean;
+  }
+  export interface ParseOptions { currentDate?: Date; endDate?: Date; iterator?: boolean; }
+  export function parseExpression(expression: string, options?: ParseOptions): CronExpressionIter;
+  export function parseString(entry: string): unknown;
+  export function parseFile(filePath: string): unknown;
+}

package/src/worktree/diff-service.ts

@@ -0,0 +1,40 @@
+// src/worktree/diff-service.ts
+// SPEC-5a §7 — worktree-diff artifact discovery for isolated runs (Q3=A).
+// All changes in the worktree vs base: tracked modifications + untracked new files.
+import { execSync } from "node:child_process";
+
+export interface PhaseArtifacts {
+  paths: string[];
+  summary: string;
+}
+
+function sh(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).toString();
+}
+
+const MAX_SUMMARY = 200;
+
+export class DiffService {
+  /**
+   * Compute a phase's artifacts = all changes in the worktree vs baseRef.
+   * Tracked modifications via `git diff --name-only`; untracked new files via
+   * `git status --porcelain` (?? entries). Deduped + sorted.
+   *
+   * @param childFinalText  the child's final text, truncated to MAX_SUMMARY chars as the prose summary.
+   */
+  diffPhase(worktreePath: string, baseRef: string, childFinalText = ""): PhaseArtifacts {
+    const tracked = sh(`git diff --name-only ${baseRef} --`, worktreePath)
+      .split("\n")
+      .filter(Boolean);
+    const status = sh("git status --porcelain", worktreePath);
+    const untracked = status
+      .split("\n")
+      .filter((l) => l.startsWith("?? "))
+      .map((l) => l.slice(3).trim());
+    const paths = Array.from(new Set([...tracked, ...untracked])).sort();
+    const summary = childFinalText.length > MAX_SUMMARY
+      ? childFinalText.slice(0, MAX_SUMMARY - 1) + "…"
+      : childFinalText;
+    return { paths, summary };
+  }
+}

package/src/worktree/worktree-service.ts

@@ -0,0 +1,92 @@
+// src/worktree/worktree-service.ts
+// Greenfield git worktree lifecycle (SPEC-5a §6, Q9=A — thin shell-outs, no git library).
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+export interface WorktreeRef {
+  path: string;
+  branch: string;
+}
+
+export interface WorktreeServiceOpts {
+  rootDir: string;
+  /** Where worktrees live. Defaults to <rootDir>/.pi/fleet/worktrees. */
+  worktreesDir?: string;
+}
+
+function sh(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+}
+
+export class WorktreeService {
+  private readonly rootDir: string;
+  private readonly worktreesDir: string;
+
+  constructor(opts: WorktreeServiceOpts) {
+    this.rootDir = opts.rootDir;
+    this.worktreesDir = opts.worktreesDir ?? join(opts.rootDir, ".pi", "fleet", "worktrees");
+  }
+
+  branchFor(runId: string): string {
+    return `fleet/${runId}`;
+  }
+
+  pathFor(runId: string): string {
+    return join(this.worktreesDir, runId);
+  }
+
+  exists(runId: string): boolean {
+    return existsSync(this.pathFor(runId));
+  }
+
+  create(runId: string, baseRef = "HEAD"): WorktreeRef {
+    if (this.exists(runId)) {
+      throw new Error(`worktree for run ${runId} already exists at ${this.pathFor(runId)}`);
+    }
+    mkdirSync(this.worktreesDir, { recursive: true });
+    const branch = this.branchFor(runId);
+    const path = this.pathFor(runId);
+    try {
+      sh(`git worktree add -b ${branch} ${path} ${baseRef}`, this.rootDir);
+    } catch (e) {
+      if (existsSync(path)) rmSync(path, { recursive: true, force: true });
+      const msg = (e as Error).message;
+      const tail = msg.split("\n").filter(Boolean).pop() ?? msg;
+      throw new Error(`worktree create failed for run ${runId} (base ${baseRef}): ${tail}`);
+    }
+    return { path, branch };
+  }
+
+  /** SPEC-5a: remove the worktree dir but KEEP the branch (for completed runs the branch is
+   *  kept for merge/inspection; only the worktree dir is temporary scaffolding). */
+  removeWorktree(runId: string): void {
+    const path = this.pathFor(runId);
+    if (existsSync(path)) {
+      try {
+        sh(`git worktree remove --force ${path}`, this.rootDir);
+      } catch {
+        rmSync(path, { recursive: true, force: true });
+        try { sh("git worktree prune", this.rootDir); } catch { /* ignore */ }
+      }
+    }
+  }
+
+  remove(runId: string): void {
+    const path = this.pathFor(runId);
+    const branch = this.branchFor(runId);
+    if (existsSync(path)) {
+      try {
+        sh(`git worktree remove --force ${path}`, this.rootDir);
+      } catch {
+        rmSync(path, { recursive: true, force: true });
+        try { sh("git worktree prune", this.rootDir); } catch { /* ignore */ }
+      }
+    }
+    try {
+      sh(`git branch -D ${branch}`, this.rootDir);
+    } catch {
+      // branch may not exist; ignore
+    }
+  }
+}