@glrs-dev/cli 2.4.0 → 2.4.1

package/dist/node_modules/@glrs-dev/autopilot/dist/chunk-7OSEI5TF.js

@@ -0,0 +1,249 @@
+// src/spec-schema.ts
+function validateMainSpec(raw) {
+  const errors = [];
+  if (typeof raw !== "object" || raw === null) {
+    return { valid: false, errors: ["main spec must be an object"] };
+  }
+  const obj = raw;
+  if (!("phases" in obj)) {
+    errors.push("main spec missing required field: phases");
+  } else if (!Array.isArray(obj["phases"])) {
+    errors.push("main spec field 'phases' must be an array");
+  } else {
+    const phases = obj["phases"];
+    for (let i = 0; i < phases.length; i++) {
+      const phase = phases[i];
+      if (typeof phase !== "object" || phase === null) {
+        errors.push(`phases[${i}] must be an object`);
+        continue;
+      }
+      const p = phase;
+      if (!("file" in p) || typeof p["file"] !== "string") {
+        errors.push(`phases[${i}] missing required field: file`);
+      }
+      if (!("completed" in p) || typeof p["completed"] !== "boolean") {
+        errors.push(`phases[${i}] missing required field: completed (boolean)`);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validatePhaseSpec(raw) {
+  const errors = [];
+  if (typeof raw !== "object" || raw === null) {
+    return { valid: false, errors: ["phase spec must be an object"] };
+  }
+  const obj = raw;
+  if (!("items" in obj)) {
+    errors.push("phase spec missing required field: items");
+    return { valid: false, errors };
+  }
+  if (!Array.isArray(obj["items"])) {
+    errors.push("phase spec field 'items' must be an array");
+    return { valid: false, errors };
+  }
+  const items = obj["items"];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (typeof item !== "object" || item === null) {
+      errors.push(`items[${i}] must be an object`);
+      continue;
+    }
+    const it = item;
+    if (!("id" in it) || typeof it["id"] !== "string" || !it["id"]) {
+      errors.push(`items[${i}] missing required field: id`);
+    }
+    if (!("intent" in it) || typeof it["intent"] !== "string" || !it["intent"]) {
+      errors.push(`items[${i}] missing required field: intent`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/spec-parser.ts
+import * as fs from "fs";
+import * as path from "path";
+import { parse as yamlParse } from "yaml";
+var DEGRADED = {
+  type: "single",
+  totalItems: 0,
+  checkedItems: 0,
+  phaseCount: 0,
+  phasesCompleted: 0,
+  phases: []
+};
+function hasSpec(planDir) {
+  try {
+    return fs.existsSync(path.join(planDir, "spec", "main.yaml"));
+  } catch {
+    return false;
+  }
+}
+function specItemToPlanItem(item) {
+  const files = (item.files ?? []).map((f) => ({
+    path: f.path,
+    isNew: f.isNew ?? false,
+    change: f.change ?? ""
+  }));
+  return {
+    id: item.id,
+    intent: item.intent,
+    checked: item.checked ?? false,
+    files,
+    tests: item.tests ?? [],
+    verify: item.verify ?? "",
+    ...item.mirror !== void 0 ? { mirror: item.mirror } : {},
+    ...item.context !== void 0 ? { context: item.context } : {},
+    ...item.conventions !== void 0 ? { conventions: item.conventions } : {}
+  };
+}
+function parseSpecItems(phasePath) {
+  try {
+    const content = fs.readFileSync(phasePath, "utf-8");
+    const raw = yamlParse(content);
+    const validation = validatePhaseSpec(raw);
+    if (!validation.valid) {
+      return [];
+    }
+    const spec = raw;
+    return spec.items.map(specItemToPlanItem);
+  } catch {
+    return [];
+  }
+}
+function parseSpecState(planDir) {
+  try {
+    const mainPath = path.join(planDir, "spec", "main.yaml");
+    if (!fs.existsSync(mainPath)) {
+      return { ...DEGRADED };
+    }
+    const mainContent = fs.readFileSync(mainPath, "utf-8");
+    const rawMain = yamlParse(mainContent);
+    const mainValidation = validateMainSpec(rawMain);
+    if (!mainValidation.valid) {
+      return { ...DEGRADED, type: "multi" };
+    }
+    const mainSpec = rawMain;
+    const phases = [];
+    let totalItems = 0;
+    let checkedItems = 0;
+    let phasesCompleted = 0;
+    for (const phaseRef of mainSpec.phases) {
+      const phasePath = path.join(planDir, "spec", phaseRef.file);
+      const items = parseSpecItems(phasePath);
+      const phaseTotal = items.length;
+      const phaseChecked = items.filter((it) => it.checked).length;
+      phases.push({
+        file: phaseRef.file,
+        totalItems: phaseTotal,
+        checkedItems: phaseChecked
+      });
+      totalItems += phaseTotal;
+      checkedItems += phaseChecked;
+      if (phaseRef.completed) {
+        phasesCompleted++;
+      }
+    }
+    return {
+      type: "multi",
+      totalItems,
+      checkedItems,
+      phaseCount: mainSpec.phases.length,
+      phasesCompleted,
+      phases
+    };
+  } catch {
+    return { ...DEGRADED };
+  }
+}
+function detectSpecPhases(planDir) {
+  try {
+    const mainPath = path.join(planDir, "spec", "main.yaml");
+    if (!fs.existsSync(mainPath)) {
+      return [];
+    }
+    const content = fs.readFileSync(mainPath, "utf-8");
+    const raw = yamlParse(content);
+    const validation = validateMainSpec(raw);
+    if (!validation.valid) {
+      return [];
+    }
+    const spec = raw;
+    return spec.phases.map((p) => p.file);
+  } catch {
+    return [];
+  }
+}
+function readSpecGoal(planDir) {
+  try {
+    const mainPath = path.join(planDir, "spec", "main.yaml");
+    const content = fs.readFileSync(mainPath, "utf-8");
+    const raw = yamlParse(content);
+    if (typeof raw === "object" && raw !== null) {
+      const obj = raw;
+      if (typeof obj["goal"] === "string") return obj["goal"];
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+function readSpecTitle(planDir) {
+  try {
+    const mainPath = path.join(planDir, "spec", "main.yaml");
+    const content = fs.readFileSync(mainPath, "utf-8");
+    const raw = yamlParse(content);
+    if (typeof raw === "object" && raw !== null) {
+      const obj = raw;
+      if (typeof obj["title"] === "string") return obj["title"];
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+function readSpecConstraints(planDir) {
+  try {
+    const mainPath = path.join(planDir, "spec", "main.yaml");
+    const content = fs.readFileSync(mainPath, "utf-8");
+    const raw = yamlParse(content);
+    if (typeof raw === "object" && raw !== null) {
+      const obj = raw;
+      if (typeof obj["constraints"] === "string") return obj["constraints"];
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+function filterUncheckedSpecPhases(phaseFiles, planDir) {
+  try {
+    const mainPath = path.join(planDir, "spec", "main.yaml");
+    const content = fs.readFileSync(mainPath, "utf-8");
+    const raw = yamlParse(content);
+    const validation = validateMainSpec(raw);
+    if (!validation.valid) {
+      return phaseFiles;
+    }
+    const spec = raw;
+    const completedSet = new Set(
+      spec.phases.filter((p) => p.completed === true).map((p) => p.file)
+    );
+    return phaseFiles.filter((f) => !completedSet.has(f));
+  } catch {
+    return phaseFiles;
+  }
+}
+
+export {
+  validateMainSpec,
+  validatePhaseSpec,
+  hasSpec,
+  parseSpecItems,
+  parseSpecState,
+  detectSpecPhases,
+  readSpecGoal,
+  readSpecTitle,
+  readSpecConstraints,
+  filterUncheckedSpecPhases
+};

package/dist/node_modules/@glrs-dev/autopilot/dist/chunk-E7PWTRFO.js

@@ -0,0 +1,91 @@
+import {
+  hasSpec,
+  readSpecGoal,
+  readSpecTitle
+} from "./chunk-7OSEI5TF.js";
+
+// src/changeset-generator.ts
+import * as fs from "fs";
+import * as path from "path";
+var TARGET_PACKAGE = "@glrs-dev/harness-plugin-opencode";
+function readPlanTitle(planPath) {
+  try {
+    const stat = fs.statSync(planPath);
+    if (stat.isDirectory() && hasSpec(planPath)) {
+      const yamlTitle = readSpecTitle(planPath);
+      if (yamlTitle) return yamlTitle;
+    }
+    const target = stat.isDirectory() ? path.join(planPath, "main.md") : planPath;
+    const content = fs.readFileSync(target, "utf-8");
+    const match = content.match(/^#\s+(.+?)\s*$/m);
+    return match ? match[1].trim() : "";
+  } catch {
+    return "";
+  }
+}
+function readPlanGoal(planPath) {
+  try {
+    const stat = fs.statSync(planPath);
+    if (stat.isDirectory() && hasSpec(planPath)) {
+      const yamlGoal = readSpecGoal(planPath);
+      if (yamlGoal) return yamlGoal;
+    }
+    const target = stat.isDirectory() ? path.join(planPath, "main.md") : planPath;
+    const content = fs.readFileSync(target, "utf-8");
+    const re = /^##\s+Goal\s*\n([\s\S]*?)(?=^##\s|$)/m;
+    const match = content.match(re);
+    if (match) {
+      return match[1].trim().replace(/\s+/g, " ");
+    }
+    return readPlanTitle(planPath);
+  } catch {
+    return "";
+  }
+}
+function inferBumpLevel(title) {
+  const t = title.toLowerCase();
+  if (t.includes("remove ") || t.includes("removal") || t.includes("breaking") || t.includes("break ") || /\bv2\b/.test(t) || /\bv\d+\b/.test(t.replace(/v1\b/, ""))) {
+    return "major";
+  }
+  if (/\bfix\b/.test(t) || /\bbug(s|fix)?\b/.test(t) || t.includes("hotfix")) {
+    return "patch";
+  }
+  return "minor";
+}
+function slugifyTitle(title) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  return slug.length > 0 ? slug : "autopilot";
+}
+function defaultRandomSuffix() {
+  return Math.random().toString(36).slice(2, 8);
+}
+async function generateChangeset(planPath, repoRoot, opts = {}) {
+  const packageName = opts.packageName ?? TARGET_PACKAGE;
+  const randomSuffix = opts._randomSuffix ?? defaultRandomSuffix;
+  const title = readPlanTitle(planPath) || "Autopilot run";
+  const goal = readPlanGoal(planPath) || title;
+  const bumpLevel = inferBumpLevel(title);
+  const slug = slugifyTitle(title);
+  const content = `---
+"${packageName}": ${bumpLevel}
+---
+
+${goal}
+`;
+  const changesetDir = path.join(repoRoot, ".changeset");
+  if (!fs.existsSync(changesetDir)) {
+    fs.mkdirSync(changesetDir, { recursive: true });
+  }
+  const filename = `${slug}-${randomSuffix()}.md`;
+  const filePath = path.join(changesetDir, filename);
+  fs.writeFileSync(filePath, content, "utf-8");
+  return { path: filePath, content, bumpLevel };
+}
+
+export {
+  readPlanTitle,
+  readPlanGoal,
+  inferBumpLevel,
+  slugifyTitle,
+  generateChangeset
+};

package/dist/node_modules/@glrs-dev/autopilot/dist/chunk-M2ZVBPWL.js

@@ -0,0 +1,101 @@
+import {
+  hasSpec,
+  readSpecTitle
+} from "./chunk-7OSEI5TF.js";
+
+// src/auto-ship.ts
+import { execFile as execFileCb } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs";
+import * as path from "path";
+var execFileDefault = promisify(execFileCb);
+var FORBIDDEN_BRANCHES = /* @__PURE__ */ new Set(["main", "master"]);
+function resolvePlanMainPath(planPath) {
+  try {
+    if (fs.statSync(planPath).isDirectory()) {
+      return path.join(planPath, "main.md");
+    }
+  } catch {
+  }
+  return planPath;
+}
+function readPlanH1(planPath) {
+  try {
+    if (fs.statSync(planPath).isDirectory() && hasSpec(planPath)) {
+      const yamlTitle = readSpecTitle(planPath);
+      if (yamlTitle) return yamlTitle;
+    }
+  } catch {
+  }
+  const target = resolvePlanMainPath(planPath);
+  try {
+    const content = fs.readFileSync(target, "utf-8");
+    const match = content.match(/^#\s+(.+?)\s*$/m);
+    if (match) return match[1].trim();
+  } catch {
+  }
+  return "Autopilot run";
+}
+async function autoShip(opts) {
+  const execFile = opts._deps?.execFile ?? execFileDefault;
+  const cwd = opts.repoRoot;
+  let branch;
+  try {
+    const { stdout } = await execFile(
+      "git",
+      ["rev-parse", "--abbrev-ref", "HEAD"],
+      { cwd }
+    );
+    branch = (typeof stdout === "string" ? stdout : String(stdout)).trim();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`auto-ship: failed to resolve current branch: ${msg}`);
+  }
+  if (!branch || branch === "HEAD") {
+    throw new Error(
+      `auto-ship: refusing to ship from a detached HEAD (branch="${branch}")`
+    );
+  }
+  if (FORBIDDEN_BRANCHES.has(branch)) {
+    throw new Error(
+      `auto-ship: refusing to push to forbidden branch "${branch}". Create a feature branch first.`
+    );
+  }
+  try {
+    await execFile("git", ["push", "-u", "origin", branch], { cwd });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`auto-ship: git push failed: ${msg}`);
+  }
+  const title = readPlanH1(opts.planPath);
+  const bodyFile = resolvePlanMainPath(opts.planPath);
+  if (!fs.existsSync(bodyFile)) {
+    throw new Error(`auto-ship: plan body file not found: ${bodyFile}`);
+  }
+  let prUrl;
+  try {
+    const { stdout } = await execFile(
+      "gh",
+      [
+        "pr",
+        "create",
+        "--title",
+        title,
+        "--body-file",
+        bodyFile
+      ],
+      { cwd }
+    );
+    const text = typeof stdout === "string" ? stdout : String(stdout);
+    const urlMatch = text.match(/https?:\/\/\S+/);
+    prUrl = urlMatch ? urlMatch[0] : text.trim();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`auto-ship: gh pr create failed: ${msg}`);
+  }
+  return { prUrl, branch, title };
+}
+
+export {
+  autoShip
+};

package/dist/node_modules/@glrs-dev/autopilot/dist/chunk-Q4ULU6ER.js

@@ -0,0 +1,68 @@
+// src/lib/logger.ts
+import pino from "pino";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+function resolveLogFilePath(cwd) {
+  const env = process.env["GLRS_AUTOPILOT_LOG_FILE"];
+  if (env === "off") return null;
+  if (env) return env;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return join(cwd, ".agent", "autopilot-logs", `${timestamp}.log`);
+}
+function buildFileStream(cwd) {
+  const filePath = resolveLogFilePath(cwd);
+  if (!filePath) return null;
+  const parent = dirname(filePath);
+  if (!existsSync(parent)) {
+    mkdirSync(parent, { recursive: true });
+  }
+  return {
+    path: filePath,
+    entry: {
+      level: "trace",
+      // sync: true gives deterministic flushSync semantics so the file
+      // log is safe to read immediately after flush() returns (critical
+      // for tests and for reliable postmortem after a crash). Autopilot
+      // runs are long-lived enough that sync writes aren't a bottleneck.
+      stream: pino.destination({ dest: filePath, sync: true, mkdir: true })
+    }
+  };
+}
+function createAutopilotLogger(opts) {
+  const fileSink = buildFileStream(opts.cwd);
+  const streams = [];
+  if (fileSink) streams.push(fileSink.entry);
+  if (streams.length === 0) {
+    const root2 = pino({ level: "silent" });
+    return { root: root2, logFilePath: null, flush: async () => {
+    } };
+  }
+  const ms = pino.multistream(streams);
+  const root = pino(
+    {
+      level: "trace",
+      // file sink captures everything
+      timestamp: pino.stdTimeFunctions.isoTime
+    },
+    ms
+  );
+  const flush = async () => {
+    try {
+      ms.flushSync();
+    } catch {
+    }
+  };
+  return {
+    root,
+    logFilePath: fileSink?.path ?? null,
+    flush
+  };
+}
+function childLogger(root, component) {
+  return root.child({ component });
+}
+
+export {
+  createAutopilotLogger,
+  childLogger
+};