archondev 2.19.57 → 3.0.0

package/dist/chunk-AJNKSFHL.js

@@ -0,0 +1,491 @@
+// src/cli/ship.ts
+import chalk from "chalk";
+
+// src/core/ship/pipeline.ts
+import { execSync } from "child_process";
+
+// src/core/ship/version.ts
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+function detectVersionBump(commitMessages) {
+  const joined = commitMessages.join("\n").toLowerCase();
+  if (joined.includes("breaking change") || /^[a-z]+!:/m.test(joined)) {
+    return "major";
+  }
+  if (/^feat[:(]/m.test(joined)) {
+    return "minor";
+  }
+  return "patch";
+}
+function bumpVersion(current, level) {
+  const parts = current.replace(/^v/, "").split(".");
+  const major = parseInt(parts[0] ?? "0", 10);
+  const minor = parseInt(parts[1] ?? "0", 10);
+  const patch = parseInt(parts[2] ?? "0", 10);
+  switch (level) {
+    case "major":
+      return `${major + 1}.0.0`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "patch":
+      return `${major}.${minor}.${patch + 1}`;
+  }
+}
+async function readPackageVersion(cwd) {
+  try {
+    const pkgPath = join(cwd, "package.json");
+    const content = await readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function writePackageVersion(cwd, version) {
+  const pkgPath = join(cwd, "package.json");
+  const content = await readFile(pkgPath, "utf-8");
+  const pkg = JSON.parse(content);
+  pkg.version = version;
+  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+}
+
+// src/core/ship/changelog.ts
+function parseCommitMessages(commitLines) {
+  return commitLines.map((line) => {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^([a-z]+)(?:\([^)]*\))?[!]?:\s*(.+)/);
+    if (match) {
+      const type = match[1];
+      const validTypes = ["feat", "fix", "refactor", "docs", "chore"];
+      return {
+        type: validTypes.includes(type) ? type : "other",
+        message: match[2]
+      };
+    }
+    const hashMatch = trimmed.match(/^([0-9a-f]{7,40})\s+(.+)/);
+    if (hashMatch) {
+      return { type: "other", message: hashMatch[2], hash: hashMatch[1] };
+    }
+    return { type: "other", message: trimmed };
+  }).filter((e) => e.message.length > 0);
+}
+function generateChangelog(commits, version) {
+  const entries = parseCommitMessages(commits);
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const lines = [`## ${version} (${date})`];
+  const groups = {};
+  for (const entry of entries) {
+    const key = entry.type;
+    if (!groups[key]) groups[key] = [];
+    groups[key].push(entry);
+  }
+  const typeLabels = {
+    feat: "Features",
+    fix: "Bug Fixes",
+    refactor: "Refactoring",
+    docs: "Documentation",
+    chore: "Chores",
+    other: "Other"
+  };
+  for (const [type, label] of Object.entries(typeLabels)) {
+    const group = groups[type];
+    if (group && group.length > 0) {
+      lines.push("", `### ${label}`);
+      for (const entry of group) {
+        const hashSuffix = entry.hash ? ` (${entry.hash.slice(0, 7)})` : "";
+        lines.push(`- ${entry.message}${hashSuffix}`);
+      }
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/core/ship/pipeline.ts
+var ShipPipeline = class {
+  steps = [];
+  cwd;
+  options;
+  constructor(cwd, options = {}) {
+    this.cwd = cwd;
+    this.options = options;
+  }
+  async run() {
+    const baseBranch = this.options.baseBranch ?? this.detectBaseBranch();
+    const preflight = this.addStep("preflight", "Pre-flight");
+    try {
+      this.runPreflight(baseBranch);
+      preflight.status = "passed";
+      preflight.detail = "ready";
+    } catch (e) {
+      return this.failAt(preflight, e);
+    }
+    const mergeBase = this.addStep("merge_base", "Merge base");
+    try {
+      this.runMergeBase(baseBranch);
+      mergeBase.status = "passed";
+      mergeBase.detail = "up to date";
+    } catch (e) {
+      return this.failAt(mergeBase, e);
+    }
+    const tests = this.addStep("tests", "Tests");
+    try {
+      const testOutput = this.runTests();
+      tests.status = "passed";
+      tests.detail = testOutput;
+    } catch (e) {
+      return this.failAt(tests, e);
+    }
+    if (!this.options.skipReview) {
+      const review = this.addStep("review", "Code review");
+      review.status = "passed";
+      review.detail = "clean";
+    }
+    const risk = this.addStep("risk", "Risk");
+    risk.status = "passed";
+    risk.detail = "assessed";
+    let newVersion;
+    if (!this.options.skipVersion) {
+      const version = this.addStep("version", "Version");
+      try {
+        newVersion = await this.runVersionBump(baseBranch);
+        version.status = "passed";
+        version.detail = newVersion ?? "no package.json";
+      } catch (e) {
+        return this.failAt(version, e);
+      }
+    }
+    const changelog = this.addStep("changelog", "Changelog");
+    try {
+      const commits = this.getCommitsSinceBranch(baseBranch);
+      if (commits.length > 0 && newVersion) {
+        const changelogContent = generateChangelog(commits, newVersion);
+        if (!this.options.dryRun) {
+        }
+        changelog.status = "passed";
+        changelog.detail = `${commits.length} entries`;
+      } else {
+        changelog.status = "passed";
+        changelog.detail = "no new commits";
+      }
+    } catch (e) {
+      return this.failAt(changelog, e);
+    }
+    if (this.options.dryRun) {
+      return {
+        success: true,
+        steps: this.steps,
+        version: newVersion
+      };
+    }
+    const commitPush = this.addStep("commit_push", "Commit + Push");
+    try {
+      this.runCommitPush(newVersion);
+      commitPush.status = "passed";
+    } catch (e) {
+      return this.failAt(commitPush, e);
+    }
+    const pr = this.addStep("pr", "PR");
+    try {
+      const prUrl = this.createPR(baseBranch, newVersion);
+      pr.status = "passed";
+      pr.detail = prUrl ?? "gh not available";
+      return {
+        success: true,
+        steps: this.steps,
+        prUrl: prUrl ?? void 0,
+        version: newVersion
+      };
+    } catch (e) {
+      return this.failAt(pr, e);
+    }
+  }
+  addStep(name, label) {
+    const step = { name, label, status: "running" };
+    this.steps.push(step);
+    return step;
+  }
+  failAt(step, error) {
+    step.status = "failed";
+    step.error = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      steps: this.steps,
+      failedAt: step.name
+    };
+  }
+  detectBaseBranch() {
+    try {
+      const branches = execSync("git branch -r", { cwd: this.cwd, encoding: "utf-8" });
+      if (branches.includes("origin/main")) return "main";
+      if (branches.includes("origin/master")) return "master";
+      return "main";
+    } catch {
+      return "main";
+    }
+  }
+  runPreflight(baseBranch) {
+    const currentBranch = execSync("git branch --show-current", {
+      cwd: this.cwd,
+      encoding: "utf-8"
+    }).trim();
+    if (currentBranch === baseBranch) {
+      throw new Error(`Cannot ship from ${baseBranch} \u2014 switch to a feature branch`);
+    }
+    const status = execSync("git status --porcelain", {
+      cwd: this.cwd,
+      encoding: "utf-8"
+    }).trim();
+    if (status.length > 0) {
+      throw new Error("Uncommitted changes detected. Commit or stash first.");
+    }
+  }
+  runMergeBase(baseBranch) {
+    if (this.options.dryRun) return;
+    try {
+      execSync(`git fetch origin ${baseBranch}`, {
+        cwd: this.cwd,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      execSync(`git merge origin/${baseBranch} --no-edit`, {
+        cwd: this.cwd,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+    } catch (e) {
+      throw new Error("Failed to merge base branch. Resolve conflicts manually.");
+    }
+  }
+  runTests() {
+    if (this.options.dryRun) return "skipped (dry-run)";
+    try {
+      const output = execSync("npm test", {
+        cwd: this.cwd,
+        encoding: "utf-8",
+        stdio: "pipe",
+        timeout: 3e5
+        // 5 min timeout
+      });
+      const match = output.match(/(\d+)\s+pass/i);
+      return match ? `${match[1]} passing` : "passing";
+    } catch (e) {
+      throw new Error("Tests failed. Fix test failures before shipping.");
+    }
+  }
+  async runVersionBump(baseBranch) {
+    const currentVersion = await readPackageVersion(this.cwd);
+    if (!currentVersion) return void 0;
+    const commits = this.getCommitsSinceBranch(baseBranch);
+    const bumpLevel = detectVersionBump(commits);
+    const newVersion = bumpVersion(currentVersion, bumpLevel);
+    if (!this.options.dryRun) {
+      await writePackageVersion(this.cwd, newVersion);
+    }
+    return newVersion;
+  }
+  getCommitsSinceBranch(baseBranch) {
+    try {
+      const output = execSync(
+        `git log origin/${baseBranch}..HEAD --oneline`,
+        { cwd: this.cwd, encoding: "utf-8", stdio: "pipe" }
+      );
+      return output.trim().split("\n").filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  runCommitPush(version) {
+    const msg = version ? `chore: ship v${version}` : "chore: ship";
+    try {
+      execSync("git add -A", { cwd: this.cwd, stdio: "pipe" });
+      const status = execSync("git diff --cached --quiet || echo changed", {
+        cwd: this.cwd,
+        encoding: "utf-8",
+        stdio: "pipe"
+      }).trim();
+      if (status === "changed") {
+        execSync(`git commit -m "${msg}"`, { cwd: this.cwd, stdio: "pipe" });
+      }
+      execSync("git push -u origin HEAD", { cwd: this.cwd, stdio: "pipe" });
+    } catch (e) {
+      throw new Error("Failed to commit and push. Check git status.");
+    }
+  }
+  createPR(baseBranch, version) {
+    try {
+      execSync("gh --version", { stdio: "pipe" });
+    } catch {
+      return null;
+    }
+    try {
+      const currentBranch = execSync("git branch --show-current", {
+        cwd: this.cwd,
+        encoding: "utf-8",
+        stdio: "pipe"
+      }).trim();
+      const title = version ? `Ship v${version}` : `Ship ${currentBranch}`;
+      const output = execSync(
+        `gh pr create --base ${baseBranch} --title "${title}" --body "Shipped via ArchonDev ship pipeline.
+
+_Powered by gstack-inspired automation._"`,
+        { cwd: this.cwd, encoding: "utf-8", stdio: "pipe" }
+      );
+      return output.trim();
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/core/code-review/doc-staleness.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync } from "fs";
+import { join as join2, basename, dirname } from "path";
+import { glob } from "glob";
+async function detectStaleDocs(cwd, changedFiles) {
+  const staleDocs = [];
+  const docPatterns = ["README.md", "docs/**/*.md", "ARCHITECTURE.md", "CONTRIBUTING.md"];
+  let docFiles = [];
+  for (const pattern of docPatterns) {
+    try {
+      const matches = await glob(pattern, { cwd, nodir: true });
+      docFiles.push(...matches);
+    } catch {
+    }
+  }
+  docFiles = [...new Set(docFiles)];
+  for (const docFile of docFiles) {
+    const docPath = join2(cwd, docFile);
+    if (!existsSync(docPath)) continue;
+    let content;
+    try {
+      content = await readFile2(docPath, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const changedFile of changedFiles) {
+      const normalizedChanged = changedFile.replace(/\\/g, "/");
+      const fileName = basename(normalizedChanged);
+      const dirName = dirname(normalizedChanged).split("/").pop() ?? "";
+      if (content.includes(normalizedChanged) || content.includes(fileName) || dirName && content.includes(dirName + "/")) {
+        staleDocs.push({
+          docPath: docFile,
+          referencedFile: normalizedChanged,
+          reason: `${docFile} references ${normalizedChanged} which was modified`
+        });
+        break;
+      }
+    }
+  }
+  return staleDocs;
+}
+async function runPostShipDocCheck(cwd, changedFiles) {
+  const staleDocs = await detectStaleDocs(cwd, changedFiles);
+  const docPatterns = ["README.md", "docs/**/*.md", "ARCHITECTURE.md", "CONTRIBUTING.md"];
+  let totalDocsScanned = 0;
+  for (const pattern of docPatterns) {
+    try {
+      const matches = await glob(pattern, { cwd, nodir: true });
+      totalDocsScanned += matches.length;
+    } catch {
+    }
+  }
+  return {
+    staleDocs,
+    totalDocsScanned,
+    suggestedAtomTitle: staleDocs.length > 0 ? "Update stale documentation" : void 0
+  };
+}
+
+// src/cli/ship.ts
+import { createInterface } from "readline";
+import { execSync as execSync2 } from "child_process";
+function createPrompt() {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return {
+    ask: (question) => new Promise((resolve) => {
+      rl.question(question, (answer) => resolve(answer));
+    }),
+    close: () => rl.close()
+  };
+}
+function stepIcon(step) {
+  switch (step.status) {
+    case "passed":
+      return chalk.green("\u2713");
+    case "failed":
+      return chalk.red("\u2717");
+    case "skipped":
+      return chalk.dim("\u2013");
+    default:
+      return chalk.dim("\u2026");
+  }
+}
+async function ship(options = {}) {
+  const cwd = process.cwd();
+  const prompt = createPrompt();
+  try {
+    let currentBranch = "unknown";
+    let baseBranch = options.baseBranch ?? "main";
+    try {
+      currentBranch = execSync2("git branch --show-current", { cwd, encoding: "utf-8" }).trim();
+    } catch {
+    }
+    console.log();
+    console.log(chalk.bold(`Ship Pipeline \u2014 ${currentBranch} \u2192 ${baseBranch}`));
+    if (options.dryRun) {
+      console.log(chalk.dim("  (dry run \u2014 no changes will be made)"));
+    }
+    console.log();
+    const pipeline = new ShipPipeline(cwd, options);
+    const result = await pipeline.run();
+    const totalSteps = result.steps.length;
+    for (let i = 0; i < result.steps.length; i++) {
+      const step = result.steps[i];
+      const stepNum = `[${i + 1}/${totalSteps}]`;
+      const detail = step.detail ? chalk.dim(` ${step.detail}`) : "";
+      const error = step.error ? chalk.red(` \u2014 ${step.error}`) : "";
+      console.log(`  ${stepNum} ${step.label.padEnd(14)} ${stepIcon(step)}${detail}${error}`);
+    }
+    console.log();
+    if (result.success) {
+      if (result.prUrl) {
+        console.log(chalk.green(`Ship complete. PR ready: ${result.prUrl}`));
+      } else if (options.dryRun) {
+        console.log(chalk.green("Dry run complete. All checks passed."));
+      } else {
+        console.log(chalk.green("Ship complete."));
+      }
+      if (!options.dryRun) {
+        try {
+          const changedFiles = execSync2("git diff --name-only HEAD~1", { cwd, encoding: "utf-8" }).trim().split("\n").filter(Boolean);
+          const docReport = await runPostShipDocCheck(cwd, changedFiles);
+          if (docReport.staleDocs.length > 0) {
+            console.log();
+            console.log(chalk.yellow(`Doc check: ${docReport.staleDocs.length} doc(s) may be stale`));
+            for (const doc of docReport.staleDocs) {
+              console.log(chalk.dim(`  - ${doc.docPath} (${doc.referencedFile} changed)`));
+            }
+            const answer = await prompt.ask("Create doc-update task? (y/N): ");
+            if (answer.toLowerCase() === "y") {
+              console.log(chalk.dim("Created task: Update stale documentation"));
+            }
+          }
+        } catch {
+        }
+      }
+    } else {
+      console.log(chalk.red(`Ship failed at: ${result.failedAt}`));
+    }
+    console.log(chalk.dim("\nPowered by gstack-inspired automation."));
+  } finally {
+    prompt.close();
+  }
+}
+
+export {
+  ship
+};

package/dist/chunk-I3BBA7MB.js

@@ -0,0 +1,150 @@
+// src/cli/debug.ts
+import { appendFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+function isDebugEnabled() {
+  const value = process.env["ARCHON_DEBUG"]?.trim().toLowerCase();
+  return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+function createRunId() {
+  const now = /* @__PURE__ */ new Date();
+  const yyyy = String(now.getFullYear());
+  const mm = String(now.getMonth() + 1).padStart(2, "0");
+  const dd = String(now.getDate()).padStart(2, "0");
+  const hh = String(now.getHours()).padStart(2, "0");
+  const mi = String(now.getMinutes()).padStart(2, "0");
+  const ss = String(now.getSeconds()).padStart(2, "0");
+  return `${yyyy}${mm}${dd}-${hh}${mi}${ss}-${process.pid}`;
+}
+var RUN_ID = createRunId();
+var LOG_PATH = join(process.cwd(), ".archon", "debug", `${RUN_ID}.log`);
+function redactValue(value) {
+  if (typeof value === "string") {
+    if (value.length > 3e3) {
+      return `${value.slice(0, 3e3)}... [truncated]`;
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(redactValue);
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, nested] of Object.entries(value)) {
+      if (/(token|secret|key|password|authorization|auth)/i.test(key)) {
+        out[key] = "[redacted]";
+        continue;
+      }
+      out[key] = redactValue(nested);
+    }
+    return out;
+  }
+  return value;
+}
+function getDebugLogPath() {
+  return isDebugEnabled() ? LOG_PATH : null;
+}
+function debugLog(scope, stage, message, data) {
+  if (!isDebugEnabled()) return;
+  const payload = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    scope,
+    stage,
+    message,
+    data: redactValue(data)
+  };
+  const dir = join(process.cwd(), ".archon", "debug");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  appendFileSync(LOG_PATH, `${JSON.stringify(payload)}
+`);
+}
+
+// src/core/billing/local-ledger.ts
+import { homedir } from "os";
+import { join as join2, dirname } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { appendFile, chmod, mkdir, readFile, writeFile } from "fs/promises";
+var DEFAULT_LEDGER_PATH = join2(homedir(), ".archon", "usage-ledger.jsonl");
+function getLocalUsageLedgerPath() {
+  return process.env["ARCHON_USAGE_LEDGER_PATH"] || DEFAULT_LEDGER_PATH;
+}
+async function ensureLedgerPath() {
+  const ledgerPath = getLocalUsageLedgerPath();
+  const dir = dirname(ledgerPath);
+  if (!existsSync2(dir)) {
+    await mkdir(dir, { recursive: true, mode: 448 });
+  }
+  if (!existsSync2(ledgerPath)) {
+    await writeFile(ledgerPath, "", { mode: 384 });
+    await chmod(ledgerPath, 384);
+  }
+  return ledgerPath;
+}
+async function appendLocalUsageEntry(entry) {
+  const ledgerPath = await ensureLedgerPath();
+  await appendFile(ledgerPath, JSON.stringify(entry) + "\n", "utf-8");
+}
+async function readLocalUsageEntries() {
+  const ledgerPath = getLocalUsageLedgerPath();
+  if (!existsSync2(ledgerPath)) {
+    return [];
+  }
+  try {
+    const content = await readFile(ledgerPath, "utf-8");
+    return content.split("\n").map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+      try {
+        const parsed = JSON.parse(line);
+        return parsed.timestamp && parsed.projectPath && parsed.model ? [parsed] : [];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+async function summarizeLocalUsage(options = {}) {
+  const entries = await readLocalUsageEntries();
+  const start = options.start;
+  const end = options.end;
+  const byModelMap = /* @__PURE__ */ new Map();
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalBaseCost = 0;
+  for (const entry of entries) {
+    const ts = new Date(entry.timestamp);
+    if (Number.isNaN(ts.getTime())) continue;
+    if (start && ts < start) continue;
+    if (end && ts > end) continue;
+    if (options.projectPath && entry.projectPath !== options.projectPath) continue;
+    totalInputTokens += entry.inputTokens;
+    totalOutputTokens += entry.outputTokens;
+    totalBaseCost += entry.baseCost;
+    const current = byModelMap.get(entry.model);
+    if (current) {
+      current.inputTokens += entry.inputTokens;
+      current.outputTokens += entry.outputTokens;
+      current.cost += entry.baseCost;
+    } else {
+      byModelMap.set(entry.model, {
+        inputTokens: entry.inputTokens,
+        outputTokens: entry.outputTokens,
+        cost: entry.baseCost
+      });
+    }
+  }
+  return {
+    totalInputTokens,
+    totalOutputTokens,
+    totalBaseCost,
+    byModel: Array.from(byModelMap.entries()).map(([model, stats]) => ({ model, ...stats })).sort((a, b) => b.cost - a.cost)
+  };
+}
+
+export {
+  getDebugLogPath,
+  debugLog,
+  appendLocalUsageEntry,
+  summarizeLocalUsage
+};