@aman_asmuei/aman-agent 0.32.0 → 0.33.0

package/dist/index.js

@@ -8,6 +8,65 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/token-budget.ts
+function estimateTokens(text3) {
+  return Math.round(text3.split(/\s+/).filter(Boolean).length * 1.3);
+}
+function buildBudgetedPrompt(components, maxTokens = 8e3) {
+  const included = [];
+  const truncated = [];
+  const parts = [];
+  let totalTokens = 0;
+  const sorted = [...components].sort((a, b) => {
+    const aPri = PRIORITIES.indexOf(a.name);
+    const bPri = PRIORITIES.indexOf(b.name);
+    return (aPri === -1 ? 99 : aPri) - (bPri === -1 ? 99 : bPri);
+  });
+  for (const comp of sorted) {
+    if (totalTokens + comp.tokens <= maxTokens) {
+      parts.push(comp.content);
+      included.push(comp.name);
+      totalTokens += comp.tokens;
+    } else {
+      const halfContent = comp.content.slice(0, Math.floor(comp.content.length / 2));
+      const halfTokens = estimateTokens(halfContent);
+      if (totalTokens + halfTokens <= maxTokens) {
+        parts.push(halfContent + "\n\n[... truncated for context budget ...]");
+        included.push(comp.name + " (partial)");
+        totalTokens += halfTokens;
+      } else {
+        truncated.push(comp.name);
+      }
+    }
+  }
+  return {
+    prompt: parts.join("\n\n---\n\n"),
+    included,
+    truncated,
+    totalTokens
+  };
+}
+var PRIORITIES;
+var init_token_budget = __esm({
+  "src/token-budget.ts"() {
+    "use strict";
+    PRIORITIES = [
+      "identity",
+      // core.md — always include
+      "user",
+      // user.md — user profile, always include
+      "guardrails",
+      // rules.md — safety critical
+      "workflows",
+      // flow.md — behavioral
+      "tools",
+      // kit.md — capabilities
+      "skills"
+      // skills.md — can be truncated
+    ];
+  }
+});
+
 // src/logger.ts
 import fs5 from "fs";
 import path5 from "path";
@@ -600,6 +659,473 @@ var init_delegate_remote = __esm({
   }
 });
 
+// src/dev/stack-detector.ts
+var stack_detector_exports = {};
+__export(stack_detector_exports, {
+  scanStack: () => scanStack
+});
+import fs24 from "fs";
+import path24 from "path";
+function scanStack(projectPath) {
+  const languages = [];
+  const frameworks = [];
+  const databases = [];
+  const infra = [];
+  let isMonorepo = false;
+  let projectName = path24.basename(projectPath);
+  const goModPath = path24.join(projectPath, "go.mod");
+  if (fs24.existsSync(goModPath)) {
+    languages.push("go");
+    const content = fs24.readFileSync(goModPath, "utf-8");
+    const moduleMatch = content.match(/^module\s+(.+)$/m);
+    if (moduleMatch) {
+      const parts = moduleMatch[1].trim().split("/");
+      projectName = parts[parts.length - 1];
+    }
+    if (content.includes("gofiber/fiber")) frameworks.push("fiber");
+    if (content.includes("gin-gonic/gin")) frameworks.push("gin");
+    if (content.includes("go-chi/chi")) frameworks.push("chi");
+    if (content.includes("labstack/echo")) frameworks.push("echo");
+  }
+  const pkgPath = path24.join(projectPath, "package.json");
+  const hasTsConfig = fs24.existsSync(path24.join(projectPath, "tsconfig.json"));
+  if (fs24.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs24.readFileSync(pkgPath, "utf-8"));
+      if (pkg.name) projectName = pkg.name;
+      if (hasTsConfig) {
+        languages.push("typescript");
+      } else {
+        languages.push("javascript");
+      }
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      for (const [dep, fwName] of Object.entries(FRAMEWORK_MAP)) {
+        if (allDeps?.[dep]) frameworks.push(fwName);
+      }
+      if (pkg.workspaces) isMonorepo = true;
+    } catch {
+      if (hasTsConfig) languages.push("typescript");
+    }
+  } else if (hasTsConfig) {
+    languages.push("typescript");
+  }
+  const cargoPath = path24.join(projectPath, "Cargo.toml");
+  if (fs24.existsSync(cargoPath)) {
+    languages.push("rust");
+    const content = fs24.readFileSync(cargoPath, "utf-8");
+    if (content.includes("[workspace]")) isMonorepo = true;
+    const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
+    if (nameMatch && !isMonorepo) projectName = nameMatch[1];
+  }
+  const pyprojectPath = path24.join(projectPath, "pyproject.toml");
+  if (fs24.existsSync(pyprojectPath)) {
+    languages.push("python");
+    const content = fs24.readFileSync(pyprojectPath, "utf-8");
+    if (content.includes("django")) frameworks.push("django");
+    if (content.includes("fastapi")) frameworks.push("fastapi");
+    if (content.includes("flask")) frameworks.push("flask");
+  }
+  if (fs24.existsSync(path24.join(projectPath, "pubspec.yaml"))) {
+    languages.push("dart");
+    frameworks.push("flutter");
+  }
+  if (fs24.existsSync(path24.join(projectPath, "Dockerfile"))) {
+    infra.push("docker");
+  }
+  const composeNames = ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"];
+  for (const name of composeNames) {
+    const composePath = path24.join(projectPath, name);
+    if (fs24.existsSync(composePath)) {
+      if (!infra.includes("docker")) infra.push("docker");
+      const content = fs24.readFileSync(composePath, "utf-8");
+      for (const [pattern, dbName] of Object.entries(DB_IMAGE_MAP)) {
+        if (content.includes(pattern) && !databases.includes(dbName)) {
+          databases.push(dbName);
+        }
+      }
+      break;
+    }
+  }
+  if (fs24.existsSync(path24.join(projectPath, ".github", "workflows"))) {
+    infra.push("github-actions");
+  }
+  for (const dir of ["k3s", "k8s", "deploy"]) {
+    if (fs24.existsSync(path24.join(projectPath, dir))) {
+      infra.push("kubernetes");
+      break;
+    }
+  }
+  if (fs24.existsSync(path24.join(projectPath, "Makefile"))) {
+    infra.push("make");
+  }
+  return {
+    projectName,
+    languages,
+    frameworks,
+    databases,
+    infra,
+    isMonorepo,
+    detectedAt: Date.now()
+  };
+}
+var FRAMEWORK_MAP, DB_IMAGE_MAP;
+var init_stack_detector = __esm({
+  "src/dev/stack-detector.ts"() {
+    "use strict";
+    FRAMEWORK_MAP = {
+      next: "next",
+      react: "react",
+      remix: "remix",
+      express: "express",
+      fastify: "fastify",
+      hono: "hono",
+      "@nestjs/core": "nestjs",
+      vue: "vue",
+      svelte: "svelte",
+      nuxt: "nuxt"
+    };
+    DB_IMAGE_MAP = {
+      postgres: "postgresql",
+      mysql: "mysql",
+      mariadb: "mariadb",
+      mongo: "mongodb",
+      redis: "redis",
+      timescaledb: "timescaledb"
+    };
+  }
+});
+
+// src/dev/context-builder.ts
+import path25 from "path";
+import os22 from "os";
+import { createDatabase as createDatabase2, recall as recall2 } from "@aman_asmuei/amem-core";
+import {
+  getIdentity as acoreGetIdentity2
+} from "@aman_asmuei/acore-core";
+import {
+  listRuleCategories as arulesListCategories2
+} from "@aman_asmuei/arules-core";
+function trimToTokenBudget(items, maxTokens) {
+  const result = [];
+  let total = 0;
+  for (const item of items) {
+    const tokens = estimateTokens(item);
+    if (total + tokens > maxTokens) break;
+    result.push(item);
+    total += tokens;
+  }
+  return result;
+}
+async function buildContext2(stack, opts) {
+  const conventions = [];
+  const decisions = [];
+  const corrections = [];
+  const preferences = [];
+  const rules = [];
+  let memoriesUsed = 0;
+  try {
+    const amemDir = process.env.AMEM_DIR ?? path25.join(os22.homedir(), ".amem");
+    const dbPath = process.env.AMEM_DB ?? path25.join(amemDir, "memory.db");
+    const db2 = createDatabase2(dbPath);
+    const query = [stack.projectName, ...stack.languages, ...stack.frameworks].join(" ");
+    const result = await recall2(db2, { query, limit: 20 });
+    for (const mem of result.memories) {
+      switch (mem.type) {
+        case "pattern":
+          conventions.push(mem.content);
+          break;
+        case "decision":
+          decisions.push(mem.content);
+          break;
+        case "correction":
+          corrections.push(mem.content);
+          break;
+        case "preference":
+          preferences.push(mem.content);
+          break;
+      }
+      memoriesUsed++;
+    }
+  } catch {
+  }
+  try {
+    const identity = await acoreGetIdentity2(AGENT_SCOPE2);
+    if (identity?.content) {
+      const lines = identity.content.split("\n").filter(
+        (l) => l.startsWith("- ") && (l.toLowerCase().includes("prefer") || l.toLowerCase().includes("style") || l.toLowerCase().includes("convention"))
+      );
+      for (const line of lines) {
+        const text3 = line.replace(/^-\s*/, "").trim();
+        if (text3 && !preferences.includes(text3)) preferences.push(text3);
+      }
+    }
+  } catch {
+  }
+  try {
+    const categories = await arulesListCategories2(AGENT_SCOPE2);
+    for (const cat of categories) {
+      for (const ruleText of cat.rules) {
+        rules.push(ruleText);
+      }
+    }
+  } catch {
+  }
+  if (opts?.smart && opts.llmClient) {
+    try {
+      const client = opts.llmClient;
+      const rawData = [
+        `Project: ${stack.projectName}`,
+        `Stack: ${stack.languages.join(", ")} + ${stack.frameworks.join(", ")}`,
+        `Databases: ${stack.databases.join(", ") || "none detected"}`,
+        "",
+        conventions.length > 0 ? `Conventions:
+${conventions.map((c) => `- ${c}`).join("\n")}` : "",
+        decisions.length > 0 ? `Decisions:
+${decisions.map((d) => `- ${d}`).join("\n")}` : "",
+        corrections.length > 0 ? `Corrections:
+${corrections.map((c) => `- ${c}`).join("\n")}` : "",
+        preferences.length > 0 ? `Preferences:
+${preferences.map((p5) => `- ${p5}`).join("\n")}` : "",
+        rules.length > 0 ? `Rules:
+${rules.map((r) => `- ${r}`).join("\n")}` : ""
+      ].filter(Boolean).join("\n\n");
+      const response = await client.chat(
+        "You are a developer context assembler. Given raw developer history, output a merged, deduplicated set of conventions and decisions as markdown bullet lists. Group by: Conventions, Decisions, Corrections, Preferences, Rules. Be specific, not generic. Max 3000 tokens.",
+        [{ role: "user", content: rawData }],
+        () => {
+        }
+      );
+      const text3 = typeof response.message.content === "string" ? response.message.content : response.message.content.map((b) => b.text ?? "").join("");
+      const extractSection = (sectionName) => {
+        const regex = new RegExp(`##?\\s*${sectionName}[\\s\\S]*?(?=##|$)`, "i");
+        const match = text3.match(regex);
+        if (!match) return [];
+        return match[0].split("\n").filter((l) => l.startsWith("- ")).map((l) => l.replace(/^-\s*/, "").trim());
+      };
+      const smartConventions = extractSection("Conventions");
+      const smartDecisions = extractSection("Decisions");
+      const smartCorrections = extractSection("Corrections");
+      const smartPreferences = extractSection("Preferences");
+      const smartRules = extractSection("Rules");
+      return {
+        stack,
+        conventions: trimToTokenBudget(smartConventions.length > 0 ? smartConventions : conventions, TOKEN_LIMITS.conventions),
+        decisions: trimToTokenBudget(smartDecisions.length > 0 ? smartDecisions : decisions, TOKEN_LIMITS.decisions),
+        corrections: trimToTokenBudget(smartCorrections.length > 0 ? smartCorrections : corrections, TOKEN_LIMITS.corrections),
+        preferences: trimToTokenBudget(smartPreferences.length > 0 ? smartPreferences : preferences, TOKEN_LIMITS.preferences),
+        rules: trimToTokenBudget(smartRules.length > 0 ? smartRules : rules, TOKEN_LIMITS.rules),
+        metadata: {
+          generatedAt: Date.now(),
+          mode: "smart",
+          memoriesUsed
+        }
+      };
+    } catch {
+    }
+  }
+  return {
+    stack,
+    conventions: trimToTokenBudget(conventions, TOKEN_LIMITS.conventions),
+    decisions: trimToTokenBudget(decisions, TOKEN_LIMITS.decisions),
+    corrections: trimToTokenBudget(corrections, TOKEN_LIMITS.corrections),
+    preferences: trimToTokenBudget(preferences, TOKEN_LIMITS.preferences),
+    rules: trimToTokenBudget(rules, TOKEN_LIMITS.rules),
+    metadata: {
+      generatedAt: Date.now(),
+      mode: "template",
+      memoriesUsed
+    }
+  };
+}
+var AGENT_SCOPE2, TOKEN_LIMITS;
+var init_context_builder = __esm({
+  "src/dev/context-builder.ts"() {
+    "use strict";
+    init_token_budget();
+    AGENT_SCOPE2 = process.env.AMAN_AGENT_SCOPE ?? "dev:agent";
+    TOKEN_LIMITS = {
+      conventions: 1500,
+      decisions: 1200,
+      corrections: 800,
+      preferences: 500,
+      rules: 800
+    };
+  }
+});
+
+// src/dev/claude-md-writer.ts
+import fs25 from "fs";
+import path26 from "path";
+function formatStack(stack) {
+  const parts = [];
+  const goFrameworks = ["fiber", "gin", "chi", "echo"];
+  const jsFrameworks = ["next", "react", "remix", "express", "fastify", "hono", "nestjs", "vue", "svelte", "nuxt"];
+  const pyFrameworks = ["django", "fastapi", "flask"];
+  for (const lang of stack.languages) {
+    const fw = stack.frameworks.filter((f) => {
+      if (lang === "go" && goFrameworks.includes(f)) return true;
+      if ((lang === "typescript" || lang === "javascript") && jsFrameworks.includes(f)) return true;
+      if (lang === "python" && pyFrameworks.includes(f)) return true;
+      if (lang === "dart" && f === "flutter") return true;
+      return false;
+    });
+    const name = lang.charAt(0).toUpperCase() + lang.slice(1);
+    if (fw.length > 0) {
+      parts.push(`${name} (${fw.map((f) => f.charAt(0).toUpperCase() + f.slice(1)).join(", ")})`);
+    } else {
+      parts.push(name);
+    }
+  }
+  if (stack.databases.length > 0) {
+    parts.push(...stack.databases.map((d) => d.charAt(0).toUpperCase() + d.slice(1)));
+  }
+  return parts.join(" + ");
+}
+function renderToString(ctx) {
+  const lines = [];
+  const ts = new Date(ctx.metadata.generatedAt).toISOString();
+  lines.push(`# Project: ${ctx.stack.projectName}`);
+  lines.push(`<!-- aman-agent:dev generated=${ts} memories=${ctx.metadata.memoriesUsed} mode=${ctx.metadata.mode} -->`);
+  lines.push("");
+  const stackLine = formatStack(ctx.stack);
+  if (stackLine || ctx.stack.infra.length > 0) {
+    lines.push("## Stack");
+    if (stackLine) lines.push(`- ${stackLine}`);
+    if (ctx.stack.infra.length > 0) {
+      lines.push(`- Infra: ${ctx.stack.infra.join(", ")}`);
+    }
+    if (ctx.stack.isMonorepo) {
+      lines.push("- Monorepo");
+    }
+    lines.push("");
+  }
+  if (ctx.conventions.length > 0) {
+    lines.push("## Conventions");
+    for (const c of ctx.conventions) lines.push(`- ${c}`);
+    lines.push("");
+  }
+  if (ctx.decisions.length > 0) {
+    lines.push("## Past Decisions");
+    for (const d of ctx.decisions) lines.push(`- ${d}`);
+    lines.push("");
+  }
+  if (ctx.corrections.length > 0) {
+    lines.push("## Corrections");
+    for (const c of ctx.corrections) lines.push(`- ${c}`);
+    lines.push("");
+  }
+  if (ctx.preferences.length > 0) {
+    lines.push("## Developer Preferences");
+    for (const p5 of ctx.preferences) lines.push(`- ${p5}`);
+    lines.push("");
+  }
+  if (ctx.rules.length > 0) {
+    lines.push("## Rules");
+    for (const r of ctx.rules) lines.push(`- ${r}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function parseMarker(content) {
+  const match = content.match(
+    /<!--\s*aman-agent:dev\s+generated=(\S+)\s+memories=(\d+)\s+mode=(\S+)\s*-->/
+  );
+  if (!match) return null;
+  return {
+    generatedAt: new Date(match[1]),
+    memories: parseInt(match[2], 10),
+    mode: match[3]
+  };
+}
+function checkStaleness(projectPath) {
+  const claudeMdPath = path26.join(projectPath, "CLAUDE.md");
+  if (!fs25.existsSync(claudeMdPath)) {
+    return { status: "missing" };
+  }
+  const content = fs25.readFileSync(claudeMdPath, "utf-8");
+  const marker = parseMarker(content);
+  if (!marker) {
+    return { status: "no-marker" };
+  }
+  return { status: "fresh", generatedAt: marker.generatedAt };
+}
+function writeClaudeMd(ctx, projectPath) {
+  const claudeMdPath = path26.join(projectPath, "CLAUDE.md");
+  let backedUp = false;
+  if (fs25.existsSync(claudeMdPath)) {
+    const content = fs25.readFileSync(claudeMdPath, "utf-8");
+    const marker = parseMarker(content);
+    if (!marker) {
+      fs25.copyFileSync(claudeMdPath, `${claudeMdPath}.bak`);
+      backedUp = true;
+    }
+  }
+  const md = renderToString(ctx);
+  fs25.writeFileSync(claudeMdPath, md, "utf-8");
+  return { written: true, backedUp, path: claudeMdPath };
+}
+var init_claude_md_writer = __esm({
+  "src/dev/claude-md-writer.ts"() {
+    "use strict";
+  }
+});
+
+// src/dev/dev-command.ts
+var dev_command_exports = {};
+__export(dev_command_exports, {
+  runDev: () => runDev
+});
+import fs26 from "fs";
+import path27 from "path";
+function ensureGitignore(projectPath) {
+  const gitignorePath = path27.join(projectPath, ".gitignore");
+  if (!fs26.existsSync(gitignorePath)) return;
+  const content = fs26.readFileSync(gitignorePath, "utf-8");
+  if (content.includes("CLAUDE.md")) return;
+  fs26.appendFileSync(gitignorePath, "\n# Generated by aman-agent dev\nCLAUDE.md\n");
+}
+async function runDev(projectPath, flags = {}, precomputedStack) {
+  const resolved = path27.resolve(projectPath);
+  if (!fs26.existsSync(resolved)) {
+    return { success: false, generated: false, error: `Directory not found: ${resolved}` };
+  }
+  const stack = precomputedStack ?? scanStack(resolved);
+  if (flags.diff) {
+    const ctx2 = await buildContext2(stack, { smart: flags.smart });
+    const newContent = renderToString(ctx2);
+    const existingPath = path27.join(resolved, "CLAUDE.md");
+    const existing = fs26.existsSync(existingPath) ? fs26.readFileSync(existingPath, "utf-8") : "";
+    return {
+      success: true,
+      generated: false,
+      diff: existing === newContent ? "(no changes)" : newContent,
+      context: ctx2
+    };
+  }
+  if (!flags.force) {
+    const staleness = checkStaleness(resolved);
+    if (staleness.status === "fresh") {
+      return { success: true, generated: false, skippedReason: "fresh" };
+    }
+  }
+  const ctx = await buildContext2(stack, { smart: flags.smart });
+  const writeResult = writeClaudeMd(ctx, resolved);
+  ensureGitignore(resolved);
+  return {
+    success: true,
+    generated: writeResult.written,
+    context: ctx
+  };
+}
+var init_dev_command = __esm({
+  "src/dev/dev-command.ts"() {
+    "use strict";
+    init_stack_detector();
+    init_context_builder();
+    init_claude_md_writer();
+  }
+});
+
 // src/index.ts
 import { Command } from "commander";
 import * as p4 from "@clack/prompts";
@@ -696,63 +1222,11 @@ function migrateIfNeeded() {
 }
 
 // src/prompt.ts
+init_token_budget();
 import fs4 from "fs";
 import path4 from "path";
 import os3 from "os";
 
-// src/token-budget.ts
-function estimateTokens(text3) {
-  return Math.round(text3.split(/\s+/).filter(Boolean).length * 1.3);
-}
-var PRIORITIES = [
-  "identity",
-  // core.md — always include
-  "user",
-  // user.md — user profile, always include
-  "guardrails",
-  // rules.md — safety critical
-  "workflows",
-  // flow.md — behavioral
-  "tools",
-  // kit.md — capabilities
-  "skills"
-  // skills.md — can be truncated
-];
-function buildBudgetedPrompt(components, maxTokens = 8e3) {
-  const included = [];
-  const truncated = [];
-  const parts = [];
-  let totalTokens = 0;
-  const sorted = [...components].sort((a, b) => {
-    const aPri = PRIORITIES.indexOf(a.name);
-    const bPri = PRIORITIES.indexOf(b.name);
-    return (aPri === -1 ? 99 : aPri) - (bPri === -1 ? 99 : bPri);
-  });
-  for (const comp of sorted) {
-    if (totalTokens + comp.tokens <= maxTokens) {
-      parts.push(comp.content);
-      included.push(comp.name);
-      totalTokens += comp.tokens;
-    } else {
-      const halfContent = comp.content.slice(0, Math.floor(comp.content.length / 2));
-      const halfTokens = estimateTokens(halfContent);
-      if (totalTokens + halfTokens <= maxTokens) {
-        parts.push(halfContent + "\n\n[... truncated for context budget ...]");
-        included.push(comp.name + " (partial)");
-        totalTokens += halfTokens;
-      } else {
-        truncated.push(comp.name);
-      }
-    }
-  }
-  return {
-    prompt: parts.join("\n\n---\n\n"),
-    included,
-    truncated,
-    totalTokens
-  };
-}
-
 // src/user-identity.ts
 import fs3 from "fs";
 import path3 from "path";
@@ -4574,12 +5048,12 @@ You are being delegated a specific task by the primary agent. Complete this task
 </delegation>`;
     let finalDelegationPrompt = delegationPrompt;
     try {
-      const recall2 = await memoryRecall(task, { limit: 3, compact: true });
-      if (recall2.total > 0) {
+      const recall3 = await memoryRecall(task, { limit: 3, compact: true });
+      if (recall3.total > 0) {
         finalDelegationPrompt += `
 
 <relevant-memories>
-${recall2.text}
+${recall3.text}
 </relevant-memories>`;
       }
     } catch {
@@ -6604,7 +7078,7 @@ function handleReset(action) {
 function handleUpdate() {
   try {
     const current = execFileSync3("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = true ? "0.32.0" : "unknown";
+    const local = true ? "0.33.0" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc6.green("Up to date")} \u2014 v${local}` };
     }
@@ -8381,6 +8855,9 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
   }
 }
 
+// src/agent.ts
+init_token_budget();
+
 // src/errors.ts
 var ERROR_MAPPINGS = [
   { pattern: /rate.?limit|429/i, message: "Rate limited. I'll retry automatically." },
@@ -8988,10 +9465,10 @@ ${converted}
     let augmentedSystemPrompt = activeSystemPrompt;
     let memoryTokens = 0;
     {
-      const recall2 = await recallForMessage(input);
-      if (recall2) {
-        augmentedSystemPrompt = activeSystemPrompt + recall2.text;
-        memoryTokens = recall2.tokenEstimate;
+      const recall3 = await recallForMessage(input);
+      if (recall3) {
+        augmentedSystemPrompt = activeSystemPrompt + recall3.text;
+        memoryTokens = recall3.tokenEstimate;
       }
     }
     const userTurnCount = messages.filter((m) => m.role === "user").length;
@@ -9370,8 +9847,8 @@ async function saveConversationToMemory(messages, sessionId) {
 }
 
 // src/index.ts
-import fs24 from "fs";
-import path24 from "path";
+import fs27 from "fs";
+import path28 from "path";
 
 // src/presets.ts
 var PRESETS = {
@@ -9585,7 +10062,7 @@ var Inbox = class {
 // package.json
 var package_default = {
   name: "@aman_asmuei/aman-agent",
-  version: "0.32.0",
+  version: "0.33.0",
   description: "Your AI companion, running locally \u2014 powered by the aman ecosystem",
   type: "module",
   engines: {
@@ -9878,9 +10355,9 @@ async function runServe(opts) {
 
 // src/index.ts
 async function autoDetectConfig() {
-  const reconfigMarker = path24.join(homeDir(), ".reconfig");
-  if (fs24.existsSync(reconfigMarker)) {
-    fs24.unlinkSync(reconfigMarker);
+  const reconfigMarker = path28.join(homeDir(), ".reconfig");
+  if (fs27.existsSync(reconfigMarker)) {
+    fs27.unlinkSync(reconfigMarker);
     return null;
   }
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
@@ -9909,10 +10386,10 @@ async function autoDetectConfig() {
   return null;
 }
 function bootstrapEcosystem() {
-  const corePath = path24.join(identityDir(), "core.md");
-  if (fs24.existsSync(corePath)) return false;
-  fs24.mkdirSync(identityDir(), { recursive: true });
-  fs24.writeFileSync(corePath, [
+  const corePath = path28.join(identityDir(), "core.md");
+  if (fs27.existsSync(corePath)) return false;
+  fs27.mkdirSync(identityDir(), { recursive: true });
+  fs27.writeFileSync(corePath, [
     "# Aman",
     "",
     "## Personality",
@@ -9924,10 +10401,10 @@ function bootstrapEcosystem() {
     "## Session",
     "_New companion \u2014 no prior sessions._"
   ].join("\n"), "utf-8");
-  const rulesPath = path24.join(rulesDir(), "rules.md");
-  if (!fs24.existsSync(rulesPath)) {
-    fs24.mkdirSync(rulesDir(), { recursive: true });
-    fs24.writeFileSync(rulesPath, [
+  const rulesPath = path28.join(rulesDir(), "rules.md");
+  if (!fs27.existsSync(rulesPath)) {
+    fs27.mkdirSync(rulesDir(), { recursive: true });
+    fs27.writeFileSync(rulesPath, [
       "# Guardrails",
       "",
       "## safety",
@@ -9939,20 +10416,20 @@ function bootstrapEcosystem() {
       "- Respect the user's preferences stored in memory"
     ].join("\n"), "utf-8");
   }
-  const flowPath = path24.join(workflowsDir(), "flow.md");
-  if (!fs24.existsSync(flowPath)) {
-    fs24.mkdirSync(workflowsDir(), { recursive: true });
-    fs24.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
+  const flowPath = path28.join(workflowsDir(), "flow.md");
+  if (!fs27.existsSync(flowPath)) {
+    fs27.mkdirSync(workflowsDir(), { recursive: true });
+    fs27.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
   }
-  const skillPath = path24.join(skillsDir(), "skills.md");
-  if (!fs24.existsSync(skillPath)) {
-    fs24.mkdirSync(skillsDir(), { recursive: true });
-    fs24.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
+  const skillPath = path28.join(skillsDir(), "skills.md");
+  if (!fs27.existsSync(skillPath)) {
+    fs27.mkdirSync(skillsDir(), { recursive: true });
+    fs27.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
   }
   return true;
 }
 var program = new Command();
-program.name("aman-agent").description("Your AI companion, running locally").version("0.32.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
+program.name("aman-agent").description("Your AI companion, running locally").version("0.33.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
   p4.intro(pc9.bold("aman agent") + pc9.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
@@ -10307,18 +10784,18 @@ program.command("init").description("Set up your AI companion with a guided wiza
   });
   if (p4.isCancel(preset)) process.exit(0);
   const result = applyPreset(preset, name || "Aman");
-  fs24.mkdirSync(identityDir(), { recursive: true });
-  fs24.writeFileSync(path24.join(identityDir(), "core.md"), result.coreMd, "utf-8");
+  fs27.mkdirSync(identityDir(), { recursive: true });
+  fs27.writeFileSync(path28.join(identityDir(), "core.md"), result.coreMd, "utf-8");
   p4.log.success(`Identity created \u2014 ${PRESETS[preset].identity.personality.split(".")[0].toLowerCase()}`);
   if (result.rulesMd) {
-    fs24.mkdirSync(rulesDir(), { recursive: true });
-    fs24.writeFileSync(path24.join(rulesDir(), "rules.md"), result.rulesMd, "utf-8");
+    fs27.mkdirSync(rulesDir(), { recursive: true });
+    fs27.writeFileSync(path28.join(rulesDir(), "rules.md"), result.rulesMd, "utf-8");
     const ruleCount = (result.rulesMd.match(/^- /gm) || []).length;
     p4.log.success(`${ruleCount} rules set`);
   }
   if (result.flowMd) {
-    fs24.mkdirSync(workflowsDir(), { recursive: true });
-    fs24.writeFileSync(path24.join(workflowsDir(), "flow.md"), result.flowMd, "utf-8");
+    fs27.mkdirSync(workflowsDir(), { recursive: true });
+    fs27.writeFileSync(path28.join(workflowsDir(), "flow.md"), result.flowMd, "utf-8");
     const wfCount = (result.flowMd.match(/^## /gm) || []).length;
     p4.log.success(`${wfCount} workflow${wfCount > 1 ? "s" : ""} added`);
   }
@@ -10347,18 +10824,78 @@ program.command("serve").description("Run aman-agent as a local MCP server other
     process.exit(1);
   }
 });
+program.command("dev [path]").description("Set up project context and start Claude Code").option("--smart", "Use LLM to generate CLAUDE.md").option("--no-launch", "Generate CLAUDE.md only, don't start claude").option("--force", "Regenerate even if CLAUDE.md is fresh").option("--diff", "Show what would change without writing").action(async (projectPath, opts) => {
+  const { runDev: runDev2 } = await Promise.resolve().then(() => (init_dev_command(), dev_command_exports));
+  const { scanStack: scanStack2 } = await Promise.resolve().then(() => (init_stack_detector(), stack_detector_exports));
+  const targetPath = projectPath ?? process.cwd();
+  const stack = scanStack2(targetPath);
+  const stackParts = stack.languages.map((l) => l.charAt(0).toUpperCase() + l.slice(1));
+  if (stack.frameworks.length > 0) {
+    stackParts.push(`(${stack.frameworks.map((f) => f.charAt(0).toUpperCase() + f.slice(1)).join(", ")})`);
+  }
+  if (stack.databases.length > 0) {
+    stackParts.push(...stack.databases.map((d) => d.charAt(0).toUpperCase() + d.slice(1)));
+  }
+  if (stack.infra.length > 0) {
+    stackParts.push(...stack.infra.map((i) => i.charAt(0).toUpperCase() + i.slice(1)));
+  }
+  if (stack.languages.length > 0) {
+    console.log(`
+  ${pc9.cyan("Detected:")} ${stackParts.join(" + ")}`);
+  } else {
+    console.log(`
+  ${pc9.dim("No stack detected \u2014 generating minimal CLAUDE.md")}`);
+  }
+  const result = await runDev2(targetPath, {
+    smart: opts.smart,
+    noLaunch: opts.launch === false,
+    force: opts.force,
+    diff: opts.diff
+  }, stack);
+  if (!result.success) {
+    console.error(`  ${pc9.red("Error:")} ${result.error}`);
+    process.exit(1);
+  }
+  if (result.diff) {
+    console.log(`
+${result.diff}`);
+    return;
+  }
+  if (result.generated) {
+    const mode = opts.smart ? "smart" : "template";
+    const memCount = result.context?.metadata.memoriesUsed ?? 0;
+    console.log(`  ${pc9.cyan("Recalled:")} ${memCount} memories`);
+    console.log(`  ${pc9.green("\u2713")} CLAUDE.md written (${mode} mode)
+`);
+  } else if (result.skippedReason === "fresh") {
+    console.log(`  ${pc9.green("\u2713")} CLAUDE.md is up to date
+`);
+  }
+  if (opts.launch !== false && !opts.diff) {
+    const { execFileSync: execFileSync4 } = await import("child_process");
+    try {
+      execFileSync4("which", ["claude"], { stdio: "ignore" });
+    } catch {
+      console.log(`  ${pc9.yellow("Claude Code not found.")} Install: npm install -g @anthropic-ai/claude-code`);
+      process.exit(1);
+    }
+    console.log(`  ${pc9.cyan("Launching Claude Code...")}
+`);
+    execFileSync4("claude", [], { cwd: targetPath, stdio: "inherit" });
+  }
+});
 program.command("setup").description("Run the full configuration wizard (provider, identity, presets)").action(async () => {
   p4.intro(pc9.bold("aman agent setup") + pc9.dim(" \u2014 full configuration wizard"));
-  const reconfigPath = path24.join(homeDir(), ".reconfig");
-  fs24.mkdirSync(homeDir(), { recursive: true });
-  fs24.writeFileSync(reconfigPath, "", "utf-8");
+  const reconfigPath = path28.join(homeDir(), ".reconfig");
+  fs27.mkdirSync(homeDir(), { recursive: true });
+  fs27.writeFileSync(reconfigPath, "", "utf-8");
   p4.log.info("Configuration reset. Restart aman-agent to complete setup.");
 });
 program.command("update").description("Update aman-agent to the latest version").action(async () => {
   const { execFileSync: execFileSync4 } = await import("child_process");
-  const isVendored = process.execPath.includes(path24.join(".aman-agent", "node"));
+  const isVendored = process.execPath.includes(path28.join(".aman-agent", "node"));
   if (isVendored) {
-    const npmPath = path24.join(homeDir(), "node", "bin", "npm");
+    const npmPath = path28.join(homeDir(), "node", "bin", "npm");
     console.log("Updating aman-agent...");
     try {
       execFileSync4(npmPath, ["install", "-g", "@aman_asmuei/aman-agent@latest"], {
@@ -10386,7 +10923,7 @@ program.command("update").description("Update aman-agent to the latest version")
 program.command("uninstall").description("Remove aman-agent and all its data").action(async () => {
   const home2 = homeDir();
   if (!process.stdin.isTTY) {
-    fs24.rmSync(home2, { recursive: true, force: true });
+    fs27.rmSync(home2, { recursive: true, force: true });
     console.log("\u2713 Removed " + home2);
     return;
   }
@@ -10397,7 +10934,7 @@ program.command("uninstall").description("Remove aman-agent and all its data").a
     console.log("Cancelled.");
     return;
   }
-  fs24.rmSync(home2, { recursive: true, force: true });
+  fs27.rmSync(home2, { recursive: true, force: true });
   console.log("\u2713 Removed " + home2);
   console.log("");
   console.log("To complete uninstall, remove the PATH line from your shell config:");