@beastmode-develeap/beastmode 0.1.264 → 0.1.265

package/dist/index.js

@@ -4560,6 +4560,7 @@ var init_chat_handler = __esm({
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync12, existsSync as existsSync15, readdirSync as readdirSync6, unlinkSync as unlinkSync3, mkdirSync as mkdirSync11, statSync as statSync5, rmSync as rmSync3 } from "fs";
 import { join as join13, basename as basename3, resolve as resolve4, dirname as dirname5 } from "path";
 import { homedir } from "os";
+import { randomUUID as randomUUID2 } from "crypto";
 import { execSync as execSync3, spawnSync } from "child_process";
 import http2 from "http";
 function assertSafeName(name) {
@@ -4806,6 +4807,30 @@ function scanStrandedRuns(runsDir, newThreshold) {
   }
   return stranded;
 }
+function _readAnalyzeMeta(projectsDir, name) {
+  const metaPath = join13(projectsDir, name, "codebase-guide.meta.json");
+  if (!existsSync15(metaPath)) return null;
+  try {
+    return JSON.parse(readFileSync12(metaPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function _gitHeadSha(repoPath) {
+  try {
+    return execSync3("git rev-parse HEAD", { cwd: repoPath, encoding: "utf-8" }).trim();
+  } catch {
+    return "no-git";
+  }
+}
+function _hasClaudeCli() {
+  try {
+    execSync3("which claude", { encoding: "utf-8" });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function getBoardRoutes(factoryDir) {
   return [
     // ── Status ──
@@ -5607,36 +5632,270 @@ function getBoardRoutes(factoryDir) {
     {
       method: "POST",
       pattern: "/api/projects/:name/analyze",
-      handler: async (_body, params) => {
+      handler: async (body, params, query) => {
         const { name } = params;
+        assertSafeName(name);
         const projectsDir = join13(factoryDir, ".beastmode", "projects");
         const subDirConfigPath = join13(projectsDir, name, "project.json");
         const flatConfigPath = join13(projectsDir, `${name}.json`);
         const projPath = existsSync15(subDirConfigPath) ? subDirConfigPath : existsSync15(flatConfigPath) ? flatConfigPath : null;
         if (!projPath) throw new Error(`Project not found: ${name}`);
         const projConfig = JSON.parse(readFileSync12(projPath, "utf-8"));
+        const projectPath = projConfig.path;
         const subDir = join13(projectsDir, name);
         if (!existsSync15(subDir)) mkdirSync11(subDir, { recursive: true });
-        const brownfieldPath = join13(subDir, "brownfield.md");
-        if (!existsSync15(brownfieldPath)) {
-          const { detectStack: detectStackFn } = await Promise.resolve().then(() => (init_engine(), engine_exports));
-          let stackInfo = "Unknown stack";
-          try {
-            const stack = detectStackFn(projConfig.path);
-            const cmds = stack.suggested_commands;
-            stackInfo = `Framework: ${stack.framework || "unknown"}
+        const force = query?.force === "true" || query?.force === "1";
+        const tier = body?.tier;
+        if (tier === "quick") {
+          const brownfieldPath = join13(subDir, "brownfield.md");
+          if (!existsSync15(brownfieldPath)) {
+            const { detectStack: detectStackFn } = await Promise.resolve().then(() => (init_engine(), engine_exports));
+            let stackInfo = "Unknown stack";
+            try {
+              const stack = detectStackFn(projectPath);
+              const cmds = stack.suggested_commands;
+              stackInfo = `Framework: ${stack.framework || "unknown"}
 Build: ${cmds?.build || "unknown"}
 Dev: ${cmds?.dev || "unknown"}`;
-          } catch {
+            } catch {
+            }
+            writeFileSync12(brownfieldPath, `# Brownfield Analysis: ${name}
+
+${stackInfo}
+
+Path: ${projectPath}
+`);
           }
-          writeFileSync12(brownfieldPath, `# Brownfield Analysis: ${name}
+          return { analyzed: true, project: name, tier: "quick" };
+        }
+        if (!force) {
+          const meta = _readAnalyzeMeta(projectsDir, name);
+          const currentSha = _gitHeadSha(projectPath);
+          if (meta && meta.status === "complete" && meta.target_repo_head_sha === currentSha) {
+            return { analyzed: true, project: name, cached: true, analyzed_at: meta.analyzed_at };
+          }
+        }
+        const existingJob = _analyzeJobs.get(name);
+        if (existingJob && existingJob.status === "running") {
+          return { analyzing: true, project: name, job_id: existingJob.job_id, status: "running" };
+        }
+        const writeMeta = (m) => {
+          try {
+            writeFileSync12(
+              join13(subDir, "codebase-guide.meta.json"),
+              JSON.stringify(m, null, 2) + "\n",
+              "utf-8"
+            );
+          } catch (err) {
+            console.error(`[analyze] Failed to write meta for ${name}:`, err);
+          }
+        };
+        if (!_hasClaudeCli()) {
+          const brownfieldPath = join13(subDir, "brownfield.md");
+          if (!existsSync15(brownfieldPath)) {
+            const { detectStack: detectStackFn } = await Promise.resolve().then(() => (init_engine(), engine_exports));
+            let stackInfo = "Unknown stack";
+            try {
+              const stack = detectStackFn(projectPath);
+              const cmds = stack.suggested_commands;
+              stackInfo = `Framework: ${stack.framework || "unknown"}
+Build: ${cmds?.build || "unknown"}
+Dev: ${cmds?.dev || "unknown"}`;
+            } catch {
+            }
+            writeFileSync12(brownfieldPath, `# Brownfield Analysis: ${name}
 
 ${stackInfo}
 
-Path: ${projConfig.path}
+Path: ${projectPath}
 `);
+          }
+          writeMeta({
+            analyzed_at: (/* @__PURE__ */ new Date()).toISOString(),
+            target_repo_head_sha: _gitHeadSha(projectPath),
+            status: "failed",
+            error: "Claude CLI not available",
+            duration_seconds: 0
+          });
+          console.warn(`[analyze] Claude CLI unavailable for project ${name}; wrote detectStack() fallback.`);
+          return { analyzed: true, project: name, fallback: true };
+        }
+        const jobId = randomUUID2();
+        const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const startMs = Date.now();
+        const job = {
+          job_id: jobId,
+          project: name,
+          status: "running",
+          started_at: startedAt
+        };
+        _analyzeJobs.set(name, job);
+        (async () => {
+          try {
+            const { spawn: spawn4 } = await import("child_process");
+            const prompt = [
+              "You are the Brownfield Analyst. Analyze the codebase at the current working directory.",
+              `Write your output in pyramid format (L0/L1/L2) to the directory: ${subDir}`,
+              "Produce exactly these four files:",
+              `  - ${join13(subDir, "codebase-guide.md")} (full L2 analysis: architecture, conventions, safe modification points, fragile areas)`,
+              `  - ${join13(subDir, "codebase-guide.l1.md")} (paragraph summary only)`,
+              `  - ${join13(subDir, "codebase-guide.l0.txt")} (one-sentence summary only)`,
+              "Do not write anything else outside the BEASTMODE_OUTPUT_DIR."
+            ].join("\n");
+            const isRoot = process.getuid?.() === 0;
+            const claudeArgs = [
+              "-p",
+              prompt,
+              "--agent",
+              "brownfield-analyst",
+              "--output-format",
+              "stream-json",
+              "--verbose",
+              "--dangerously-skip-permissions"
+            ];
+            const spawnCmd = isRoot ? "runuser" : "claude";
+            const spawnArgs = isRoot ? ["-u", "node", "--", "claude", ...claudeArgs] : claudeArgs;
+            const child = spawn4(spawnCmd, spawnArgs, {
+              cwd: projectPath,
+              env: {
+                ...process.env,
+                BEASTMODE_PROJECT: name,
+                BEASTMODE_OUTPUT_DIR: subDir,
+                ...isRoot ? { HOME: "/home/node" } : {}
+              },
+              stdio: ["ignore", "pipe", "pipe"]
+            });
+            child.stdout?.on("data", () => {
+            });
+            child.stderr?.on("data", () => {
+            });
+            child.on("close", (code) => {
+              const durationSeconds = (Date.now() - startMs) / 1e3;
+              const sha = _gitHeadSha(projectPath);
+              const guidePath = join13(subDir, "codebase-guide.md");
+              const ok = code === 0 && existsSync15(guidePath);
+              if (ok) {
+                writeMeta({
+                  analyzed_at: (/* @__PURE__ */ new Date()).toISOString(),
+                  analyst_version: "brownfield-analyst-v1",
+                  target_repo_head_sha: sha,
+                  project_name: name,
+                  duration_seconds: durationSeconds,
+                  status: "complete"
+                });
+                const legacy = join13(subDir, "brownfield.md");
+                if (existsSync15(legacy)) {
+                  try {
+                    unlinkSync3(legacy);
+                  } catch {
+                  }
+                }
+                _analyzeJobs.set(name, {
+                  ...job,
+                  status: "complete",
+                  completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+                  duration_seconds: durationSeconds
+                });
+              } else {
+                const errMsg = `claude exited with code ${code}`;
+                writeMeta({
+                  analyzed_at: (/* @__PURE__ */ new Date()).toISOString(),
+                  target_repo_head_sha: sha,
+                  status: "failed",
+                  error: errMsg,
+                  duration_seconds: durationSeconds
+                });
+                _analyzeJobs.set(name, {
+                  ...job,
+                  status: "failed",
+                  completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+                  duration_seconds: durationSeconds,
+                  error: errMsg
+                });
+              }
+            });
+            child.on("error", (err) => {
+              const durationSeconds = (Date.now() - startMs) / 1e3;
+              const sha = _gitHeadSha(projectPath);
+              writeMeta({
+                analyzed_at: (/* @__PURE__ */ new Date()).toISOString(),
+                target_repo_head_sha: sha,
+                status: "failed",
+                error: String(err),
+                duration_seconds: durationSeconds
+              });
+              _analyzeJobs.set(name, {
+                ...job,
+                status: "failed",
+                completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+                duration_seconds: durationSeconds,
+                error: String(err)
+              });
+            });
+          } catch (err) {
+            const durationSeconds = (Date.now() - startMs) / 1e3;
+            const sha = _gitHeadSha(projectPath);
+            writeMeta({
+              analyzed_at: (/* @__PURE__ */ new Date()).toISOString(),
+              target_repo_head_sha: sha,
+              status: "failed",
+              error: String(err),
+              duration_seconds: durationSeconds
+            });
+            _analyzeJobs.set(name, {
+              ...job,
+              status: "failed",
+              completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+              duration_seconds: durationSeconds,
+              error: String(err)
+            });
+          }
+        })();
+        return { analyzing: true, project: name, job_id: jobId, status: "running" };
+      }
+    },
+    {
+      method: "GET",
+      pattern: "/api/projects/:name/analyze/status",
+      handler: (_body, params) => {
+        const { name } = params;
+        assertSafeName(name);
+        const projectsDir = join13(factoryDir, ".beastmode", "projects");
+        const job = _analyzeJobs.get(name);
+        const meta = _readAnalyzeMeta(projectsDir, name);
+        if (job && job.status === "running") {
+          return {
+            status: "running",
+            job_id: job.job_id,
+            started_at: job.started_at
+          };
         }
-        return { analyzed: true, project: name };
+        if (job && job.status === "failed") {
+          return {
+            status: "failed",
+            job_id: job.job_id,
+            error: job.error,
+            started_at: job.started_at,
+            completed_at: job.completed_at,
+            duration_seconds: job.duration_seconds
+          };
+        }
+        if (meta && meta.status === "complete") {
+          return {
+            status: job?.status === "cached" ? "cached" : "complete",
+            analyzed_at: meta.analyzed_at,
+            duration_seconds: meta.duration_seconds,
+            target_repo_head_sha: meta.target_repo_head_sha
+          };
+        }
+        if (meta && meta.status === "failed") {
+          return {
+            status: "failed",
+            analyzed_at: meta.analyzed_at,
+            error: meta.error
+          };
+        }
+        return { status: "idle" };
       }
     },
     // ── Runs ──
@@ -6348,7 +6607,7 @@ function matchBoardRoute(routes, method, url) {
   }
   return null;
 }
-var BinaryResponse, HttpError, _TERMINAL_STAGES;
+var BinaryResponse, HttpError, _TERMINAL_STAGES, _analyzeJobs;
 var init_board_api_routes = __esm({
   "src/cli/ui/board-api-routes.ts"() {
     "use strict";
@@ -6378,6 +6637,7 @@ var init_board_api_routes = __esm({
       "stuck_infra_gap",
       "ready_for_review"
     ]);
+    _analyzeJobs = /* @__PURE__ */ new Map();
   }
 });
 
@@ -7733,7 +7993,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z as z2 } from "zod";
 import { readFileSync as readFileSync28, writeFileSync as writeFileSync24, existsSync as existsSync31, readdirSync as readdirSync11, mkdirSync as mkdirSync19 } from "fs";
 import { join as join29, resolve as resolve18, basename as basename5 } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 function readJsonFile2(filePath) {
   if (!existsSync31(filePath)) return null;
   try {
@@ -7901,7 +8161,7 @@ function createMcpServer() {
       const factoryDir = getFactoryPath();
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const item = {
-        id: randomUUID3(),
+        id: randomUUID4(),
         title,
         description: "",
         status: status || "ready",
@@ -8099,7 +8359,7 @@ function createMcpServer() {
       const factoryDir = getFactoryPath();
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const item = {
-        id: randomUUID3(),
+        id: randomUUID4(),
         title,
         description: description || "",
         status: status || "new",
@@ -11533,7 +11793,7 @@ init_schemas();
 import { Command as Command15 } from "commander";
 import { join as join27 } from "path";
 import { existsSync as existsSync29, readFileSync as readFileSync26, writeFileSync as writeFileSync22, mkdirSync as mkdirSync17 } from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var runCommand = new Command15("run").description("Run a single pipeline task").argument("[project]", "Project name (defaults to first project)").option("--task <description>", "Task description").action(async (project, opts) => {
   try {
     await runPipeline(project, opts);
@@ -11596,7 +11856,7 @@ async function runPipeline(projectName, opts) {
     }
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const taskId = randomUUID2();
+  const taskId = randomUUID3();
   const task = {
     id: taskId,
     title: opts.task,