@glrs-dev/cli 2.4.0 → 2.6.0

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

@@ -0,0 +1,91 @@
+import {
+  hasSpec,
+  readSpecGoal,
+  readSpecTitle
+} from "./chunk-GXXCEGDD.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 = opts.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-BLEIZHET.js

@@ -0,0 +1,101 @@
+import {
+  hasSpec,
+  readSpecTitle
+} from "./chunk-GXXCEGDD.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-GXXCEGDD.js

@@ -0,0 +1,251 @@
+// 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 } : {},
+    ...item.proof !== void 0 ? { proof: item.proof } : {},
+    ...item.proof_type !== void 0 ? { proof_type: item.proof_type } : {}
+  };
+}
+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-S34HOCZ4.js

@@ -0,0 +1,44 @@
+// src/model-resolver.ts
+var CLAUDE_TIER_ALIASES = {
+  deep: "claude-opus-4-7",
+  prime: "claude-opus-4-7",
+  mid: "claude-sonnet-4-6",
+  "mid-execute": "claude-sonnet-4-6",
+  "autopilot-execute": "claude-haiku-4-5-20251001",
+  fast: "claude-haiku-4-5-20251001"
+};
+var warnedOnce = null;
+function warn(message) {
+  if (!warnedOnce) warnedOnce = /* @__PURE__ */ new Set();
+  if (warnedOnce.has(message)) return;
+  warnedOnce.add(message);
+  console.warn(`[model-resolver] ${message}`);
+}
+function resolveModel(specifier, adapterName, opencodeTiers) {
+  if (specifier.includes("/")) {
+    return specifier;
+  }
+  if (adapterName === "claude-code-cli") {
+    if (specifier in CLAUDE_TIER_ALIASES) {
+      return CLAUDE_TIER_ALIASES[specifier];
+    }
+    return specifier;
+  }
+  if (!opencodeTiers) {
+    return specifier;
+  }
+  const resolved = opencodeTiers[specifier];
+  if (resolved !== void 0) {
+    return Array.isArray(resolved) ? resolved[0] : resolved;
+  }
+  const fallback = opencodeTiers["deep"];
+  if (fallback !== void 0) {
+    warn(`Unknown tier "${specifier}"; falling back to "deep"`);
+    return Array.isArray(fallback) ? fallback[0] : fallback;
+  }
+  return specifier;
+}
+
+export {
+  resolveModel
+};