archondev 1.5.0 → 1.6.1

package/README.md

@@ -39,6 +39,7 @@ Copy governance files into any project. Works with your existing AI tools (Curso
 - **Code Review Mode** — Structured code review without changing your code
 - **Local Database** — Track atoms and learnings in SQLite (no CLI required)
 - **Memory Management** — Context handoff protocol for long sessions
+- **Task Extraction Protocol** — AI confirms all items before starting, nothing gets forgotten
 - Works with any AI coding assistant
 
 ---
@@ -50,6 +51,7 @@ Copy governance files into any project. Works with your existing AI tools (Curso
 | `archon` | Interactive mode — just run and follow prompts |
 | `archon init` | Initialize in your project |
 | `archon plan <description>` | Create a work item with AI planning |
+| `archon plan` | Create a work item with AI planning (extracts and confirms multi-item requests) |
 | `archon execute <atom-id>` | Execute with quality gates |
 | `archon list` | List all work items |
 | `archon show <atom-id>` | Show details |

package/dist/{chunk-PK3OQVBG.js → chunk-NCJN4X5A.js}

@@ -1,6 +1,6 @@
 import {
   listLocalAtoms
-} from "./chunk-EDP55FCI.js";
+} from "./chunk-3AAQEUY6.js";
 
 // src/cli/list.ts
 import chalk from "chalk";

package/dist/{chunk-74EEFKVP.js → chunk-S7UXMYWS.js}

@@ -1,6 +1,6 @@
 import {
   loadAtom
-} from "./chunk-EDP55FCI.js";
+} from "./chunk-3AAQEUY6.js";
 import {
   ArchitectureParser
 } from "./chunk-2CFO5GVH.js";

package/dist/chunk-TJXGZB6T.js

@@ -0,0 +1,342 @@
+// src/cli/init.ts
+import { readdir, readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join, extname } from "path";
+import { execSync } from "child_process";
+import chalk from "chalk";
+import ora from "ora";
+import readline from "readline";
+function isInitialized(cwd) {
+  const archMdPath = join(cwd, "ARCHITECTURE.md");
+  const archonDir = join(cwd, ".archon");
+  return existsSync(archMdPath) || existsSync(archonDir);
+}
+var LANGUAGE_EXTENSIONS = {
+  ".ts": "TypeScript",
+  ".tsx": "TypeScript",
+  ".js": "JavaScript",
+  ".jsx": "JavaScript",
+  ".py": "Python",
+  ".go": "Go",
+  ".rs": "Rust",
+  ".java": "Java",
+  ".rb": "Ruby",
+  ".php": "PHP",
+  ".cs": "C#",
+  ".cpp": "C++",
+  ".c": "C",
+  ".swift": "Swift",
+  ".kt": "Kotlin",
+  ".vue": "Vue",
+  ".svelte": "Svelte"
+};
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "target",
+  "vendor",
+  ".archon"
+]);
+async function init(options = {}) {
+  const cwd = process.cwd();
+  const archMdPath = join(cwd, "ARCHITECTURE.md");
+  const archonDir = join(cwd, ".archon");
+  console.log(chalk.blue("\n\u{1F3DB}\uFE0F  ArchonDev Initialization\n"));
+  if (existsSync(archMdPath)) {
+    const overwrite = await promptYesNo("ARCHITECTURE.md already exists. Overwrite?", false);
+    if (!overwrite) {
+      console.log(chalk.yellow("Initialization cancelled."));
+      return;
+    }
+  }
+  const spinner = ora("Detecting project capabilities...").start();
+  const capabilities = await detectCapabilities(cwd);
+  spinner.succeed("Project capabilities detected");
+  spinner.start("Scanning codebase...");
+  const stats = await scanRepository(cwd);
+  spinner.succeed(`Scanned ${stats.totalFiles} files (${formatLines(stats.totalLines)} lines)`);
+  if (options.git !== false && !capabilities.hasGit) {
+    spinner.start("Initializing git repository...");
+    try {
+      execSync("git init", { cwd, stdio: "pipe" });
+      spinner.succeed("Git repository initialized");
+    } catch {
+      spinner.warn("Could not initialize git");
+    }
+  }
+  if (!existsSync(archonDir)) {
+    await mkdir(archonDir, { recursive: true });
+  }
+  spinner.start("Generating ARCHITECTURE.md...");
+  const archContent = generateArchitectureMd(capabilities, stats, options.analyze);
+  await writeFile(archMdPath, archContent);
+  spinner.succeed("ARCHITECTURE.md created");
+  printSummary(capabilities, stats, options.analyze);
+}
+function promptYesNo(question, defaultValue) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const hint = defaultValue ? "(Y/n)" : "(y/N)";
+    rl.question(`${question} ${hint} `, (answer) => {
+      rl.close();
+      if (answer.trim() === "") {
+        resolve(defaultValue);
+      } else {
+        resolve(answer.toLowerCase().startsWith("y"));
+      }
+    });
+  });
+}
+async function detectCapabilities(cwd) {
+  const hasFile = (name) => existsSync(join(cwd, name));
+  const hasJsonDep = async (name) => {
+    try {
+      const pkg = JSON.parse(await readFile(join(cwd, "package.json"), "utf-8"));
+      return !!(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
+    } catch {
+      return false;
+    }
+  };
+  let packageManager = null;
+  if (hasFile("pnpm-lock.yaml")) packageManager = "pnpm";
+  else if (hasFile("yarn.lock")) packageManager = "yarn";
+  else if (hasFile("bun.lockb")) packageManager = "bun";
+  else if (hasFile("package-lock.json")) packageManager = "npm";
+  const hasTypeScript = hasFile("tsconfig.json") || await hasJsonDep("typescript");
+  const hasESLint = hasFile(".eslintrc") || hasFile(".eslintrc.js") || hasFile("eslint.config.js") || await hasJsonDep("eslint");
+  const hasJest = hasFile("jest.config.js") || hasFile("jest.config.ts") || await hasJsonDep("jest") || await hasJsonDep("vitest");
+  const hasPrettier = hasFile(".prettierrc") || hasFile(".prettierrc.js") || await hasJsonDep("prettier");
+  const hasGit = hasFile(".git");
+  return {
+    hasTypeScript,
+    hasESLint,
+    hasJest,
+    hasPrettier,
+    hasGit,
+    packageManager,
+    primaryLanguage: hasTypeScript ? "TypeScript" : "JavaScript"
+  };
+}
+async function scanRepository(cwd) {
+  const stats = {
+    totalFiles: 0,
+    totalLines: 0,
+    languageBreakdown: {},
+    directories: []
+  };
+  async function scanDir(dir, depth = 0) {
+    if (depth > 10) return;
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (IGNORE_DIRS.has(entry.name)) continue;
+        if (entry.name.startsWith(".") && entry.name !== ".github") continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (depth < 2) {
+            const relativePath = fullPath.replace(cwd, "").replace(/^\//, "");
+            if (relativePath) {
+              stats.directories.push(relativePath);
+            }
+          }
+          await scanDir(fullPath, depth + 1);
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name).toLowerCase();
+          const language = LANGUAGE_EXTENSIONS[ext];
+          if (language) {
+            stats.totalFiles++;
+            try {
+              const content = await readFile(fullPath, "utf-8");
+              const lines = content.split("\n").length;
+              stats.totalLines += lines;
+              if (!stats.languageBreakdown[language]) {
+                stats.languageBreakdown[language] = { files: 0, lines: 0 };
+              }
+              stats.languageBreakdown[language].files++;
+              stats.languageBreakdown[language].lines += lines;
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  await scanDir(cwd);
+  return stats;
+}
+function generateArchitectureMd(capabilities, stats, analyze) {
+  const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const suggestedComponents = stats.directories.filter((d) => !d.includes("/")).slice(0, 10).map((dir) => ({
+    id: dir.replace(/[^a-zA-Z0-9]/g, "-"),
+    name: dir.charAt(0).toUpperCase() + dir.slice(1),
+    path: `${dir}/**`
+  }));
+  const qualityGates = [];
+  if (capabilities.hasTypeScript) qualityGates.push("SYNTAX");
+  if (capabilities.hasESLint) qualityGates.push("LINT");
+  if (capabilities.hasJest) qualityGates.push("UNIT");
+  return `---
+version: "1.0"
+updatedAt: "${now}"
+profile: "balanced"
+strictMode: true
+
+# System Goals
+systemGoals:
+  - id: "GOAL-001"
+    title: "Maintain code quality"
+    description: "All changes must pass quality gates before merging"
+    priority: "HIGH"
+
+  - id: "GOAL-002"
+    title: "Preserve architectural boundaries"
+    description: "Components should not violate defined boundaries"
+    priority: "HIGH"
+
+# Components & Boundaries
+# Detected ${suggestedComponents.length} top-level directories
+components:
+${suggestedComponents.map((c) => `  - id: "${c.id}"
+    name: "${c.name}"
+    paths:
+      - "${c.path}"
+    boundary: "INTERNAL"
+    stability: "EVOLVING"`).join("\n\n")}
+
+# Invariants (Rules to enforce)
+invariants:
+  - id: "INV-001"
+    severity: "WARN"
+    rule: "Avoid console.log in production code"
+    match: "console\\\\.log"
+    scope: "src"
+    reason: "Use proper logging library instead"
+
+# Protected Paths
+protectedPaths:
+  - pattern: "package.json"
+    level: "SOFT"
+    reason: "Dependency changes should be reviewed"
+
+${capabilities.hasTypeScript ? `  - pattern: "tsconfig.json"
+    level: "SOFT"
+    reason: "TypeScript config affects entire project"` : ""}
+
+# Environment Configuration
+environments:
+  development:
+    autoApprove: true
+    qualityGates:
+      - ARCHITECTURE
+${qualityGates.map((g) => `      - ${g}`).join("\n")}
+
+  production:
+    autoApprove: false
+    requiresManualPromotion: true
+    qualityGates:
+      - ARCHITECTURE
+${qualityGates.map((g) => `      - ${g}`).join("\n")}
+      - ACCEPTANCE
+---
+
+# Project Architecture
+
+## Overview
+
+This architecture document was auto-generated by ArchonDev on ${now}.
+
+${analyze ? `## Codebase Analysis
+
+- **Total Files:** ${stats.totalFiles}
+- **Total Lines:** ${formatLines(stats.totalLines)}
+- **Primary Language:** ${capabilities.primaryLanguage}
+
+### Language Breakdown
+
+${Object.entries(stats.languageBreakdown).sort((a, b) => b[1].lines - a[1].lines).map(([lang, data]) => `- ${lang}: ${data.files} files, ${formatLines(data.lines)} lines`).join("\n")}
+
+### Detected Capabilities
+
+- TypeScript: ${capabilities.hasTypeScript ? "\u2705" : "\u274C"}
+- ESLint: ${capabilities.hasESLint ? "\u2705" : "\u274C"}
+- Testing: ${capabilities.hasJest ? "\u2705" : "\u274C"}
+- Package Manager: ${capabilities.packageManager ?? "Not detected"}
+` : ""}
+## Components
+
+${suggestedComponents.map((c) => `### ${c.name}
+
+Path: \`${c.path}\`
+
+TODO: Add description for this component.
+`).join("\n")}
+
+## Getting Started
+
+1. Review and customize the components above
+2. Add invariants for your specific rules
+3. Define protected paths for sensitive files
+4. Run \`archon plan <description>\` to create your first atom
+
+## Architecture Decision Records
+
+Document important architectural decisions here.
+`;
+}
+function formatLines(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toString();
+}
+function printSummary(capabilities, stats, analyze) {
+  console.log();
+  console.log(chalk.green("\u2713 ArchonDev initialized successfully!"));
+  console.log();
+  console.log(chalk.bold("Detected Capabilities:"));
+  console.log(`  ${capabilities.hasTypeScript ? chalk.green("\u2713") : chalk.gray("\u25CB")} TypeScript`);
+  console.log(`  ${capabilities.hasESLint ? chalk.green("\u2713") : chalk.gray("\u25CB")} ESLint`);
+  console.log(`  ${capabilities.hasJest ? chalk.green("\u2713") : chalk.gray("\u25CB")} Testing (Jest/Vitest)`);
+  console.log(`  ${capabilities.packageManager ? chalk.green("\u2713") : chalk.gray("\u25CB")} Package Manager: ${capabilities.packageManager ?? "none"}`);
+  console.log();
+  console.log(chalk.bold("Codebase Summary:"));
+  console.log(`  Files: ${stats.totalFiles}`);
+  console.log(`  Lines: ${formatLines(stats.totalLines)}`);
+  console.log(`  Directories: ${stats.directories.length}`);
+  console.log();
+  if (Object.keys(stats.languageBreakdown).length > 0) {
+    console.log(chalk.bold("Languages:"));
+    Object.entries(stats.languageBreakdown).sort((a, b) => b[1].lines - a[1].lines).slice(0, 5).forEach(([lang, data]) => {
+      const pct = Math.round(data.lines / stats.totalLines * 100);
+      console.log(`  ${lang}: ${pct}%`);
+    });
+    console.log();
+  }
+  if (analyze && stats.directories.length > 0) {
+    console.log(chalk.bold("Suggested Boundaries:"));
+    stats.directories.filter((d) => !d.includes("/")).slice(0, 5).forEach((dir) => {
+      console.log(`  \u2022 ${dir}/`);
+    });
+    console.log();
+  }
+  console.log(chalk.bold("Next Steps:"));
+  console.log(`  1. ${chalk.cyan("Review")} ARCHITECTURE.md and customize components`);
+  console.log(`  2. ${chalk.cyan("Run")} ${chalk.dim('archon plan "your first task"')} to create an atom`);
+  console.log(`  3. ${chalk.cyan("Execute")} ${chalk.dim("archon execute ATOM-001")} to implement it`);
+  console.log();
+}
+
+export {
+  isInitialized,
+  init
+};

package/dist/{execute-N6CCEJ5I.js → execute-6ZGARWT2.js}

@@ -1,11 +1,11 @@
 import {
   execute
-} from "./chunk-74EEFKVP.js";
-import "./chunk-EDP55FCI.js";
+} from "./chunk-S7UXMYWS.js";
+import "./chunk-3AAQEUY6.js";
+import "./chunk-SMR7JQK6.js";
 import "./chunk-2CFO5GVH.js";
 import "./chunk-MOZHC2GX.js";
 import "./chunk-A7QU6JC6.js";
-import "./chunk-SMR7JQK6.js";
 import "./chunk-WCCBJSNI.js";
 import "./chunk-QGM4M3NI.js";
 export {