@getpipher/armory-fleet 0.4.0 → 0.5.0

package/src/vendor/cron-parser/lib/parser.js

@@ -0,0 +1,103 @@
+'use strict';
+
+var CronExpression = require('./expression');
+
+function CronParser() {}
+
+/**
+ * Parse crontab entry
+ *
+ * @private
+ * @param {String} entry Crontab file entry/line
+ */
+CronParser._parseEntry = function _parseEntry (entry) {
+  var atoms = entry.split(' ');
+
+  if (atoms.length === 6) {
+    return {
+      interval: CronExpression.parse(entry)
+    };
+  } else if (atoms.length > 6) {
+    return {
+      interval: CronExpression.parse(entry),
+      command: atoms.slice(6, atoms.length)
+    };
+  } else {
+    throw new Error('Invalid entry: ' + entry);
+  }
+};
+
+/**
+ * Wrapper for CronExpression.parser method
+ *
+ * @public
+ * @param {String} expression Input expression
+ * @param {Object} [options] Parsing options
+ * @return {Object}
+ */
+CronParser.parseExpression = function parseExpression (expression, options, callback) {
+  return CronExpression.parse(expression, options, callback);
+};
+
+/**
+ * Parse content string
+ *
+ * @public
+ * @param {String} data Crontab content
+ * @return {Object}
+ */
+CronParser.parseString = function parseString (data) {
+  var self = this;
+  var blocks = data.split('\n');
+
+  var response = {
+    variables: {},
+    expressions: [],
+    errors: {}
+  };
+
+  for (var i = 0, c = blocks.length; i < c; i++) {
+    var block = blocks[i];
+    var matches = null;
+    var entry = block.replace(/^\s+|\s+$/g, ''); // Remove surrounding spaces
+
+    if (entry.length > 0) {
+      if (entry.match(/^#/)) { // Comment
+        continue;
+      } else if ((matches = entry.match(/^(.*)=(.*)$/))) { // Variable
+        response.variables[matches[1]] = matches[2];
+      } else { // Expression?
+        var result = null;
+
+        try {
+          result = self._parseEntry('0 ' + entry);
+          response.expressions.push(result.interval);
+        } catch (err) {
+          response.errors[entry] = err;
+        }
+      }
+    }
+  }
+
+  return response;
+};
+
+/**
+ * Parse crontab file
+ *
+ * @public
+ * @param {String} filePath Path to file
+ * @param {Function} callback
+ */
+CronParser.parseFile = function parseFile (filePath, callback) {
+  require('fs').readFile(filePath, function(err, data) {
+    if (err) {
+      callback(err);
+      return;
+    }
+
+    return callback(null, CronParser.parseString(data.toString()));
+  });
+};
+
+module.exports = CronParser;

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
+    }
+  }
+}