lovecode-ai 0.1.9 → 0.2.1

package/dist/chunk-PX34PVT4.js

@@ -0,0 +1,3284 @@
+import {
+  commit,
+  createBranch,
+  formatBranches,
+  formatLog,
+  formatStatus,
+  getBranches,
+  getCurrentBranch,
+  getFullDiff,
+  getLog,
+  getStagedDiff,
+  getStatus,
+  isGitAvailable,
+  stageAll,
+  switchBranch
+} from "./chunk-7CT3XDH6.js";
+import {
+  click,
+  formatDOMElement,
+  formatScreenshotResult,
+  goto,
+  inspect,
+  isBrowserRunning,
+  screenshot,
+  type
+} from "./chunk-IVAMLKMS.js";
+import {
+  disablePlugin,
+  enablePlugin,
+  getAllPluginTools,
+  listPlugins,
+  loadBuiltinPlugins
+} from "./chunk-MOZHR2QY.js";
+
+// src/core/tools.ts
+import * as fs14 from "fs";
+import * as path13 from "path";
+import { execSync as execSync3 } from "child_process";
+import chalk13 from "chalk";
+
+// src/fs/scanner.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import chalk from "chalk";
+
+// src/fs/ignore.ts
+import * as fs from "fs";
+import * as path from "path";
+function parseGitignore(content) {
+  const patterns = [];
+  const negations = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("!")) {
+      negations.push(trimmed.slice(1));
+    } else {
+      patterns.push(trimmed);
+    }
+  }
+  return { patterns, negations };
+}
+function loadFile(dir, filename) {
+  const filePath = path.join(dir, filename);
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return parseGitignore(content);
+  } catch {
+    return null;
+  }
+}
+function loadIgnoreRules(rootDir) {
+  const rules2 = { patterns: [], negations: [] };
+  const gitignore = loadFile(rootDir, ".gitignore");
+  if (gitignore) {
+    rules2.patterns.push(...gitignore.patterns);
+    rules2.negations.push(...gitignore.negations);
+  }
+  const lovecodeignore = loadFile(rootDir, ".lovecodeignore");
+  if (lovecodeignore) {
+    rules2.patterns.push(...lovecodeignore.patterns);
+    rules2.negations.push(...lovecodeignore.negations);
+  }
+  rules2.patterns.push("node_modules/**", ".git/**", "dist/**", "build/**", ".next/**");
+  return rules2;
+}
+function isIgnored(relativePath, rules2) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  for (const negation of rules2.negations) {
+    if (matchPattern(normalized, negation)) return false;
+  }
+  for (const pattern of rules2.patterns) {
+    if (matchPattern(normalized, pattern)) return true;
+  }
+  return false;
+}
+function matchPattern(filePath, pattern) {
+  if (pattern.endsWith("/")) {
+    if (filePath.startsWith(pattern) || filePath === pattern.slice(0, -1)) return true;
+  }
+  if (pattern.startsWith("/")) {
+    return matchSimple(filePath, pattern.slice(1));
+  }
+  if (matchSimple(filePath, pattern)) return true;
+  const basename6 = path.basename(filePath);
+  if (isGlobless(pattern) && basename6 === pattern) return true;
+  return false;
+}
+function isGlobless(pattern) {
+  return !pattern.includes("*") && !pattern.includes("?") && !pattern.includes("[");
+}
+function matchSimple(filePath, pattern) {
+  const regex = globToRegex(pattern);
+  return regex.test(filePath.split("/").slice(-pattern.split("/").length).join("/"));
+}
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "___DOUBLESTAR___").replace(/\*/g, "[^/]*").replace(/___DOUBLESTAR___/g, ".*").replace(/\?/g, "[^/]");
+  return new RegExp(`^${escaped}$`);
+}
+
+// src/fs/scanner.ts
+var sourceExtensions = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".py",
+  ".rs",
+  ".go",
+  ".rb",
+  ".java",
+  ".kt",
+  ".swift",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".php",
+  ".r",
+  ".scala",
+  ".ex",
+  ".exs"
+]);
+var configExtensions = /* @__PURE__ */ new Set([
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".env",
+  ".env.example",
+  ".editorconfig",
+  ".prettierrc",
+  ".eslintrc",
+  "tsconfig.json",
+  "package.json",
+  "Dockerfile",
+  "Makefile"
+]);
+var docExtensions = /* @__PURE__ */ new Set([
+  ".md",
+  ".mdx",
+  ".txt",
+  ".rst",
+  ".adoc",
+  ".wiki",
+  ".org"
+]);
+var scriptExtensions = /* @__PURE__ */ new Set([
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".bat",
+  ".cmd",
+  ".ps1"
+]);
+var dataExtensions = /* @__PURE__ */ new Set([
+  ".csv",
+  ".tsv",
+  ".jsonl",
+  ".xml",
+  ".sql",
+  ".graphql",
+  ".proto"
+]);
+function categorize(ext, basename6) {
+  if (sourceExtensions.has(ext)) return "source";
+  if (configExtensions.has(ext) || configExtensions.has(basename6)) return "config";
+  if (docExtensions.has(ext)) return "doc";
+  if (scriptExtensions.has(ext)) return "script";
+  if (dataExtensions.has(ext)) return "data";
+  return "other";
+}
+function scanDirectory(options) {
+  const { rootDir, maxDepth = 20, maxFiles = 1e4, includeHidden = false } = options;
+  const rules2 = loadIgnoreRules(rootDir);
+  const results = [];
+  function walk(dir, depth) {
+    if (depth > maxDepth || results.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      const relativePath = path2.relative(rootDir, fullPath);
+      if (relativePath.startsWith("..")) continue;
+      const isHidden = entry.name.startsWith(".") && entry.name !== "." && entry.name !== "..";
+      if (isHidden && !includeHidden) {
+        if (entry.isDirectory()) continue;
+        const skipHiddenConfig = entry.name === ".gitignore" || entry.name === ".env";
+        if (!skipHiddenConfig) continue;
+      }
+      if (isIgnored(relativePath, rules2)) continue;
+      if (entry.isDirectory()) {
+        walk(fullPath, depth + 1);
+      } else if (entry.isFile()) {
+        const ext = path2.extname(entry.name).toLowerCase();
+        const stats = fs2.statSync(fullPath);
+        const relative5 = relativePath.replace(/\\/g, "/");
+        results.push({
+          path: fullPath,
+          relativePath: relative5,
+          size: stats.size,
+          modifiedAt: stats.mtime,
+          extension: ext,
+          category: categorize(ext, entry.name)
+        });
+      }
+    }
+  }
+  walk(rootDir, 0);
+  if (options.categories && options.categories.length > 0) {
+    return results.filter((f) => options.categories.includes(f.category));
+  }
+  return results;
+}
+function getFilesByCategory(files) {
+  const grouped = {
+    source: [],
+    config: [],
+    doc: [],
+    script: [],
+    data: [],
+    other: []
+  };
+  for (const file of files) {
+    grouped[file.category].push(file);
+  }
+  return grouped;
+}
+function printScanSummary(files) {
+  const grouped = getFilesByCategory(files);
+  const total = files.length;
+  const categoryColors = {
+    source: chalk.cyan,
+    config: chalk.yellow,
+    doc: chalk.green,
+    script: chalk.magenta,
+    data: chalk.blue,
+    other: chalk.gray
+  };
+  const lines = [chalk.bold(`
+  Scanned ${total} files`)];
+  for (const [category, catFiles] of Object.entries(grouped)) {
+    if (catFiles.length > 0) {
+      const color = categoryColors[category] || chalk.gray;
+      lines.push(`  ${color(category.padEnd(10))} ${catFiles.length} files`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/fs/operations.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+function renameFile(oldPath, newPath) {
+  try {
+    const dir = path3.dirname(newPath);
+    if (!fs3.existsSync(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
+    }
+    fs3.renameSync(oldPath, newPath);
+    return { success: true, message: `Renamed to ${newPath}` };
+  } catch (err) {
+    return { success: false, message: "", error: String(err) };
+  }
+}
+function duplicateFile(sourcePath, destPath) {
+  try {
+    const dir = path3.dirname(destPath);
+    if (!fs3.existsSync(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
+    }
+    fs3.copyFileSync(sourcePath, destPath);
+    return { success: true, message: `Duplicated to ${destPath}` };
+  } catch (err) {
+    return { success: false, message: "", error: String(err) };
+  }
+}
+function getDirectoryTree(dirPath, prefix = "", maxDepth = 3, currentDepth = 0) {
+  if (currentDepth > maxDepth) return `${prefix}  ...
+`;
+  let result = "";
+  let entries;
+  try {
+    entries = fs3.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return `${prefix}  (error reading)
+`;
+  }
+  const filtered = entries.filter((e) => !e.name.startsWith(".") || e.name === ".gitignore");
+  const sorted = filtered.sort((a, b) => {
+    if (a.isDirectory() && !b.isDirectory()) return -1;
+    if (!a.isDirectory() && b.isDirectory()) return 1;
+    return a.name.localeCompare(b.name);
+  });
+  for (let i = 0; i < sorted.length; i++) {
+    const entry = sorted[i];
+    const isLast = i === sorted.length - 1;
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const nextPrefix = isLast ? "    " : "\u2502   ";
+    if (entry.isDirectory()) {
+      result += `${prefix}${connector}${entry.name}/
+`;
+      result += getDirectoryTree(
+        path3.join(dirPath, entry.name),
+        prefix + nextPrefix,
+        maxDepth,
+        currentDepth + 1
+      );
+    } else {
+      const stats = fs3.statSync(path3.join(dirPath, entry.name));
+      const size = formatSize(stats.size);
+      result += `${prefix}${connector}${entry.name} ${size}
+`;
+    }
+  }
+  return result;
+}
+function formatSize(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIdx = 0;
+  while (size >= 1024 && unitIdx < units.length - 1) {
+    size /= 1024;
+    unitIdx++;
+  }
+  return `(${size.toFixed(1)} ${units[unitIdx]})`;
+}
+
+// src/fs/search.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { execSync } from "child_process";
+function normalizeQuery(query) {
+  return query.toLowerCase().split(/[\s_-]+/).filter((w) => w.length > 0);
+}
+function scoreByName(filename, query) {
+  const lower = filename.toLowerCase();
+  const qLower = query.toLowerCase();
+  let score = 0;
+  if (lower === qLower) score += 100;
+  else if (lower.includes(qLower)) score += 50;
+  else if (lower.startsWith(qLower)) score += 40;
+  const queryWords = normalizeQuery(query);
+  const nameWords = normalizeQuery(filename.replace(/[.-]/g, " "));
+  for (const qw of queryWords) {
+    for (const nw of nameWords) {
+      if (nw === qw) score += 20;
+      else if (nw.startsWith(qw) || nw.endsWith(qw)) score += 10;
+      else if (nw.includes(qw)) score += 5;
+    }
+  }
+  return score;
+}
+function collectAllFiles(dir, maxFiles = 5e3) {
+  const results = [];
+  function walk(dir2) {
+    if (results.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = fs4.readdirSync(dir2, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (results.length >= maxFiles) return;
+      if (entry.name.startsWith(".") && entry.name !== ".gitignore") continue;
+      const fullPath = path4.join(dir2, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === ".git") continue;
+        walk(fullPath);
+      } else {
+        results.push(fullPath);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+function findFiles(options) {
+  const { rootDir, query, maxResults = 20 } = options;
+  const allFiles = collectAllFiles(rootDir);
+  const scored = [];
+  for (const filePath of allFiles) {
+    const relativePath = path4.relative(rootDir, filePath).replace(/\\/g, "/");
+    const basename6 = path4.basename(filePath);
+    const score = scoreByName(basename6, query) + scoreByName(relativePath, query) * 0.5;
+    if (score > 0) {
+      scored.push({
+        filePath,
+        relativePath,
+        score
+      });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  const results = scored.slice(0, maxResults);
+  if (options.includeContent) {
+    for (const result of results) {
+      result.matches = searchFileContent(result.filePath, query);
+    }
+  }
+  return results;
+}
+function searchFileContent(filePath, query) {
+  try {
+    const content = fs4.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const matches = [];
+    const lowerQuery = query.toLowerCase();
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].toLowerCase().includes(lowerQuery)) {
+        matches.push({ line: i + 1, content: lines[i].trim() });
+        if (matches.length >= 10) break;
+      }
+    }
+    return matches;
+  } catch {
+    return [];
+  }
+}
+function findWithRipgrep(query, rootDir) {
+  try {
+    const cmd = `rg -l -i '${query.replace(/'/g, "'\\''")}' 2>/dev/null`;
+    const output = execSync(cmd, { cwd: rootDir, encoding: "utf-8", maxBuffer: 1024 * 1024 });
+    const files = output.trim().split("\n").filter(Boolean);
+    return files.slice(0, 30).map((filePath) => ({
+      filePath: path4.join(rootDir, filePath),
+      relativePath: filePath,
+      score: 50
+    }));
+  } catch {
+    return [];
+  }
+}
+function semanticSearch(query, rootDir) {
+  const nameResults = findFiles({ rootDir, query, maxResults: 15 });
+  const namePaths = new Set(nameResults.map((r) => r.relativePath));
+  let contentResults = [];
+  try {
+    contentResults = findWithRipgrep(query, rootDir);
+  } catch {
+    const textFiles = collectAllFiles(rootDir, 2e3).filter((f) => {
+      const ext = path4.extname(f);
+      return [".ts", ".js", ".py", ".rs", ".go", ".md", ".json", ".txt", ".yaml", ".yml"].includes(ext);
+    });
+    for (const filePath of textFiles.slice(0, 100)) {
+      const relativePath = path4.relative(rootDir, filePath).replace(/\\/g, "/");
+      if (namePaths.has(relativePath)) continue;
+      const matches = searchFileContent(filePath, query);
+      if (matches.length > 0) {
+        contentResults.push({
+          filePath,
+          relativePath,
+          matches,
+          score: 10 + matches.length
+        });
+      }
+    }
+  }
+  const combined = [...nameResults];
+  for (const cr of contentResults) {
+    if (!namePaths.has(cr.relativePath)) {
+      combined.push(cr);
+    }
+  }
+  combined.sort((a, b) => b.score - a.score);
+  return combined.slice(0, 20);
+}
+
+// src/fs/rank.ts
+import * as path5 from "path";
+import chalk2 from "chalk";
+var CATEGORY_WEIGHTS = {
+  source: 100,
+  config: 70,
+  script: 60,
+  doc: 40,
+  data: 30,
+  other: 10
+};
+var EXTENSION_BOOSTS = {
+  ".ts": 15,
+  ".tsx": 15,
+  ".js": 10,
+  ".jsx": 10,
+  ".py": 12,
+  ".rs": 12,
+  ".go": 12,
+  ".md": 5
+};
+var IMPORTANT_FILES = {
+  "package.json": 50,
+  "tsconfig.json": 40,
+  "Cargo.toml": 40,
+  "go.mod": 40,
+  "pyproject.toml": 40,
+  "Dockerfile": 30,
+  "docker-compose.yml": 30,
+  "Makefile": 25,
+  "README.md": 20,
+  "index.ts": 20,
+  "main.ts": 20,
+  "app.ts": 20,
+  "server.ts": 20,
+  "cli.ts": 15,
+  "main.py": 20,
+  "main.rs": 20,
+  "main.go": 20,
+  "mod.rs": 15,
+  "lib.rs": 15,
+  "index.js": 20,
+  "main.js": 20
+};
+function rankFiles(files, taskDescription, options = {}) {
+  const {
+    boostSource = true,
+    boostRecent = true,
+    boostShallow = true,
+    boostConfig = true,
+    recentHours = 48
+  } = options;
+  const taskTokens = taskDescription ? taskDescription.toLowerCase().split(/[\s_-]+/).filter((w) => w.length > 2) : [];
+  const now = Date.now();
+  const recentCutoff = now - recentHours * 60 * 60 * 1e3;
+  const results = files.map((file) => {
+    let score = 0;
+    const reasons = [];
+    const basename6 = path5.basename(file.path);
+    score += CATEGORY_WEIGHTS[file.category] || 10;
+    reasons.push(`category:${file.category}=${CATEGORY_WEIGHTS[file.category] || 10}`);
+    if (boostSource && file.category === "source") {
+      const extBoost = EXTENSION_BOOSTS[file.extension] || 0;
+      if (extBoost > 0) {
+        score += extBoost;
+        reasons.push(`ext-boost:${file.extension}=${extBoost}`);
+      }
+    }
+    if (IMPORTANT_FILES[basename6] !== void 0) {
+      score += IMPORTANT_FILES[basename6];
+      reasons.push(`important-file:${basename6}=${IMPORTANT_FILES[basename6]}`);
+    }
+    if (boostConfig && file.category === "config") {
+      score += 15;
+      reasons.push("config-boost=15");
+    }
+    if (boostRecent && file.modifiedAt.getTime() > recentCutoff) {
+      const recencyBoost = 20;
+      score += recencyBoost;
+      reasons.push(`recently-modified=${recencyBoost}`);
+    }
+    if (boostShallow) {
+      const depth = file.relativePath.split("/").length;
+      const depthBoost = Math.max(0, 20 - depth * 2);
+      score += depthBoost;
+      if (depthBoost > 0) reasons.push(`shallow-depth=${depthBoost}`);
+    }
+    if (file.size < 100) {
+      score -= 5;
+      reasons.push("small-file=-5");
+    }
+    if (file.size > 5e5) {
+      score -= 10;
+      reasons.push("large-file=-10");
+    }
+    if (taskTokens.length > 0) {
+      const lowerPath = file.relativePath.toLowerCase();
+      const lowerName = basename6.toLowerCase();
+      let taskMatchScore = 0;
+      for (const token of taskTokens) {
+        if (lowerName.includes(token)) taskMatchScore += 15;
+        if (lowerPath.includes(token)) taskMatchScore += 8;
+      }
+      if (taskMatchScore > 0) {
+        score += taskMatchScore;
+        reasons.push(`task-match=${taskMatchScore}`);
+      }
+    }
+    return { ...file, rankScore: score, rankReasons: reasons };
+  });
+  results.sort((a, b) => b.rankScore - a.rankScore);
+  return results;
+}
+function printRankedFiles(ranked) {
+  const lines = [""];
+  lines.push(chalk2.bold("  File Context Rankings"));
+  const maxScore = ranked.length > 0 ? ranked[0].rankScore : 1;
+  for (const file of ranked) {
+    const barLength = Math.round(file.rankScore / maxScore * 20);
+    const bar = chalk2.cyan("\u2588".repeat(barLength)) + chalk2.dim("\u2591".repeat(20 - barLength));
+    const pct = Math.round(file.rankScore / maxScore * 100);
+    lines.push(`  ${chalk2.dim(file.relativePath)}`);
+    lines.push(`  ${bar} ${chalk2.bold(String(file.rankScore))} ${chalk2.dim(`(${pct}%)`)}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/editor/patch.ts
+import * as fs5 from "fs";
+import chalk3 from "chalk";
+function generateDiff(oldLines, newLines) {
+  const result = [];
+  const maxLen = Math.max(oldLines.length, newLines.length);
+  let hasChanges = false;
+  for (let i = 0; i < maxLen; i++) {
+    const oldLine = i < oldLines.length ? oldLines[i] : void 0;
+    const newLine = i < newLines.length ? newLines[i] : void 0;
+    if (oldLine === newLine) {
+      result.push(`  ${oldLine}`);
+    } else {
+      hasChanges = true;
+      if (oldLine !== void 0) {
+        result.push(chalk3.red(`- ${oldLine}`));
+      }
+      if (newLine !== void 0) {
+        result.push(chalk3.green(`+ ${newLine}`));
+      }
+    }
+  }
+  if (!hasChanges) return "(no changes)";
+  return result.join("\n");
+}
+function applyInlinePatch(filePath, searchBlock, replaceBlock) {
+  try {
+    if (!fs5.existsSync(filePath)) {
+      return { success: false, applied: false, output: "", error: `File not found: ${filePath}` };
+    }
+    const content = fs5.readFileSync(filePath, "utf-8");
+    const searchNormalized = searchBlock.trim();
+    const contentNormalized = content;
+    const idx = contentNormalized.indexOf(searchNormalized);
+    if (idx === -1) {
+      return {
+        success: false,
+        applied: false,
+        output: "",
+        error: "Search block not found in file. The context may have changed."
+      };
+    }
+    const before = contentNormalized.slice(0, idx);
+    const after = contentNormalized.slice(idx + searchNormalized.length);
+    const newContent = before + replaceBlock + after;
+    const oldLines = searchBlock.split("\n");
+    const newLines = replaceBlock.split("\n");
+    const diff = generateDiff(oldLines, newLines);
+    fs5.writeFileSync(filePath, newContent, "utf-8");
+    return { success: true, applied: true, output: `Patch applied:
+${diff}` };
+  } catch (err) {
+    return { success: false, applied: false, output: "", error: String(err) };
+  }
+}
+
+// src/editor/ast.ts
+var PAIR_MATCH = {
+  "{": "}",
+  "[": "]",
+  "(": ")"
+};
+var OPENERS = new Set(Object.keys(PAIR_MATCH));
+var CLOSERS = new Set(Object.values(PAIR_MATCH));
+function checkBraceBalance(code, _filePath) {
+  const errors = [];
+  const stack = [];
+  const lines = code.split("\n");
+  let inBlockComment = false;
+  let inString = false;
+  let stringChar = "";
+  for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+    const line = lines[lineNum];
+    for (let col = 0; col < line.length; col++) {
+      const char = line[col];
+      const nextChar = line[col + 1] || "";
+      if (inBlockComment) {
+        if (char === "*" && nextChar === "/") {
+          inBlockComment = false;
+          col++;
+        }
+        continue;
+      }
+      if (inString) {
+        if (char === "\\") {
+          col++;
+          continue;
+        }
+        if (char === stringChar) {
+          inString = false;
+        }
+        continue;
+      }
+      if (char === "/" && nextChar === "*" || char === "/" && nextChar === "/") {
+        if (char === "/" && nextChar === "*") {
+          inBlockComment = true;
+          col++;
+        }
+        break;
+      }
+      if (char === "#" && (col === 0 || line[col - 1] === " " || line[col - 1] === "	")) {
+        break;
+      }
+      if (char === '"' || char === "'" || char === "`") {
+        inString = true;
+        stringChar = char;
+        continue;
+      }
+      if (OPENERS.has(char)) {
+        stack.push({ char, line: lineNum + 1, column: col + 1 });
+      } else if (CLOSERS.has(char)) {
+        const expected = Object.entries(PAIR_MATCH).find(([, v]) => v === char)?.[0];
+        if (stack.length === 0) {
+          errors.push({
+            line: lineNum + 1,
+            column: col + 1,
+            message: `Unexpected closing '${char}' without opening '${expected}'`
+          });
+        } else {
+          const last = stack[stack.length - 1];
+          if (PAIR_MATCH[last.char] !== char) {
+            errors.push({
+              line: lineNum + 1,
+              column: col + 1,
+              message: `Expected '${PAIR_MATCH[last.char]}' but found '${char}'`
+            });
+          } else {
+            stack.pop();
+          }
+        }
+      }
+    }
+  }
+  for (const remaining of stack) {
+    errors.push({
+      line: remaining.line,
+      column: remaining.column,
+      message: `Unclosed '${remaining.char}' \u2014 expected '${PAIR_MATCH[remaining.char]}'`
+    });
+  }
+  return { valid: errors.length === 0, errors };
+}
+function hasValidSyntax(code, lang) {
+  const balance = checkBraceBalance(code);
+  const ext = lang?.toLowerCase() || "";
+  if (["ts", "tsx", "js", "jsx", "rs", "go", "c", "cpp", "java", "kt"].some((e) => ext.includes(e) || ext === e)) {
+    if (!balance.valid) {
+      return false;
+    }
+  }
+  return true;
+}
+function detectLanguage(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() || "";
+  const langMap = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    py: "python",
+    rs: "rust",
+    go: "go",
+    rb: "ruby",
+    java: "java",
+    kt: "kotlin",
+    c: "c",
+    cpp: "cpp",
+    h: "c",
+    cs: "csharp",
+    php: "php",
+    swift: "swift"
+  };
+  return langMap[ext] || "unknown";
+}
+
+// src/editor/undo.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+var UNDO_DIR = ".lovecode/undo";
+function getUndoDir(rootDir) {
+  return path6.join(rootDir, UNDO_DIR);
+}
+function ensureUndoDir(rootDir) {
+  const dir = getUndoDir(rootDir);
+  fs6.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function getUndoFilePath(rootDir, id) {
+  return path6.join(getUndoDir(rootDir), `${id}.json`);
+}
+function getIndexPath(rootDir) {
+  return path6.join(getUndoDir(rootDir), "index.json");
+}
+function saveUndoPoint(rootDir, filePath, label = "edit") {
+  try {
+    if (!fs6.existsSync(filePath)) return null;
+    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const content = fs6.readFileSync(filePath, "utf-8");
+    const entry = {
+      id,
+      filePath,
+      timestamp: Date.now(),
+      originalContent: content,
+      label
+    };
+    ensureUndoDir(rootDir);
+    const entryFile = getUndoFilePath(rootDir, id);
+    fs6.writeFileSync(entryFile, JSON.stringify(entry, null, 2), "utf-8");
+    const indexPath = getIndexPath(rootDir);
+    let index = [];
+    if (fs6.existsSync(indexPath)) {
+      try {
+        index = JSON.parse(fs6.readFileSync(indexPath, "utf-8"));
+      } catch {
+        index = [];
+      }
+    }
+    index.unshift(entry);
+    if (index.length > 100) index = index.slice(0, 100);
+    fs6.writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf-8");
+    return entry;
+  } catch {
+    return null;
+  }
+}
+function undoLast(rootDir, filePath) {
+  try {
+    const indexPath = getIndexPath(rootDir);
+    if (!fs6.existsSync(indexPath)) return null;
+    const index = JSON.parse(fs6.readFileSync(indexPath, "utf-8"));
+    const targetIdx = filePath ? index.findIndex((e) => e.filePath === filePath) : 0;
+    if (targetIdx === -1) return null;
+    const entry = index[targetIdx];
+    if (!fs6.existsSync(entry.filePath)) {
+      index.splice(targetIdx, 1);
+      fs6.writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf-8");
+      return null;
+    }
+    fs6.writeFileSync(entry.filePath, entry.originalContent, "utf-8");
+    index.splice(targetIdx, 1);
+    fs6.writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf-8");
+    const entryFile = getUndoFilePath(rootDir, entry.id);
+    if (fs6.existsSync(entryFile)) fs6.unlinkSync(entryFile);
+    return entry;
+  } catch {
+    return null;
+  }
+}
+function getUndoHistory(rootDir) {
+  try {
+    const indexPath = getIndexPath(rootDir);
+    if (!fs6.existsSync(indexPath)) return [];
+    return JSON.parse(fs6.readFileSync(indexPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function undoForFile(rootDir, filePath) {
+  return undoLast(rootDir, filePath);
+}
+
+// src/editor/snapshot.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+var SNAPSHOT_DIR = ".lovecode/snapshots";
+function getSnapshotDir(rootDir) {
+  return path7.join(rootDir, SNAPSHOT_DIR);
+}
+function ensureSnapshotDir(rootDir) {
+  const dir = getSnapshotDir(rootDir);
+  fs7.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function createSnapshot(rootDir, filePath, label = "") {
+  try {
+    if (!fs7.existsSync(filePath)) return null;
+    const content = fs7.readFileSync(filePath, "utf-8");
+    const relativePath = path7.relative(rootDir, filePath).replace(/\\/g, "/");
+    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const snapshotDir = ensureSnapshotDir(rootDir);
+    const snapshot = {
+      id,
+      filePath,
+      relativePath,
+      timestamp: Date.now(),
+      label,
+      size: content.length
+    };
+    fs7.writeFileSync(path7.join(snapshotDir, `${id}.snap`), content, "utf-8");
+    fs7.writeFileSync(path7.join(snapshotDir, `${id}.meta`), JSON.stringify(snapshot, null, 2), "utf-8");
+    return snapshot;
+  } catch {
+    return null;
+  }
+}
+function restoreSnapshot(rootDir, id) {
+  try {
+    const snapshotDir = getSnapshotDir(rootDir);
+    const metaPath = path7.join(snapshotDir, `${id}.meta`);
+    const snapPath = path7.join(snapshotDir, `${id}.snap`);
+    if (!fs7.existsSync(metaPath) || !fs7.existsSync(snapPath)) return false;
+    const meta = JSON.parse(fs7.readFileSync(metaPath, "utf-8"));
+    const content = fs7.readFileSync(snapPath, "utf-8");
+    if (fs7.existsSync(meta.filePath)) {
+      fs7.writeFileSync(meta.filePath, content, "utf-8");
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listSnapshots(rootDir) {
+  try {
+    const snapshotDir = getSnapshotDir(rootDir);
+    if (!fs7.existsSync(snapshotDir)) return [];
+    const files = fs7.readdirSync(snapshotDir);
+    const metaFiles = files.filter((f) => f.endsWith(".meta"));
+    const snapshots = [];
+    for (const metaFile of metaFiles) {
+      try {
+        const meta = JSON.parse(fs7.readFileSync(path7.join(snapshotDir, metaFile), "utf-8"));
+        snapshots.push(meta);
+      } catch {
+      }
+    }
+    snapshots.sort((a, b) => b.timestamp - a.timestamp);
+    return snapshots;
+  } catch {
+    return [];
+  }
+}
+function createBatchSnapshot(rootDir, filePaths, label = "batch") {
+  const snapshots = [];
+  for (const fp of filePaths) {
+    const snap = createSnapshot(rootDir, fp, label);
+    if (snap) snapshots.push(snap);
+  }
+  return snapshots;
+}
+
+// src/editor/refactor.ts
+import * as fs8 from "fs";
+import chalk4 from "chalk";
+async function executeRefactor(plan) {
+  const snapshots = [];
+  const errors = [];
+  let applied = 0;
+  const filesToSnapshot = [...new Set(plan.edits.map((e) => e.filePath))];
+  const batchSnaps = createBatchSnapshot(plan.rootDir, filesToSnapshot, "refactor");
+  snapshots.push(...batchSnaps);
+  for (const edit of plan.edits) {
+    const result = applyInlinePatch(edit.filePath, edit.search, edit.replace);
+    if (result.success && result.applied) {
+      if (plan.validateSyntax) {
+        try {
+          const content = fs8.readFileSync(edit.filePath, "utf-8");
+          const lang = detectLanguage(edit.filePath);
+          if (!hasValidSyntax(content, lang)) {
+            errors.push({
+              filePath: edit.filePath,
+              error: "Syntax validation failed after edit. Use undo or snapshot to revert."
+            });
+          }
+        } catch {
+        }
+      }
+      applied++;
+    } else {
+      errors.push({
+        filePath: edit.filePath,
+        error: result.error || "Patch failed to apply"
+      });
+    }
+  }
+  const total = plan.edits.length;
+  const allSuccess = errors.length === 0;
+  const successCount = applied;
+  const output = [
+    chalk4.bold("\n  Refactor Summary"),
+    chalk4.dim(`  ${successCount}/${total} edits applied`),
+    ...snapshots.length > 0 ? [chalk4.dim(`  Snapshots: ${snapshots.length} created`)] : [],
+    ...errors.map((e) => chalk4.red(`  \u2717 ${e.filePath}: ${e.error}`)),
+    allSuccess ? chalk4.green("  \u2713 All edits applied successfully\n") : ""
+  ].filter(Boolean).join("\n");
+  return {
+    success: allSuccess,
+    applied: successCount,
+    failed: errors.length,
+    snapshots,
+    errors,
+    output
+  };
+}
+function planRefactor(edits, rootDir, validateSyntax = true) {
+  return { edits, rootDir, validateSyntax };
+}
+
+// src/shell/executor.ts
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+
+// src/core/approval.ts
+import * as readline from "readline";
+import chalk6 from "chalk";
+
+// src/core/modes.ts
+import chalk5 from "chalk";
+var modeConfigs = {
+  assist: {
+    label: "Assist",
+    icon: "\u{1F3AF}",
+    description: "User controls every step \u2014 you approve each action before execution",
+    color: (t) => chalk5.blue(t),
+    autoApproveSafe: false,
+    autoApproveWarning: false,
+    maxRetries: 1,
+    maxSteps: 15
+  },
+  smart: {
+    label: "Smart",
+    icon: "\u{1F9E0}",
+    description: "Semi-autonomous \u2014 safe actions run auto, warnings ask approval, dangerous blocked",
+    color: (t) => chalk5.yellow(t),
+    autoApproveSafe: true,
+    autoApproveWarning: false,
+    maxRetries: 3,
+    maxSteps: 30
+  },
+  yolo: {
+    label: "YOLO",
+    icon: "\u{1F680}",
+    description: "Full autonomy \u2014 all actions execute without user intervention",
+    color: (t) => chalk5.magenta(t),
+    autoApproveSafe: true,
+    autoApproveWarning: true,
+    maxRetries: 5,
+    maxSteps: 50
+  }
+};
+function getModeConfig(mode) {
+  return modeConfigs[mode];
+}
+function createContext(mode, workingDir) {
+  const cfg = modeConfigs[mode];
+  return {
+    mode,
+    workingDir,
+    maxRetries: cfg.maxRetries,
+    maxSteps: cfg.maxSteps
+  };
+}
+function listModes() {
+  return Object.entries(modeConfigs).map(([, cfg]) => `  ${cfg.color(`${cfg.icon} ${cfg.label}`.padEnd(15))} ${chalk5.dim(cfg.description)}`).join("\n");
+}
+
+// src/core/approval.ts
+var dangerousPatterns = [
+  /^rm\s+-rf\s+(\/|\/\w+|\.)/,
+  /^sudo\s+/,
+  /^chmod\s+777/,
+  /^dd\s+/,
+  /^mkfs/,
+  /^fdisk/,
+  /^>\/dev/,
+  /^:\(\)\s*{/,
+  /^wget\s+.*\||^curl\s+.*\|/,
+  /^eval\s+/,
+  /^exec\s+/
+];
+var warningPatterns = [
+  /^rm\s+/,
+  /^chmod\s+/,
+  /^chown\s+/,
+  /^mv\s+/,
+  /^cp\s+/,
+  /^kill\s+/,
+  /^pkill\s+/,
+  /^systemctl/,
+  /^service/,
+  /^apt\s+(install|remove|purge)/,
+  /^npm\s+(install|uninstall|publish)/,
+  /^pip\s+(install|uninstall)/,
+  /^docker\s+(rm|rmi|kill|stop)/,
+  /^git\s+push/,
+  /^git\s+reset/,
+  /^git\s+revert/,
+  /^git\s+merge/,
+  /^git\s+rebase/,
+  /^gh\s+/
+];
+function classifyCommand(command) {
+  const trimmed = command.trim();
+  for (const pattern of dangerousPatterns) {
+    if (pattern.test(trimmed)) return "dangerous";
+  }
+  for (const pattern of warningPatterns) {
+    if (pattern.test(trimmed)) return "warning";
+  }
+  return "safe";
+}
+function classifyTool(toolName, args) {
+  if (toolName === "execute_command" && args?.command) {
+    return classifyCommand(args.command);
+  }
+  const safeTools = /* @__PURE__ */ new Set(["read_file", "grep_search", "glob_search", "list_dir", "get_cwd"]);
+  const warningTools = /* @__PURE__ */ new Set(["write_file", "edit_file", "create_file", "append_file"]);
+  const dangerousTools = /* @__PURE__ */ new Set(["delete_file", "delete_dir", "overwrite_dir"]);
+  if (safeTools.has(toolName)) return "safe";
+  if (dangerousTools.has(toolName)) return "dangerous";
+  if (warningTools.has(toolName)) return "warning";
+  return "warning";
+}
+function askApproval(description, toolName, level) {
+  return new Promise((resolve3) => {
+    const label = level === "dangerous" ? chalk6.bgRed.white(" DANGEROUS ") : chalk6.bgYellow.black(" WARNING ");
+    console.log(`
+  ${label} ${chalk6.dim(toolName)}: ${description}`);
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(chalk6.dim("  Allow? (y/N): "), (answer) => {
+      rl.close();
+      const allowed = answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+      if (allowed) {
+        console.log(chalk6.green("  \u2713 Approved\n"));
+      } else {
+        console.log(chalk6.yellow("  \u2717 Skipped\n"));
+      }
+      resolve3(allowed);
+    });
+  });
+}
+async function getApproval(mode, toolName, description, args) {
+  const level = classifyTool(toolName, args);
+  const config = getModeConfig(mode);
+  if (level === "dangerous") {
+    if (mode === "yolo") {
+      console.log(chalk6.bgRed.white(`  ${toolName}: ${description}`));
+      if (!config.autoApproveWarning) {
+        const allowed2 = await askApproval(description, toolName, level);
+        return { allowed: allowed2, reason: allowed2 ? "approved by user" : "blocked by user" };
+      }
+      return { allowed: true, reason: "yolo mode" };
+    }
+    console.log(chalk6.bgRed.white(`  BLOCKED: ${toolName} - ${description}`));
+    console.log(chalk6.dim("  This action is classified as dangerous.\n"));
+    return { allowed: false, reason: "dangerous action blocked" };
+  }
+  if (level === "warning") {
+    if (config.autoApproveWarning) {
+      console.log(chalk6.green(`  \u2713 ${toolName}: ${chalk6.dim(description)}`));
+      return { allowed: true, reason: `${mode} mode auto-approve` };
+    }
+    const allowed2 = await askApproval(description, toolName, level);
+    return { allowed: allowed2, reason: allowed2 ? "approved by user" : "skipped by user" };
+  }
+  if (config.autoApproveSafe) {
+    return { allowed: true, reason: `${mode} mode auto-approve` };
+  }
+  const allowed = await askApproval(description, toolName, level);
+  return { allowed, reason: allowed ? "approved by user" : "skipped by user" };
+}
+
+// src/shell/executor.ts
+var CommandExecutor = class extends EventEmitter {
+  process = null;
+  aborted = false;
+  stdoutBuffer = "";
+  stderrBuffer = "";
+  startTime = 0;
+  cwd;
+  constructor(cwd = process.cwd()) {
+    super();
+    this.cwd = cwd;
+  }
+  async execute(options) {
+    const { command, timeout = 12e4, env, signal } = options;
+    this.aborted = false;
+    this.stdoutBuffer = "";
+    this.stderrBuffer = "";
+    this.startTime = Date.now();
+    const isDangerous = classifyCommand(command);
+    if (isDangerous === "dangerous") {
+      return {
+        success: false,
+        exitCode: null,
+        stdout: "",
+        stderr: "Command blocked by sandbox: classified as dangerous",
+        duration: 0,
+        cancelled: false
+      };
+    }
+    return new Promise((resolve3) => {
+      const shell = process.platform === "win32" ? "cmd.exe" : "/bin/bash";
+      const shellFlag = process.platform === "win32" ? "/c" : "-c";
+      try {
+        this.process = spawn(shell, [shellFlag, command], {
+          cwd: this.cwd,
+          env: { ...process.env, ...env, FORCE_COLOR: "1" },
+          stdio: ["pipe", "pipe", "pipe"],
+          signal
+        });
+      } catch (err) {
+        resolve3({
+          success: false,
+          exitCode: null,
+          stdout: "",
+          stderr: String(err),
+          duration: 0,
+          cancelled: false
+        });
+        return;
+      }
+      const timer = setTimeout(() => {
+        this.kill();
+        resolve3({
+          success: false,
+          exitCode: null,
+          stdout: this.stdoutBuffer,
+          stderr: this.stderrBuffer + "\n[Timeout] Command timed out",
+          duration: Date.now() - this.startTime,
+          cancelled: true
+        });
+      }, timeout);
+      this.process.stdout?.on("data", (data) => {
+        const text = data.toString();
+        this.stdoutBuffer += text;
+        options.onStdout?.(text);
+        this.emit("stdout", text);
+      });
+      this.process.stderr?.on("data", (data) => {
+        const text = data.toString();
+        this.stderrBuffer += text;
+        options.onStderr?.(text);
+        this.emit("stderr", text);
+      });
+      this.process.on("exit", (exitCode) => {
+        clearTimeout(timer);
+        const duration = Date.now() - this.startTime;
+        options.onExit?.(exitCode);
+        this.emit("exit", exitCode);
+        resolve3({
+          success: exitCode === 0 && !this.aborted,
+          exitCode,
+          stdout: this.stdoutBuffer,
+          stderr: this.stderrBuffer,
+          duration,
+          cancelled: this.aborted
+        });
+      });
+      this.process.on("error", (err) => {
+        clearTimeout(timer);
+        this.emit("error", err);
+        resolve3({
+          success: false,
+          exitCode: null,
+          stdout: this.stdoutBuffer,
+          stderr: String(err),
+          duration: Date.now() - this.startTime,
+          cancelled: this.aborted
+        });
+      });
+    });
+  }
+  kill() {
+    this.aborted = true;
+    if (this.process && !this.process.killed) {
+      if (process.platform === "win32") {
+        spawn("taskkill", ["/pid", String(this.process.pid), "/f", "/t"]);
+      } else {
+        this.process.kill("SIGTERM");
+        setTimeout(() => {
+          if (this.process && !this.process.killed) {
+            this.process.kill("SIGKILL");
+          }
+        }, 3e3);
+      }
+    }
+  }
+  get isRunning() {
+    return this.process !== null && !this.process.killed;
+  }
+};
+function execCommand(command, cwd = process.cwd(), timeout = 12e4) {
+  const executor = new CommandExecutor(cwd);
+  return executor.execute({ command, cwd, timeout });
+}
+
+// src/shell/stream.ts
+import chalk7 from "chalk";
+
+// src/shell/interactive.ts
+import { spawn as spawn2 } from "child_process";
+import * as readline2 from "readline";
+import chalk8 from "chalk";
+
+// src/shell/sandbox.ts
+import chalk9 from "chalk";
+var SAFE_PREFIXES = [
+  "npm",
+  "node",
+  "npx",
+  "yarn",
+  "pnpm",
+  "bun",
+  "python",
+  "python3",
+  "pip",
+  "pip3",
+  "go",
+  "cargo",
+  "rustc",
+  "tsc",
+  "eslint",
+  "prettier",
+  "git",
+  "ls",
+  "cat",
+  "head",
+  "tail",
+  "wc",
+  "sort",
+  "uniq",
+  "echo",
+  "printf",
+  "grep",
+  "rg",
+  "ag",
+  "ack",
+  "find",
+  "tree",
+  "pwd",
+  "which",
+  "whoami",
+  "curl",
+  "wget",
+  "mkdir",
+  "touch",
+  "cp",
+  "mv",
+  "docker",
+  "docker-compose",
+  "make",
+  "cmake",
+  "jq",
+  "yq",
+  "diff",
+  "patch",
+  "test",
+  "["
+];
+var DEFAULT_BLOCKED = [
+  /^rm\s+-rf\s+(\/|\/\w+)/,
+  /^sudo\s+/,
+  /^su\s+/,
+  /^chmod\s+777/,
+  /^dd\s+/,
+  /^mkfs/,
+  /^fdisk/,
+  /^:\(\)/,
+  /^eval\s+/,
+  /^exec\s+/,
+  /^kill\s+-9/,
+  /^>\/dev\/sda/
+];
+var DEFAULT_ALLOWED = [
+  /^npm\s+(install|run|test|build|start|add|remove|update)/,
+  /^node\s+/,
+  /^npx\s+/,
+  /^yarn\s+/,
+  /^python3?\s+/,
+  /^pip3?\s+(install|list|show)/,
+  /^go\s+(build|run|test|mod|fmt)/,
+  /^cargo\s+(build|run|test|check|add)/,
+  /^rustc\s+/,
+  /^tsc\s*/,
+  /^eslint\s+/,
+  /^prettier\s+/,
+  /^git\s+(status|log|diff|show|add|commit|push|pull|branch|checkout|stash|init|clone)/,
+  /^ls\s*/,
+  /^cat\s+/,
+  /^head\s+/,
+  /^tail\s+/,
+  /^grep\s+/,
+  /^rg\s+/,
+  /^find\s+/,
+  /^echo\s+/,
+  /^printf\s+/,
+  /^pwd\s*/,
+  /^which\s+/,
+  /^mkdir\s+/,
+  /^touch\s+/,
+  /^cp\s+/,
+  /^mv\s+/,
+  /^rm\s+(?!-rf\s+\/)/,
+  /^diff\s+/,
+  /^jq\s+/,
+  /^make\s+/,
+  /^docker\s+(ps|images|build|run|compose)/,
+  /^curl\s+/,
+  /^wget\s+/
+];
+function createDefaultPolicy() {
+  return {
+    allowCommands: DEFAULT_ALLOWED,
+    blockCommands: DEFAULT_BLOCKED,
+    allowNetwork: true,
+    allowFileWrite: true,
+    maxProcessTime: 3e5,
+    allowedPrefixes: SAFE_PREFIXES
+  };
+}
+function evaluateCommand(command, policy) {
+  const p = policy || createDefaultPolicy();
+  const trimmed = command.trim();
+  for (const block of p.blockCommands) {
+    if (block.test(trimmed)) {
+      return {
+        allowed: false,
+        reason: `Command matches blocked pattern: ${block}`,
+        risk: "blocked"
+      };
+    }
+  }
+  for (const allow of p.allowCommands) {
+    if (allow.test(trimmed)) {
+      return {
+        allowed: true,
+        reason: "Command matches allowed pattern",
+        risk: "safe"
+      };
+    }
+  }
+  const firstWord = trimmed.split(/\s+/)[0]?.toLowerCase();
+  if (p.allowedPrefixes.includes(firstWord)) {
+    return {
+      allowed: true,
+      reason: `Command prefix "${firstWord}" is in safe list`,
+      risk: "low"
+    };
+  }
+  return {
+    allowed: false,
+    reason: `Command "${trimmed.slice(0, 50)}..." is not in the allowed list`,
+    risk: "blocked"
+  };
+}
+function printSandboxVerdict(verdict) {
+  const labels = {
+    safe: chalk9.green("SAFE"),
+    low: chalk9.cyan("LOW RISK"),
+    medium: chalk9.yellow("MEDIUM RISK"),
+    high: chalk9.red("HIGH RISK"),
+    blocked: chalk9.bgRed.white(" BLOCKED ")
+  };
+  return `  ${labels[verdict.risk] || chalk9.dim("UNKNOWN")} ${chalk9.dim(verdict.reason)}`;
+}
+
+// src/repo/detect.ts
+import * as fs9 from "fs";
+import * as path8 from "path";
+import chalk10 from "chalk";
+var rules = [
+  {
+    name: "Next.js",
+    icon: "\u25B2",
+    language: "TypeScript",
+    check: (dir) => {
+      const evidence = [];
+      if (fs9.existsSync(path8.join(dir, "next.config.js")) || fs9.existsSync(path8.join(dir, "next.config.mjs"))) {
+        evidence.push("next.config.{js,mjs}");
+      }
+      const pkg = readJson(path8.join(dir, "package.json"));
+      if (pkg?.dependencies?.next || pkg?.devDependencies?.next) {
+        evidence.push("package.json: next dependency");
+      }
+      return { detected: evidence.length > 0, confidence: evidence.length >= 2 ? 95 : 70, evidence };
+    }
+  },
+  {
+    name: "React",
+    icon: "\u269B",
+    language: "TypeScript/JavaScript",
+    check: (dir) => {
+      const evidence = [];
+      const pkg = readJson(path8.join(dir, "package.json"));
+      if (pkg?.dependencies?.react) evidence.push("package.json: react dependency");
+      if (fs9.existsSync(path8.join(dir, "jsconfig.json"))) evidence.push("jsconfig.json");
+      if (findFiles2(dir, ".jsx", 3).length > 0) evidence.push(".jsx files found");
+      if (findFiles2(dir, ".tsx", 3).length > 0) evidence.push(".tsx files found");
+      return { detected: evidence.length > 0, confidence: Math.min(evidence.length * 30, 95), evidence };
+    }
+  },
+  {
+    name: "Node.js",
+    icon: "\u25CF",
+    language: "JavaScript",
+    check: (dir) => {
+      const evidence = [];
+      if (fs9.existsSync(path8.join(dir, "package.json"))) evidence.push("package.json");
+      if (fs9.existsSync(path8.join(dir, "package-lock.json"))) evidence.push("package-lock.json");
+      const pkg = readJson(path8.join(dir, "package.json"));
+      if (pkg && !pkg?.dependencies?.react && !pkg?.dependencies?.next) {
+        evidence.push("Node.js package (no React/Next)");
+      }
+      return { detected: evidence.length > 0, confidence: Math.min(evidence.length * 35, 90), evidence };
+    }
+  },
+  {
+    name: "Go",
+    icon: "\u{1F537}",
+    language: "Go",
+    check: (dir) => {
+      const evidence = [];
+      if (fs9.existsSync(path8.join(dir, "go.mod"))) evidence.push("go.mod");
+      if (fs9.existsSync(path8.join(dir, "go.sum"))) evidence.push("go.sum");
+      if (findFiles2(dir, ".go", 3).length > 0) evidence.push(".go files found");
+      return { detected: evidence.length > 0, confidence: evidence.includes("go.mod") ? 98 : 60, evidence };
+    }
+  },
+  {
+    name: "Django",
+    icon: "\u{1F3AF}",
+    language: "Python",
+    check: (dir) => {
+      const evidence = [];
+      if (fs9.existsSync(path8.join(dir, "manage.py"))) evidence.push("manage.py");
+      if (findFiles2(dir, "settings.py", 5).length > 0) evidence.push("settings.py found");
+      const cfg = readFile(path8.join(dir, "requirements.txt"));
+      if (cfg?.includes("django")) evidence.push("requirements.txt: django");
+      const pipfile = readFile(path8.join(dir, "Pipfile"));
+      if (pipfile?.includes("django")) evidence.push("Pipfile: django");
+      return { detected: evidence.length > 0, confidence: evidence.includes("manage.py") ? 95 : 50, evidence };
+    }
+  },
+  {
+    name: "Flutter",
+    icon: "\u{1F7E6}",
+    language: "Dart",
+    check: (dir) => {
+      const evidence = [];
+      if (fs9.existsSync(path8.join(dir, "pubspec.yaml"))) evidence.push("pubspec.yaml");
+      if (findFiles2(dir, ".dart", 3).length > 0) evidence.push(".dart files found");
+      if (fs9.existsSync(path8.join(dir, "android")) && fs9.existsSync(path8.join(dir, "ios"))) {
+        evidence.push("android/ & ios/ directories");
+      }
+      return { detected: evidence.length > 0, confidence: evidence.includes("pubspec.yaml") ? 95 : 50, evidence };
+    }
+  },
+  {
+    name: "Python",
+    icon: "\u{1F40D}",
+    language: "Python",
+    check: (dir) => {
+      const evidence = [];
+      if (fs9.existsSync(path8.join(dir, "requirements.txt"))) evidence.push("requirements.txt");
+      if (fs9.existsSync(path8.join(dir, "setup.py"))) evidence.push("setup.py");
+      if (fs9.existsSync(path8.join(dir, "pyproject.toml"))) evidence.push("pyproject.toml");
+      if (findFiles2(dir, ".py", 5).length > 0) evidence.push(".py files found");
+      return { detected: evidence.length > 0, confidence: Math.min(evidence.length * 25, 90), evidence };
+    }
+  },
+  {
+    name: "Rust",
+    icon: "\u{1F980}",
+    language: "Rust",
+    check: (dir) => {
+      const evidence = [];
+      if (fs9.existsSync(path8.join(dir, "Cargo.toml"))) evidence.push("Cargo.toml");
+      if (fs9.existsSync(path8.join(dir, "Cargo.lock"))) evidence.push("Cargo.lock");
+      if (findFiles2(dir, ".rs", 3).length > 0) evidence.push(".rs files found");
+      return { detected: evidence.length > 0, confidence: evidence.includes("Cargo.toml") ? 98 : 60, evidence };
+    }
+  },
+  {
+    name: "Vue.js",
+    icon: "\u{1F49A}",
+    language: "JavaScript",
+    check: (dir) => {
+      const evidence = [];
+      const pkg = readJson(path8.join(dir, "package.json"));
+      if (pkg?.dependencies?.vue) evidence.push("package.json: vue");
+      if (findFiles2(dir, ".vue", 3).length > 0) evidence.push(".vue files found");
+      return { detected: evidence.length > 0, confidence: Math.min(evidence.length * 40, 90), evidence };
+    }
+  },
+  {
+    name: "Angular",
+    icon: "\u{1F53A}",
+    language: "TypeScript",
+    check: (dir) => {
+      const evidence = [];
+      if (fs9.existsSync(path8.join(dir, "angular.json"))) evidence.push("angular.json");
+      const pkg = readJson(path8.join(dir, "package.json"));
+      if (pkg?.dependencies?.["@angular/core"]) evidence.push("package.json: @angular/core");
+      return { detected: evidence.length > 0, confidence: Math.min(evidence.length * 40, 95), evidence };
+    }
+  }
+];
+function readJson(filePath) {
+  try {
+    const content = fs9.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function readFile(filePath) {
+  try {
+    return fs9.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function findFiles2(dir, ext, max) {
+  const results = [];
+  try {
+    const entries = fs9.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (results.length >= max) break;
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const fullPath = path8.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findFiles2(fullPath, ext, max - results.length));
+      } else if (entry.name.endsWith(ext)) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function detectProject(rootDir) {
+  const types = [];
+  for (const rule of rules) {
+    const result = rule.check(rootDir);
+    if (result.detected) {
+      types.push({
+        name: rule.name,
+        icon: rule.icon,
+        confidence: result.confidence,
+        language: rule.language,
+        detectedBy: result.evidence,
+        configFiles: result.evidence
+      });
+    }
+  }
+  types.sort((a, b) => b.confidence - a.confidence);
+  const languages = [...new Set(types.map((t) => t.language))];
+  const primary = types[0] || null;
+  const pkg = readJson(path8.join(rootDir, "package.json"));
+  let packageManager = null;
+  if (fs9.existsSync(path8.join(rootDir, "yarn.lock"))) packageManager = "yarn";
+  else if (fs9.existsSync(path8.join(rootDir, "pnpm-lock.yaml"))) packageManager = "pnpm";
+  else if (fs9.existsSync(path8.join(rootDir, "package-lock.json"))) packageManager = "npm";
+  else if (fs9.existsSync(path8.join(rootDir, "bun.lockb"))) packageManager = "bun";
+  let buildTool = null;
+  if (pkg?.scripts) {
+    const scripts = pkg.scripts;
+    if (scripts.build) {
+      if (scripts.build.includes("webpack")) buildTool = "webpack";
+      else if (scripts.build.includes("vite")) buildTool = "vite";
+      else if (scripts.build.includes("tsc")) buildTool = "tsc";
+      else if (scripts.build.includes("next")) buildTool = "next";
+      else buildTool = "custom";
+    }
+  }
+  if (!buildTool && fs9.existsSync(path8.join(rootDir, "webpack.config.js"))) buildTool = "webpack";
+  if (!buildTool && fs9.existsSync(path8.join(rootDir, "vite.config.ts"))) buildTool = "vite";
+  if (!buildTool && fs9.existsSync(path8.join(rootDir, "tsconfig.json"))) buildTool = "tsc";
+  return { types, primary, languages, packageManager, buildTool };
+}
+function printProjectInfo(info) {
+  const lines = [chalk10.bold("\n  Project Detection")];
+  if (info.primary) {
+    lines.push(`  ${info.primary.icon} ${chalk10.cyan(info.primary.name)} ${chalk10.dim(`(${info.primary.confidence}% confidence)`)}`);
+    lines.push(`  ${chalk10.dim("  Language:")} ${info.languages.join(", ")}`);
+  }
+  if (info.types.length > 0) {
+    lines.push(chalk10.dim("\n  All detected:"));
+    for (const t of info.types) {
+      const bar = confidenceBar(t.confidence);
+      lines.push(`  ${t.icon} ${chalk10.cyan(t.name.padEnd(12))} ${bar} ${chalk10.dim(`${t.confidence}%`)}`);
+    }
+  } else {
+    lines.push(chalk10.yellow("\n  No known project types detected."));
+  }
+  if (info.packageManager) {
+    lines.push(`
+  Package Manager: ${chalk10.cyan(info.packageManager)}`);
+  }
+  if (info.buildTool) {
+    lines.push(`  Build Tool: ${chalk10.cyan(info.buildTool)}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function confidenceBar(pct) {
+  const filled = Math.round(pct / 10);
+  const empty = 10 - filled;
+  return chalk10.green("\u2588".repeat(filled)) + chalk10.dim("\u2591".repeat(empty));
+}
+
+// src/repo/deps.ts
+import * as fs10 from "fs";
+import * as path9 from "path";
+import chalk11 from "chalk";
+var IMPORT_PATTERNS = [
+  { regex: /import\s+(?:\*\s+as\s+\w+\s+from\s+)?['"]([^'"]+)['"]/g, type: "import" },
+  { regex: /import\s+(\w+(?:\s*,\s*\w+)?)\s+from\s+['"]([^'"]+)['"]/g, type: "import" },
+  { regex: /import\s+type\s+.*?from\s+['"]([^'"]+)['"]/g, type: "import" },
+  { regex: /from\s+['"]([^'"]+)['"]/g, type: "import" },
+  { regex: /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g, type: "require" },
+  { regex: /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g, type: "dynamic" }
+];
+var PYTHON_PATTERNS = [
+  { regex: /^import\s+(\w+(?:\.\w+)*)/gm, type: "import" },
+  { regex: /^from\s+(\w+(?:\.\w+)*)\s+import/gm, type: "import" }
+];
+var GO_PATTERNS = [
+  { regex: /^import\s+\(([^)]+)\)/gms, type: "import" },
+  { regex: /^import\s+"([^"]+)"/gm, type: "import" }
+];
+var RUST_PATTERNS = [
+  { regex: /^use\s+(\w+(?:::\w+)*)/gm, type: "import" },
+  { regex: /^extern\s+crate\s+(\w+)/gm, type: "import" }
+];
+function analyzeDependencies(rootDir) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const sourceFiles = collectSourceFiles(rootDir);
+  for (const filePath of sourceFiles) {
+    const relativePath = path9.relative(rootDir, filePath).replace(/\\/g, "/");
+    const ext = path9.extname(filePath).toLowerCase();
+    let patterns = IMPORT_PATTERNS;
+    if (ext === ".py") patterns = PYTHON_PATTERNS;
+    else if (ext === ".go") patterns = GO_PATTERNS;
+    else if (ext === ".rs") patterns = RUST_PATTERNS;
+    if (!nodes.has(relativePath)) {
+      nodes.set(relativePath, {
+        name: relativePath,
+        filePath,
+        imports: [],
+        importedBy: [],
+        isExternal: false
+      });
+    }
+    try {
+      const content = fs10.readFileSync(filePath, "utf-8");
+      const imports = extractImports(content, patterns);
+      for (const imp of imports) {
+        const resolved = resolveImport(imp, relativePath, rootDir, sourceFiles);
+        edges.push({ source: relativePath, target: resolved, type: "import" });
+        nodes.get(relativePath).imports.push(imp);
+        if (!nodes.has(resolved)) {
+          const isExternal = !sourceFiles.includes(resolved) && !fs10.existsSync(resolved);
+          nodes.set(resolved, {
+            name: resolved,
+            filePath: resolved,
+            imports: [],
+            importedBy: [],
+            isExternal
+          });
+        }
+        nodes.get(resolved).importedBy.push(relativePath);
+      }
+    } catch {
+    }
+  }
+  const entryPoints = detectEntryPoints(rootDir, sourceFiles);
+  const externalDeps = [...nodes.values()].filter((n) => n.isExternal).map((n) => n.name);
+  return { nodes, edges, entryPoints, externalDeps };
+}
+function collectSourceFiles(rootDir) {
+  const results = [];
+  const skipDirs = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "__pycache__", "target", "vendor"]);
+  function walk(dir) {
+    try {
+      const entries = fs10.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || skipDirs.has(entry.name)) continue;
+        const fullPath = path9.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath);
+        } else {
+          const ext = path9.extname(entry.name).toLowerCase();
+          if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".py", ".go", ".rs", ".rb", ".java"].includes(ext)) {
+            results.push(fullPath);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  walk(rootDir);
+  return results;
+}
+function extractImports(content, patterns) {
+  const imports = [];
+  for (const { regex } of patterns) {
+    const matches = content.matchAll(regex);
+    for (const match of matches) {
+      const imp = (match[2] || match[1] || "").trim();
+      if (imp && !imp.startsWith(".") && !imp.startsWith("/")) {
+        const parts = imp.split("/");
+        imports.push(parts[0].startsWith("@") ? `${parts[0]}/${parts[1] || ""}` : parts[0]);
+      } else if (imp) {
+        imports.push(imp);
+      }
+    }
+  }
+  return [...new Set(imports)];
+}
+function resolveImport(imp, relativeFrom, rootDir, allFiles) {
+  if (imp.startsWith(".")) {
+    const dir = path9.dirname(path9.join(rootDir, relativeFrom));
+    const resolved = path9.resolve(dir, imp);
+    const extensions = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".py", ".go", ".rs", "/index.ts", "/index.js"];
+    for (const ext of extensions) {
+      const candidate = resolved + ext;
+      if (allFiles.includes(candidate)) return path9.relative(rootDir, candidate).replace(/\\/g, "/");
+    }
+    return imp;
+  }
+  return imp;
+}
+function detectEntryPoints(rootDir, files) {
+  const entries = [];
+  const entryNames = ["index.ts", "index.js", "main.ts", "main.js", "app.ts", "app.js", "server.ts", "server.js"];
+  for (const name of entryNames) {
+    const fp = path9.join(rootDir, name);
+    if (files.includes(fp)) entries.push(name);
+  }
+  if (fs10.existsSync(path9.join(rootDir, "package.json"))) {
+    try {
+      const pkg = JSON.parse(fs10.readFileSync(path9.join(rootDir, "package.json"), "utf-8"));
+      if (pkg.main) {
+        const mainPath = path9.join(rootDir, pkg.main);
+        const relative5 = path9.relative(rootDir, mainPath).replace(/\\/g, "/");
+        if (!entries.includes(relative5)) entries.push(relative5);
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function printDepGraph(graph) {
+  const lines = [chalk11.bold("\n  Dependency Analysis")];
+  lines.push(`
+  ${chalk11.dim("Source files:")} ${graph.nodes.size}`);
+  lines.push(`  ${chalk11.dim("External deps:")} ${graph.externalDeps.length}`);
+  if (graph.entryPoints.length > 0) {
+    lines.push(`
+  ${chalk11.bold("Entry Points:")}`);
+    for (const ep of graph.entryPoints) {
+      lines.push(`  ${chalk11.green("\u2192")} ${ep}`);
+    }
+  }
+  if (graph.externalDeps.length > 0) {
+    lines.push(`
+  ${chalk11.bold("External Dependencies:")}`);
+    const unique = [...new Set(graph.externalDeps)].sort();
+    for (const dep of unique.slice(0, 20)) {
+      lines.push(`  ${chalk11.cyan("\u25A0")} ${dep}`);
+    }
+    if (unique.length > 20) {
+      lines.push(`  ${chalk11.dim(`  ... and ${unique.length - 20} more`)}`);
+    }
+  }
+  const mostImported = [...graph.nodes.entries()].filter(([, n]) => n.importedBy.length > 0).sort(([, a], [, b]) => b.importedBy.length - a.importedBy.length).slice(0, 10);
+  if (mostImported.length > 0) {
+    lines.push(`
+  ${chalk11.bold("Most Imported Modules:")}`);
+    for (const [name, node] of mostImported) {
+      lines.push(`  ${chalk11.yellow("\u2605")} ${name} ${chalk11.dim(`(imported ${node.importedBy.length}x)`)}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function findCircularDeps(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  const circles = [];
+  function dfs(node, path14) {
+    visited.add(node);
+    recursionStack.add(node);
+    const nodeData = graph.nodes.get(node);
+    if (!nodeData) {
+      recursionStack.delete(node);
+      return;
+    }
+    for (const imp of nodeData.imports) {
+      const target = resolveImportInGraph(imp, node, graph);
+      if (target && graph.nodes.has(target)) {
+        if (!visited.has(target)) {
+          dfs(target, [...path14, target]);
+        } else if (recursionStack.has(target)) {
+          const cycle = [...path14.slice(path14.indexOf(target)), target];
+          circles.push(cycle);
+        }
+      }
+    }
+    recursionStack.delete(node);
+  }
+  for (const [name] of graph.nodes) {
+    if (!visited.has(name)) {
+      dfs(name, [name]);
+    }
+  }
+  return circles;
+}
+function resolveImportInGraph(imp, from, _graph) {
+  if (!imp.startsWith(".")) return null;
+  const dir = path9.dirname(from);
+  const resolved = path9.normalize(path9.join(dir, imp)).replace(/\\/g, "/");
+  return resolved;
+}
+
+// src/repo/summary.ts
+import * as fs11 from "fs";
+import * as path10 from "path";
+import chalk12 from "chalk";
+function countDirStats(dir) {
+  let files = 0;
+  let dirs = 0;
+  let totalLines = 0;
+  const languages = /* @__PURE__ */ new Map();
+  const largest = [];
+  const skipDirs = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "__pycache__", "target", "vendor", "coverage"]);
+  function walk(dir2) {
+    try {
+      const entries = fs11.readdirSync(dir2, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || skipDirs.has(entry.name)) continue;
+        const fullPath = path10.join(dir2, entry.name);
+        if (entry.isDirectory()) {
+          dirs++;
+          walk(fullPath);
+        } else {
+          files++;
+          const ext = path10.extname(entry.name).toLowerCase() || entry.name;
+          const stats = fs11.statSync(fullPath);
+          let lineCount = 0;
+          try {
+            const content = fs11.readFileSync(fullPath, "utf-8");
+            lineCount = content.split("\n").length;
+            totalLines += lineCount;
+          } catch {
+          }
+          const existing = languages.get(ext) || { files: 0, lines: 0 };
+          existing.files++;
+          existing.lines += lineCount;
+          languages.set(ext, existing);
+          largest.push({ path: fullPath, size: stats.size, lines: lineCount });
+        }
+      }
+    } catch {
+    }
+  }
+  walk(dir);
+  largest.sort((a, b) => b.size - a.size);
+  return { files, dirs, lines: totalLines, languages, largest: largest.slice(0, 10) };
+}
+function buildDirectoryTree(rootDir, maxDepth = 4) {
+  const skipDirs = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "__pycache__", "target", "vendor", "coverage"]);
+  const result = [];
+  function walk(dir, prefix, depth) {
+    if (depth > maxDepth) return;
+    try {
+      const entries = fs11.readdirSync(dir, { withFileTypes: true });
+      const filtered = entries.filter((e) => !e.name.startsWith(".") && !skipDirs.has(e.name));
+      const sorted = filtered.sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory()) return -1;
+        if (!a.isDirectory() && b.isDirectory()) return 1;
+        return a.name.localeCompare(b.name);
+      });
+      for (let i = 0; i < sorted.length; i++) {
+        const entry = sorted[i];
+        const isLast = i === sorted.length - 1;
+        const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+        const nextPrefix = isLast ? "    " : "\u2502   ";
+        if (entry.isDirectory()) {
+          result.push(`${prefix}${connector}${chalk12.cyan(entry.name)}/`);
+          walk(path10.join(dir, entry.name), prefix + nextPrefix, depth + 1);
+        } else {
+          const stats = fs11.statSync(path10.join(dir, entry.name));
+          const size = stats.size > 1024 ? `${(stats.size / 1024).toFixed(1)} KB` : `${stats.size} B`;
+          result.push(`${prefix}${connector}${entry.name} ${chalk12.dim(size)}`);
+        }
+      }
+    } catch {
+    }
+  }
+  result.push(chalk12.bold(`${path10.basename(rootDir)}/`));
+  walk(rootDir, "", 1);
+  return result.join("\n");
+}
+function languageLabel(ext) {
+  const map = {
+    ".ts": "TypeScript",
+    ".tsx": "TypeScript React",
+    ".js": "JavaScript",
+    ".jsx": "React",
+    ".py": "Python",
+    ".rs": "Rust",
+    ".go": "Go",
+    ".rb": "Ruby",
+    ".java": "Java",
+    ".kt": "Kotlin",
+    ".swift": "Swift",
+    ".c": "C",
+    ".cpp": "C++",
+    ".h": "C/C++ Header",
+    ".cs": "C#",
+    ".php": "PHP",
+    ".vue": "Vue",
+    ".svelte": "Svelte",
+    ".md": "Markdown",
+    ".json": "JSON",
+    ".yaml": "YAML",
+    ".yml": "YAML",
+    ".toml": "TOML",
+    ".html": "HTML",
+    ".css": "CSS",
+    ".scss": "SCSS"
+  };
+  return map[ext] || ext || "(unknown)";
+}
+function generateSummary(rootDir) {
+  const projectInfo = detectProject(rootDir);
+  const depGraph = analyzeDependencies(rootDir);
+  const stats = countDirStats(rootDir);
+  const directoryTree = buildDirectoryTree(rootDir);
+  return {
+    projectInfo,
+    depGraph,
+    totalFiles: stats.files,
+    totalDirs: stats.dirs,
+    totalLines: stats.lines,
+    languages: stats.languages,
+    directoryTree,
+    largestFiles: stats.largest,
+    structure: directoryTree
+  };
+}
+function printSummary(summary) {
+  const lines = [
+    chalk12.bold("\n  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"),
+    chalk12.bold("  \u2551         Repository Architecture Summary       \u2551"),
+    chalk12.bold("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"),
+    ""
+  ];
+  if (summary.projectInfo.primary) {
+    const p = summary.projectInfo.primary;
+    lines.push(`  ${p.icon} ${chalk12.bold(p.name)} ${chalk12.dim(`${p.confidence}% confidence`)}`);
+    lines.push(`  ${chalk12.dim("Language:")} ${p.language}`);
+  }
+  lines.push("");
+  lines.push(`  ${chalk12.bold("Stats")}`);
+  lines.push(`  ${chalk12.dim("Files:")}        ${summary.totalFiles}`);
+  lines.push(`  ${chalk12.dim("Directories:")}  ${summary.totalDirs}`);
+  lines.push(`  ${chalk12.dim("Lines of code:")} ${summary.totalLines.toLocaleString()}`);
+  if (summary.projectInfo.packageManager) {
+    lines.push(`  ${chalk12.dim("Package mgr:")}  ${summary.projectInfo.packageManager}`);
+  }
+  if (summary.projectInfo.buildTool) {
+    lines.push(`  ${chalk12.dim("Build tool:")}    ${summary.projectInfo.buildTool}`);
+  }
+  lines.push("");
+  lines.push(`  ${chalk12.bold("Languages")}`);
+  const sortedLangs = [...summary.languages.entries()].sort(([, a], [, b]) => b.lines - a.lines);
+  for (const [ext, info] of sortedLangs.slice(0, 10)) {
+    const label = languageLabel(ext);
+    const pct = summary.totalLines > 0 ? (info.lines / summary.totalLines * 100).toFixed(1) : "0";
+    const bar = chalk12.cyan("\u2588".repeat(Math.round(parseFloat(pct) / 5))) + chalk12.dim("\u2591".repeat(20 - Math.round(parseFloat(pct) / 5)));
+    lines.push(`  ${chalk12.cyan(label.padEnd(20))} ${bar} ${chalk12.bold(pct)}%  ${chalk12.dim(`(${info.files} files, ${info.lines.toLocaleString()} lines)`)}`);
+  }
+  if (summary.largestFiles.length > 0) {
+    lines.push("");
+    lines.push(`  ${chalk12.bold("Largest Files")}`);
+    for (const f of summary.largestFiles.slice(0, 5)) {
+      const relativePath = f.path;
+      const size = f.size > 1024 ? `${(f.size / 1024).toFixed(1)} KB` : `${f.size} B`;
+      lines.push(`  ${chalk12.dim(relativePath)} ${chalk12.yellow(size)} ${chalk12.dim(`(${f.lines} lines)`)}`);
+    }
+  }
+  if (summary.depGraph.entryPoints.length > 0) {
+    lines.push("");
+    lines.push(`  ${chalk12.bold("Entry Points")}`);
+    for (const ep of summary.depGraph.entryPoints) {
+      lines.push(`  ${chalk12.green("\u2192")} ${ep}`);
+    }
+  }
+  lines.push("");
+  lines.push(`  ${chalk12.bold("Directory Structure")}`);
+  lines.push(summary.directoryTree);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/memory/memory.ts
+import * as fs12 from "fs";
+import * as path11 from "path";
+function getMemoryDir(rootDir) {
+  const base = rootDir || process.cwd();
+  return path11.join(base, ".lovecode", "memory");
+}
+function getMemoryFilePath(key, rootDir) {
+  return path11.join(getMemoryDir(rootDir), `${key}.json`);
+}
+function ensureMemoryDir(rootDir) {
+  const dir = getMemoryDir(rootDir);
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
+  }
+}
+function readMemory(key, fallback, rootDir) {
+  const filePath = getMemoryFilePath(key, rootDir);
+  if (!fs12.existsSync(filePath)) return fallback;
+  try {
+    const raw = fs12.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+function writeMemory(key, data, rootDir) {
+  ensureMemoryDir(rootDir);
+  const filePath = getMemoryFilePath(key, rootDir);
+  fs12.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+var DEFAULT_PREFERENCES = {
+  indentStyle: "spaces",
+  indentSize: 2,
+  quoteStyle: "single",
+  semiColons: true,
+  trailingComma: true,
+  preferredTestRunner: "vitest",
+  preferredPackageManager: "npm",
+  preferredLinter: "eslint",
+  custom: {}
+};
+var DEFAULT_REPO = {
+  lastScan: 0,
+  totalFiles: 0,
+  totalDirs: 0,
+  primaryLanguage: "",
+  frameworks: [],
+  entryPoints: [],
+  keyDirectories: [],
+  buildCommands: [],
+  testCommands: [],
+  notes: []
+};
+var DEFAULT_WORKFLOWS = {
+  workflows: []
+};
+function getPreferences(rootDir) {
+  return readMemory("preferences", DEFAULT_PREFERENCES, rootDir);
+}
+function savePreferences(prefs, rootDir) {
+  const current = getPreferences(rootDir);
+  const updated = { ...current, ...prefs };
+  writeMemory("preferences", updated, rootDir);
+  return updated;
+}
+function getRepoMemory(rootDir) {
+  return readMemory("repo", DEFAULT_REPO, rootDir);
+}
+function getWorkflows(rootDir) {
+  return readMemory("workflows", DEFAULT_WORKFLOWS, rootDir);
+}
+function saveWorkflow(workflow, rootDir) {
+  const current = getWorkflows(rootDir);
+  const existingIdx = current.workflows.findIndex((w) => w.name === workflow.name);
+  if (existingIdx >= 0) {
+    current.workflows[existingIdx] = workflow;
+  } else {
+    current.workflows.push(workflow);
+  }
+  writeMemory("workflows", current, rootDir);
+  return current;
+}
+function deleteWorkflow(name, rootDir) {
+  const current = getWorkflows(rootDir);
+  const before = current.workflows.length;
+  current.workflows = current.workflows.filter((w) => w.name !== name);
+  if (current.workflows.length < before) {
+    writeMemory("workflows", current, rootDir);
+    return true;
+  }
+  return false;
+}
+function addRepoNote(note, rootDir) {
+  const current = getRepoMemory(rootDir);
+  current.notes.push(note);
+  if (current.notes.length > 50) current.notes = current.notes.slice(-50);
+  writeMemory("repo", current, rootDir);
+  return current;
+}
+function clearAllMemory(rootDir) {
+  const dir = getMemoryDir(rootDir);
+  if (fs12.existsSync(dir)) {
+    for (const file of fs12.readdirSync(dir)) {
+      if (file.endsWith(".json")) {
+        fs12.unlinkSync(path11.join(dir, file));
+      }
+    }
+  }
+}
+function formatPreferences(prefs) {
+  const lines = ["Coding Preferences:"];
+  lines.push(`  Indent: ${prefs.indentStyle} (${prefs.indentSize})`);
+  lines.push(`  Quotes: ${prefs.quoteStyle}`);
+  lines.push(`  Semicolons: ${prefs.semiColons ? "yes" : "no"}`);
+  lines.push(`  Trailing commas: ${prefs.trailingComma ? "yes" : "no"}`);
+  lines.push(`  Test runner: ${prefs.preferredTestRunner}`);
+  lines.push(`  Package manager: ${prefs.preferredPackageManager}`);
+  lines.push(`  Linter: ${prefs.preferredLinter}`);
+  if (Object.keys(prefs.custom).length > 0) {
+    lines.push("  Custom:");
+    for (const [k, v] of Object.entries(prefs.custom)) {
+      lines.push(`    ${k}: ${v}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatRepoMemory(mem) {
+  const lines = ["Repo Memory:"];
+  lines.push(`  Last scanned: ${mem.lastScan ? new Date(mem.lastScan).toISOString() : "never"}`);
+  lines.push(`  Files: ${mem.totalFiles}  Dirs: ${mem.totalDirs}`);
+  if (mem.primaryLanguage) lines.push(`  Primary language: ${mem.primaryLanguage}`);
+  if (mem.frameworks.length) lines.push(`  Frameworks: ${mem.frameworks.join(", ")}`);
+  if (mem.entryPoints.length) lines.push(`  Entry points: ${mem.entryPoints.join(", ")}`);
+  if (mem.keyDirectories.length) lines.push(`  Key dirs: ${mem.keyDirectories.join(", ")}`);
+  if (mem.buildCommands.length) lines.push(`  Build: ${mem.buildCommands.join(", ")}`);
+  if (mem.testCommands.length) lines.push(`  Test: ${mem.testCommands.join(", ")}`);
+  if (mem.notes.length) lines.push(`  Notes (${mem.notes.length}):`);
+  for (const note of mem.notes.slice(-5)) {
+    lines.push(`    \u2022 ${note}`);
+  }
+  return lines.join("\n");
+}
+
+// src/memory/vector.ts
+import * as fs13 from "fs";
+import * as path12 from "path";
+
+// src/ai/embeddings.ts
+import { execSync as execSync2 } from "child_process";
+async function getEmbedding(text) {
+  const ollamaBaseUrl = process.env.OLLAMA_URL || "http://localhost:11434";
+  try {
+    const response = await fetch(`${ollamaBaseUrl}/api/embeddings`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "nomic-embed-text",
+        prompt: text
+      })
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (data.embedding) {
+        return { vector: data.embedding, model: "nomic-embed-text", provider: "ollama" };
+      }
+    }
+  } catch {
+  }
+  try {
+    const response = await fetch(`${ollamaBaseUrl}/api/embeddings`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "all-minilm",
+        prompt: text
+      })
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (data.embedding) {
+        return { vector: data.embedding, model: "all-minilm", provider: "ollama" };
+      }
+    }
+  } catch {
+  }
+  return getSimpleEmbedding(text);
+}
+function getSimpleEmbedding(text) {
+  const words = text.toLowerCase().split(/\s+/).filter(Boolean);
+  const freq = /* @__PURE__ */ new Map();
+  for (const word of words) {
+    freq.set(word, (freq.get(word) || 0) + 1);
+  }
+  const vector = new Array(128).fill(0);
+  const chars = text.split("");
+  for (let i = 0; i < Math.min(chars.length, 128); i++) {
+    vector[i] = chars[i].charCodeAt(0) / 255;
+  }
+  return { vector, model: "simple", provider: "local" };
+}
+function cosineSimilarity(a, b) {
+  let dot = 0, magA = 0, magB = 0;
+  for (let i = 0; i < Math.min(a.length, b.length); i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(magA) * Math.sqrt(magB);
+  return denom === 0 ? 0 : dot / denom;
+}
+
+// src/memory/vector.ts
+function getVectorDir(rootDir) {
+  const base = rootDir || process.cwd();
+  return path12.join(base, ".lovecode", "memory");
+}
+function getVectorFilePath(rootDir) {
+  return path12.join(getVectorDir(rootDir), "vectors.json");
+}
+function ensureDir2(rootDir) {
+  const dir = getVectorDir(rootDir);
+  if (!fs13.existsSync(dir)) {
+    fs13.mkdirSync(dir, { recursive: true });
+  }
+}
+function loadVectors(rootDir) {
+  const filePath = getVectorFilePath(rootDir);
+  if (!fs13.existsSync(filePath)) return [];
+  try {
+    const raw = fs13.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function saveVectors(entries, rootDir) {
+  ensureDir2(rootDir);
+  const filePath = getVectorFilePath(rootDir);
+  fs13.writeFileSync(filePath, JSON.stringify(entries, null, 2), "utf-8");
+}
+async function storeVector(text, metadata, rootDir) {
+  const result = await getEmbedding(text);
+  const entry = {
+    id: Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
+    text,
+    vector: result.vector,
+    metadata: metadata || {},
+    timestamp: Date.now()
+  };
+  const entries = loadVectors(rootDir);
+  entries.push(entry);
+  saveVectors(entries, rootDir);
+  return entry;
+}
+async function searchVectors(query, options, rootDir) {
+  const entries = loadVectors(rootDir);
+  if (entries.length === 0) return [];
+  const queryResult = await getEmbedding(query);
+  const queryVec = queryResult.vector;
+  const minScore = options?.minScore ?? 0.1;
+  const topK = options?.topK ?? 5;
+  let filtered = entries;
+  if (options?.filter) {
+    const filterKeys = Object.keys(options.filter);
+    if (filterKeys.length > 0) {
+      filtered = entries.filter(
+        (e) => filterKeys.every((k) => e.metadata[k] === options.filter[k])
+      );
+    }
+  }
+  const scored = filtered.map((entry) => ({
+    entry,
+    score: cosineSimilarity(queryVec, entry.vector)
+  }));
+  scored.sort((a, b) => b.score - a.score);
+  return scored.filter((s) => s.score >= minScore).slice(0, topK);
+}
+function clearVectors(rootDir) {
+  const filePath = getVectorFilePath(rootDir);
+  if (fs13.existsSync(filePath)) {
+    fs13.unlinkSync(filePath);
+  }
+}
+function getVectorCount(rootDir) {
+  return loadVectors(rootDir).length;
+}
+function formatVectorResults(results) {
+  if (results.length === 0) return "No matching memories found.";
+  const lines = ["Vector Memory Search Results:"];
+  for (const r of results) {
+    const score = (r.score * 100).toFixed(1);
+    const tags = Object.entries(r.entry.metadata).map(([k, v]) => `${k}=${v}`).join(", ");
+    const meta = tags ? chalkDim(tags) : "";
+    lines.push(`  [${score}%] ${r.entry.text.slice(0, 120)}${meta ? ` (${meta})` : ""}`);
+  }
+  return lines.join("\n");
+}
+function chalkDim(s) {
+  return `\x1B[2m${s}\x1B[22m`;
+}
+
+// src/plugin/index.ts
+loadBuiltinPlugins();
+
+// src/core/tools.ts
+var fileTools = [
+  {
+    name: "read_file",
+    description: "Read the contents of a file",
+    usage: "path=<file path>",
+    execute(workingDir, args) {
+      try {
+        const filePath = path13.resolve(workingDir, args.path || ".");
+        if (!fs14.existsSync(filePath)) {
+          return { success: false, output: "", error: `File not found: ${args.path}` };
+        }
+        const content = fs14.readFileSync(filePath, "utf-8");
+        const lines = content.split("\n");
+        const numbered = lines.map((l, i) => `${String(i + 1).padStart(4, " ")} | ${l}`).join("\n");
+        return { success: true, output: numbered };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  },
+  {
+    name: "write_file",
+    description: "Write content to a file (creates parent dirs)",
+    usage: "path=<file path> content=<file content>",
+    execute(workingDir, args) {
+      try {
+        const filePath = path13.resolve(workingDir, args.path || "");
+        fs14.mkdirSync(path13.dirname(filePath), { recursive: true });
+        fs14.writeFileSync(filePath, args.content || "", "utf-8");
+        return { success: true, output: `Wrote ${filePath}` };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  },
+  {
+    name: "edit_file",
+    description: "Edit a file by replacing text (oldString -> newString)",
+    usage: "path=<file path> oldString=<text to find> newString=<replacement>",
+    execute(workingDir, args) {
+      try {
+        const filePath = path13.resolve(workingDir, args.path || "");
+        if (!fs14.existsSync(filePath)) {
+          return { success: false, output: "", error: `File not found: ${args.path}` };
+        }
+        const content = fs14.readFileSync(filePath, "utf-8");
+        const { oldString, newString } = args;
+        if (!oldString) {
+          return { success: false, output: "", error: "oldString is required" };
+        }
+        const count = (content.match(new RegExp(oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")) || []).length;
+        if (count === 0) {
+          return { success: false, output: "", error: `oldString not found in ${args.path}` };
+        }
+        const updated = content.replaceAll(oldString, newString || "");
+        fs14.writeFileSync(filePath, updated, "utf-8");
+        return { success: true, output: `Edited ${filePath} (${count} replacement${count > 1 ? "s" : ""})` };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  },
+  {
+    name: "create_file",
+    description: "Create a new empty file",
+    usage: "path=<file path>",
+    execute(workingDir, args) {
+      try {
+        const filePath = path13.resolve(workingDir, args.path || "");
+        if (fs14.existsSync(filePath)) {
+          return { success: false, output: "", error: `File already exists: ${args.path}` };
+        }
+        fs14.mkdirSync(path13.dirname(filePath), { recursive: true });
+        fs14.writeFileSync(filePath, "", "utf-8");
+        return { success: true, output: `Created ${filePath}` };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  },
+  {
+    name: "delete_file",
+    description: "Delete a file",
+    usage: "path=<file path>",
+    execute(workingDir, args) {
+      try {
+        const filePath = path13.resolve(workingDir, args.path || "");
+        if (!fs14.existsSync(filePath)) {
+          return { success: false, output: "", error: `File not found: ${args.path}` };
+        }
+        fs14.unlinkSync(filePath);
+        return { success: true, output: `Deleted ${filePath}` };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  },
+  {
+    name: "append_file",
+    description: "Append content to the end of a file",
+    usage: "path=<file path> content=<content to append>",
+    execute(workingDir, args) {
+      try {
+        const filePath = path13.resolve(workingDir, args.path || "");
+        fs14.mkdirSync(path13.dirname(filePath), { recursive: true });
+        fs14.appendFileSync(filePath, (args.content || "") + "\n", "utf-8");
+        return { success: true, output: `Appended to ${filePath}` };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  }
+];
+var commandTools = [];
+var searchTools = [
+  {
+    name: "grep_search",
+    description: "Search file contents with a regular expression",
+    usage: "pattern=<regex> [include=<glob pattern>]",
+    execute(workingDir, args) {
+      try {
+        const pattern = args.pattern || "";
+        const include = args.include || "**/*";
+        const cmd = `rg -n '${pattern.replace(/'/g, "'\\''")}' --include '${include}' 2>/dev/null || echo "(no matches)"`;
+        const output = execSync3(cmd, { cwd: workingDir, encoding: "utf-8", maxBuffer: 1024 * 1024 });
+        return { success: true, output: output.trim() };
+      } catch {
+        return { success: true, output: "(no matches)" };
+      }
+    }
+  },
+  {
+    name: "glob_search",
+    description: "Find files matching a glob pattern",
+    usage: "pattern=<glob pattern>",
+    execute(workingDir, args) {
+      try {
+        const pattern = args.pattern || "*";
+        const cmd = `ls -1 ${pattern.replace(/ /g, "\\ ")} 2>/dev/null || echo "(no files found)"`;
+        const output = execSync3(cmd, { cwd: workingDir, encoding: "utf-8", maxBuffer: 1024 * 1024 });
+        return { success: true, output: output.trim() };
+      } catch {
+        return { success: true, output: "(no files found)" };
+      }
+    }
+  },
+  {
+    name: "list_dir",
+    description: "List files and directories",
+    usage: "path=<directory path>",
+    execute(workingDir, args) {
+      try {
+        const dirPath = path13.resolve(workingDir, args.path || ".");
+        if (!fs14.existsSync(dirPath)) {
+          return { success: false, output: "", error: `Directory not found: ${args.path}` };
+        }
+        const entries = fs14.readdirSync(dirPath, { withFileTypes: true });
+        const output = entries.map((e) => e.isDirectory() ? chalk13.cyan(`${e.name}/`) : e.name).join("\n");
+        return { success: true, output };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  },
+  {
+    name: "get_cwd",
+    description: "Get the current working directory",
+    usage: "(no arguments)",
+    execute(_workingDir, _args) {
+      return { success: true, output: process.cwd() };
+    }
+  }
+];
+var fsEngineTools = [
+  {
+    name: "scan_files",
+    description: "Recursively scan files in the project. Returns categorized listing.",
+    usage: "[path=<dir>] [maxDepth=<number>] [category=<source|config|doc|script|data>]",
+    execute(workingDir, args) {
+      try {
+        const rootDir = path13.resolve(workingDir, args.path || ".");
+        const maxDepth = parseInt(args.maxDepth || "10", 10);
+        const category = args.category;
+        const files = scanDirectory({
+          rootDir,
+          maxDepth,
+          maxFiles: 1e4
+        });
+        if (category) {
+          const filtered = files.filter((f) => f.category === category);
+          const summary = printScanSummary(filtered);
+          const fileList = filtered.map((f) => `  ${f.relativePath}`).join("\n");
+          return { success: true, output: `${summary}
+
+${fileList}` };
+        }
+        return { success: true, output: printScanSummary(files) };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  },
+  {
+    name: "find_file",
+    description: "Search for files by name/pattern",
+    usage: "query=<name or pattern> [content=<true|false>]",
+    execute(workingDir, args) {
+      try {
+        const query = args.query || "";
+        const includeContent = args.content === "true";
+        const results = findFiles({ rootDir: workingDir, query, maxResults: 20, includeContent });
+        if (results.length === 0) return { success: true, output: "(no files found)" };
+        const lines = results.map((r, i) => {
+          let line = `  ${i + 1}. ${r.relativePath} ${chalk13.dim(`(score: ${r.score})`)}`;
+          if (r.matches && r.matches.length > 0) {
+            const top = r.matches.slice(0, 3);
+            line += top.map((m) => `
+       ${chalk13.dim(`L${m.line}:`)} ${m.content.slice(0, 80)}`).join("");
+          }
+          return line;
+        });
+        return { success: true, output: `Found ${results.length} files:
+${lines.join("\n")}` };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  },
+  {
+    name: "semantic_search",
+    description: "Search by file name and content (combined)",
+    usage: "query=<search term>",
+    execute(workingDir, args) {
+      try {
+        const query = args.query || "";
+        const results = semanticSearch(query, workingDir);
+        if (results.length === 0) return { success: true, output: "(no matches)" };
+        const lines = results.map((r, i) => {
+          let line = `  ${i + 1}. ${r.relativePath} ${chalk13.dim(`(score: ${r.score})`)}`;
+          if (r.matches && r.matches.length > 0) {
+            const top = r.matches.slice(0, 2);
+            line += top.map((m) => `
+       ${chalk13.dim(`L${m.line}:`)} ${m.content.slice(0, 80)}`).join("");
+          }
+          return line;
+        });
+        return { success: true, output: `Semantic search results:
+${lines.join("\n")}` };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  },
+  {
+    name: "rename_file",
+    description: "Rename or move a file",
+    usage: "oldPath=<current path> newPath=<new path>",
+    execute(workingDir, args) {
+      const oldPath = path13.resolve(workingDir, args.oldPath || "");
+      const newPath = path13.resolve(workingDir, args.newPath || "");
+      const result = renameFile(oldPath, newPath);
+      return { success: result.success, output: result.message, error: result.error };
+    }
+  },
+  {
+    name: "duplicate_file",
+    description: "Copy/duplicate a file",
+    usage: "source=<source path> dest=<destination path>",
+    execute(workingDir, args) {
+      const sourcePath = path13.resolve(workingDir, args.source || "");
+      const destPath = path13.resolve(workingDir, args.dest || "");
+      const result = duplicateFile(sourcePath, destPath);
+      return { success: result.success, output: result.message, error: result.error };
+    }
+  },
+  {
+    name: "file_tree",
+    description: "Show directory tree structure",
+    usage: "[path=<dir>] [maxDepth=<number>]",
+    execute(workingDir, args) {
+      try {
+        const dirPath = path13.resolve(workingDir, args.path || ".");
+        const maxDepth = parseInt(args.maxDepth || "3", 10);
+        const tree = getDirectoryTree(dirPath, "", maxDepth);
+        return { success: true, output: tree };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  },
+  {
+    name: "rank_files",
+    description: "Rank files by importance for context",
+    usage: "[task=<task description>] [limit=<number>]",
+    execute(workingDir, args) {
+      try {
+        const task = args.task || "";
+        const limit = parseInt(args.limit || "10", 10);
+        const files = scanDirectory({ rootDir: workingDir, maxDepth: 10, maxFiles: 5e3 });
+        const ranked = rankFiles(files, task);
+        const top = ranked.slice(0, limit);
+        return { success: true, output: printRankedFiles(top) };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  }
+];
+var editorTools = [
+  {
+    name: "inline_patch",
+    description: "Apply a search/replace patch to a file with context matching",
+    usage: "path=<file> search=<text to find> replace=<replacement>",
+    execute(workingDir, args) {
+      const filePath = path13.resolve(workingDir, args.path || "");
+      const result = applyInlinePatch(filePath, args.search || "", args.replace || "");
+      if (result.success) {
+        saveUndoPoint(workingDir, filePath, "inline_patch");
+      }
+      return { success: result.success, output: result.output, error: result.error };
+    }
+  },
+  {
+    name: "syntax_check",
+    description: "Check a file for basic syntax errors (brace balance)",
+    usage: "path=<file path>",
+    execute(workingDir, args) {
+      try {
+        const filePath = path13.resolve(workingDir, args.path || "");
+        const content = fs14.readFileSync(filePath, "utf-8");
+        const result = checkBraceBalance(content, filePath);
+        if (result.valid) {
+          return { success: true, output: "Syntax check passed: all braces balanced" };
+        }
+        const lines = result.errors.map(
+          (e) => `  Line ${e.line}:${e.column} \u2014 ${e.message}`
+        );
+        return { success: false, output: `Syntax errors found:
+${lines.join("\n")}` };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  },
+  {
+    name: "undo",
+    description: "Undo the last file edit",
+    usage: "[path=<file path>]",
+    execute(workingDir, args) {
+      const filePath = args.path ? path13.resolve(workingDir, args.path) : void 0;
+      const result = filePath ? undoForFile(workingDir, filePath) : undoForFile(workingDir, "");
+      if (result) {
+        return { success: true, output: `Undone: ${result.label} on ${result.filePath}` };
+      }
+      return { success: false, output: "", error: "Nothing to undo" };
+    }
+  },
+  {
+    name: "undo_history",
+    description: "Show undo history",
+    usage: "(no arguments)",
+    execute(workingDir, _args) {
+      const history = getUndoHistory(workingDir);
+      if (history.length === 0) return { success: true, output: "(no undo history)" };
+      const lines = history.map(
+        (e, i) => `  ${i + 1}. ${chalk13.dim(e.label)} \u2014 ${e.filePath} ${chalk13.dim(`(${new Date(e.timestamp).toLocaleString()})`)}`
+      );
+      return { success: true, output: `Undo History:
+${lines.join("\n")}` };
+    }
+  },
+  {
+    name: "snapshot",
+    description: "Create a snapshot of a file",
+    usage: "path=<file path> [label=<optional label>]",
+    execute(workingDir, args) {
+      const filePath = path13.resolve(workingDir, args.path || "");
+      const label = args.label || "manual";
+      const snap = createSnapshot(workingDir, filePath, label);
+      if (snap) {
+        return { success: true, output: `Snapshot created: ${snap.id} (${snap.size} bytes)` };
+      }
+      return { success: false, output: "", error: "Failed to create snapshot" };
+    }
+  },
+  {
+    name: "snapshot_list",
+    description: "List available snapshots",
+    usage: "(no arguments)",
+    execute(workingDir, _args) {
+      const snaps = listSnapshots(workingDir);
+      if (snaps.length === 0) return { success: true, output: "(no snapshots)" };
+      const lines = snaps.map(
+        (s, i) => `  ${i + 1}. ${chalk13.cyan(s.id)} ${chalk13.dim(s.relativePath)} \u2014 ${s.label}`
+      );
+      return { success: true, output: `Snapshots:
+${lines.join("\n")}` };
+    }
+  },
+  {
+    name: "snapshot_restore",
+    description: "Restore a file from a snapshot",
+    usage: "id=<snapshot id>",
+    execute(workingDir, args) {
+      const id = args.id || "";
+      const ok = restoreSnapshot(workingDir, id);
+      if (ok) return { success: true, output: `Restored snapshot: ${id}` };
+      return { success: false, output: "", error: `Snapshot not found: ${id}` };
+    }
+  },
+  {
+    name: "refactor",
+    description: "Execute multi-file refactoring with syntax validation",
+    usage: "edits=<JSON array of {filePath,search,replace,description}>",
+    async execute(workingDir, args) {
+      try {
+        const edits = JSON.parse(args.edits || "[]");
+        if (!Array.isArray(edits) || edits.length === 0) {
+          return { success: false, output: "", error: "edits must be a non-empty JSON array" };
+        }
+        const plan = planRefactor(edits, workingDir, true);
+        const result = await executeRefactor(plan);
+        return { success: result.success, output: result.output };
+      } catch (err) {
+        return { success: false, output: "", error: String(err) };
+      }
+    }
+  }
+];
+var shellTools = [
+  {
+    name: "execute_command",
+    description: "Run a shell command with sandbox, timeout, and output capture",
+    usage: "command=<shell command> [timeout=<ms>]",
+    execute(workingDir, args) {
+      const command = args.command || "";
+      const timeout = parseInt(args.timeout || "120000", 10);
+      const policy = createDefaultPolicy();
+      const verdict = evaluateCommand(command, policy);
+      if (!verdict.allowed) {
+        return {
+          success: false,
+          output: printSandboxVerdict(verdict),
+          error: verdict.reason
+        };
+      }
+      return execCommand(command, workingDir, timeout).then((result) => ({
+        success: result.success,
+        output: result.stdout + (result.stderr ? `
+${chalk13.yellow(result.stderr)}` : ""),
+        error: result.success ? void 0 : `Exit code: ${result.exitCode}${result.cancelled ? " (cancelled)" : ""}`
+      }));
+    }
+  }
+];
+var memoryTools = [
+  {
+    name: "store_preference",
+    description: "Store a coding preference",
+    usage: "key=<name> value=<value>",
+    async execute(_workingDir, args) {
+      const key = args.key;
+      const value = args.value;
+      if (!key || !value) return { success: false, output: "", error: "key and value required" };
+      const boolKeys = ["semiColons", "trailingComma"];
+      const numKeys = ["indentSize"];
+      const prefs = {};
+      if (boolKeys.includes(key)) prefs[key] = value === "true" || value === "yes";
+      else if (numKeys.includes(key)) prefs[key] = parseInt(value, 10);
+      else prefs[key] = value;
+      savePreferences(prefs);
+      return { success: true, output: `Stored preference ${key} = ${value}` };
+    }
+  },
+  {
+    name: "recall_preferences",
+    description: "Retrieve stored coding preferences",
+    usage: "",
+    execute() {
+      const prefs = getPreferences();
+      const lines = [
+        `Indent: ${prefs.indentStyle} (${prefs.indentSize})`,
+        `Quotes: ${prefs.quoteStyle}`,
+        `Semicolons: ${prefs.semiColons ? "yes" : "no"}`,
+        `Trailing commas: ${prefs.trailingComma ? "yes" : "no"}`,
+        `Test runner: ${prefs.preferredTestRunner}`,
+        `Package manager: ${prefs.preferredPackageManager}`,
+        `Linter: ${prefs.preferredLinter}`
+      ];
+      return { success: true, output: lines.join("\n") };
+    }
+  },
+  {
+    name: "repo_note",
+    description: "Store a note about the repository structure or conventions",
+    usage: "note=<text>",
+    execute(_workingDir, args) {
+      if (!args.note) return { success: false, output: "", error: "note required" };
+      addRepoNote(args.note);
+      return { success: true, output: `Note saved: ${args.note}` };
+    }
+  },
+  {
+    name: "recall_repo_memory",
+    description: "Retrieve stored repo memory and notes",
+    usage: "",
+    execute() {
+      const mem = getRepoMemory();
+      const lines = [];
+      if (mem.primaryLanguage) lines.push(`Language: ${mem.primaryLanguage}`);
+      if (mem.frameworks.length) lines.push(`Frameworks: ${mem.frameworks.join(", ")}`);
+      if (mem.entryPoints.length) lines.push(`Entry points: ${mem.entryPoints.join(", ")}`);
+      if (mem.buildCommands.length) lines.push(`Build: ${mem.buildCommands.join(", ")}`);
+      if (mem.testCommands.length) lines.push(`Test: ${mem.testCommands.join(", ")}`);
+      if (mem.notes.length) lines.push(`Notes:
+  ${mem.notes.join("\n  ")}`);
+      return { success: true, output: lines.join("\n") || "No repo memory stored." };
+    }
+  },
+  {
+    name: "save_workflow",
+    description: "Save a reusable workflow for future tasks",
+    usage: "name=<workflow name> steps=<comma separated steps>",
+    execute(_workingDir, args) {
+      if (!args.name || !args.steps) return { success: false, output: "", error: "name and steps required" };
+      const steps = args.steps.split(",").map((s) => s.trim());
+      saveWorkflow({ name: args.name, description: steps[0] || "", steps, tags: [], created: Date.now(), used: Date.now() });
+      return { success: true, output: `Workflow "${args.name}" saved with ${steps.length} steps.` };
+    }
+  },
+  {
+    name: "list_workflows",
+    description: "List saved workflows",
+    usage: "",
+    execute() {
+      const wf = getWorkflows();
+      if (wf.workflows.length === 0) return { success: true, output: "No saved workflows." };
+      const lines = wf.workflows.map((w) => `  ${w.name} (${w.steps.length} steps): ${w.description}`);
+      return { success: true, output: `Workflows:
+${lines.join("\n")}` };
+    }
+  },
+  {
+    name: "vector_store",
+    description: "Store text in vector memory for semantic recall",
+    usage: "text=<content> [label=<category>]",
+    async execute(_workingDir, args) {
+      if (!args.text) return { success: false, output: "", error: "text required" };
+      const metadata = {};
+      if (args.label) metadata.label = args.label;
+      await storeVector(args.text, metadata);
+      return { success: true, output: "Stored in vector memory." };
+    }
+  },
+  {
+    name: "vector_search",
+    description: "Search vector memory by semantic similarity",
+    usage: "query=<search text> [topK=<number>]",
+    async execute(_workingDir, args) {
+      if (!args.query) return { success: false, output: "", error: "query required" };
+      const topK = args.topK ? parseInt(args.topK, 10) : 5;
+      const results = await searchVectors(args.query, { topK });
+      return { success: true, output: formatVectorResults(results) };
+    }
+  }
+];
+var gitTools = [
+  {
+    name: "git_status",
+    description: "Show working tree status",
+    usage: "",
+    execute(_workingDir) {
+      if (!isGitAvailable()) return { success: false, output: "", error: "Git not available" };
+      const status = getStatus();
+      return { success: true, output: formatStatus(status) };
+    }
+  },
+  {
+    name: "git_commit",
+    description: "Stage all changes and commit with a message",
+    usage: "message=<commit message>",
+    execute(_workingDir, args) {
+      if (!isGitAvailable()) return { success: false, output: "", error: "Git not available" };
+      if (!args.message) return { success: false, output: "", error: "message required" };
+      stageAll();
+      const result = commit(args.message);
+      return result.success ? { success: true, output: `Committed: ${result.hash ? result.hash.slice(0, 8) : "ok"} \u2014 ${args.message}` } : { success: false, output: result.output, error: result.output };
+    }
+  },
+  {
+    name: "git_diff",
+    description: "Show current diff (staged + unstaged)",
+    usage: "[staged=<true|false>]",
+    execute(_workingDir, args) {
+      if (!isGitAvailable()) return { success: false, output: "", error: "Git not available" };
+      const diff = args.staged === "true" ? getStagedDiff() : getFullDiff();
+      return { success: true, output: diff || "No changes." };
+    }
+  },
+  {
+    name: "git_branches",
+    description: "List all branches",
+    usage: "",
+    execute() {
+      if (!isGitAvailable()) return { success: false, output: "", error: "Git not available" };
+      const branches = getBranches();
+      return { success: true, output: formatBranches(branches) };
+    }
+  },
+  {
+    name: "git_create_branch",
+    description: "Create and switch to a new branch",
+    usage: "name=<branch name>",
+    execute(_workingDir, args) {
+      if (!isGitAvailable()) return { success: false, output: "", error: "Git not available" };
+      if (!args.name) return { success: false, output: "", error: "name required" };
+      const ok = createBranch(args.name);
+      return ok ? { success: true, output: `Created and switched to branch "${args.name}"` } : { success: false, output: "", error: `Failed to create branch "${args.name}"` };
+    }
+  },
+  {
+    name: "git_switch_branch",
+    description: "Switch to an existing branch",
+    usage: "name=<branch name>",
+    execute(_workingDir, args) {
+      if (!isGitAvailable()) return { success: false, output: "", error: "Git not available" };
+      if (!args.name) return { success: false, output: "", error: "name required" };
+      const result = switchBranch(args.name);
+      return result.success ? { success: true, output: `Switched to branch "${args.name}"` } : { success: false, output: result.output, error: result.output };
+    }
+  },
+  {
+    name: "git_log",
+    description: "Show recent commit log",
+    usage: "[count=<number>]",
+    execute(_workingDir, args) {
+      if (!isGitAvailable()) return { success: false, output: "", error: "Git not available" };
+      const count = args.count ? parseInt(args.count, 10) : 10;
+      const log = getLog(count);
+      return { success: true, output: formatLog(log) };
+    }
+  },
+  {
+    name: "git_branch",
+    description: "Get current branch name",
+    usage: "",
+    execute() {
+      if (!isGitAvailable()) return { success: false, output: "", error: "Git not available" };
+      return { success: true, output: getCurrentBranch() };
+    }
+  }
+];
+var browserTools = [
+  {
+    name: "browser_goto",
+    description: "Navigate the browser to a URL",
+    usage: "url=<URL>",
+    async execute(_wd, args) {
+      if (!args.url) return { success: false, output: "", error: "url required" };
+      try {
+        if (!isBrowserRunning()) {
+          const { launchBrowser } = await import("./browser-UA4QOMPS.js");
+          await launchBrowser();
+        }
+        const result = await goto(args.url);
+        return { success: true, output: result };
+      } catch (e) {
+        return { success: false, output: "", error: String(e) };
+      }
+    }
+  },
+  {
+    name: "browser_click",
+    description: "Click an element on the page",
+    usage: "selector=<CSS selector>",
+    async execute(_wd, args) {
+      if (!args.selector) return { success: false, output: "", error: "selector required" };
+      try {
+        const result = await click(args.selector);
+        return { success: true, output: result };
+      } catch (e) {
+        return { success: false, output: "", error: String(e) };
+      }
+    }
+  },
+  {
+    name: "browser_type",
+    description: "Type text into an input element",
+    usage: "selector=<CSS selector> text=<text>",
+    async execute(_wd, args) {
+      if (!args.selector) return { success: false, output: "", error: "selector required" };
+      if (!args.text) return { success: false, output: "", error: "text required" };
+      try {
+        const result = await type(args.selector, args.text);
+        return { success: true, output: result };
+      } catch (e) {
+        return { success: false, output: "", error: String(e) };
+      }
+    }
+  },
+  {
+    name: "browser_screenshot",
+    description: "Take a browser screenshot",
+    usage: "[name=<filename>]",
+    async execute() {
+      try {
+        const result = await screenshot();
+        return { success: true, output: formatScreenshotResult(result) };
+      } catch (e) {
+        return { success: false, output: "", error: String(e) };
+      }
+    }
+  },
+  {
+    name: "browser_inspect",
+    description: "Inspect a DOM element on the page",
+    usage: "selector=<CSS selector>",
+    async execute(_wd, args) {
+      if (!args.selector) return { success: false, output: "", error: "selector required" };
+      try {
+        const el = await inspect(args.selector);
+        if (!el) return { success: false, output: "", error: "Element not found" };
+        return { success: true, output: formatDOMElement(el) };
+      } catch (e) {
+        return { success: false, output: "", error: String(e) };
+      }
+    }
+  }
+];
+var pluginTools = [
+  {
+    name: "plugin_list",
+    description: "List loaded plugins",
+    usage: "",
+    execute() {
+      const plugins = listPlugins();
+      const lines = plugins.map((p) => `  ${p.enabled ? "\u2713" : "\u2717"} ${p.manifest.name}@${p.manifest.version} \u2014 ${p.manifest.description}`);
+      return { success: true, output: lines.join("\n") || "No plugins loaded." };
+    }
+  },
+  {
+    name: "plugin_enable",
+    description: "Enable a plugin by name",
+    usage: "name=<plugin name>",
+    execute(_wd, args) {
+      if (!args.name) return { success: false, output: "", error: "name required" };
+      const ok = enablePlugin(args.name);
+      return ok ? { success: true, output: `Enabled ${args.name}` } : { success: false, output: "", error: `Plugin "${args.name}" not found` };
+    }
+  },
+  {
+    name: "plugin_disable",
+    description: "Disable a plugin by name",
+    usage: "name=<plugin name>",
+    execute(_wd, args) {
+      if (!args.name) return { success: false, output: "", error: "name required" };
+      const ok = disablePlugin(args.name);
+      return ok ? { success: true, output: `Disabled ${args.name}` } : { success: false, output: "", error: `Plugin "${args.name}" not found` };
+    }
+  }
+];
+var repoTools = [
+  {
+    name: "detect_project",
+    description: "Detect project type, framework, and stack",
+    usage: "[dir=<directory>]",
+    execute(workingDir, args) {
+      const dir = args.dir ? path13.resolve(workingDir, args.dir) : workingDir;
+      const info = detectProject(dir);
+      return { success: true, output: printProjectInfo(info) };
+    }
+  },
+  {
+    name: "analyze_deps",
+    description: "Analyze dependencies and import graph",
+    usage: "[dir=<directory>]",
+    execute(workingDir, args) {
+      const dir = args.dir ? path13.resolve(workingDir, args.dir) : workingDir;
+      const graph = analyzeDependencies(dir);
+      return { success: true, output: printDepGraph(graph) };
+    }
+  },
+  {
+    name: "repo_summary",
+    description: "Generate a full repository architecture summary",
+    usage: "[dir=<directory>]",
+    execute(workingDir, args) {
+      const dir = args.dir ? path13.resolve(workingDir, args.dir) : workingDir;
+      const summary = generateSummary(dir);
+      return { success: true, output: printSummary(summary) };
+    }
+  }
+];
+loadBuiltinPlugins();
+var allTools = [
+  ...fileTools,
+  ...commandTools,
+  ...searchTools,
+  ...fsEngineTools,
+  ...editorTools,
+  ...shellTools,
+  ...repoTools,
+  ...memoryTools,
+  ...gitTools,
+  ...browserTools,
+  ...pluginTools,
+  ...getAllPluginTools()
+];
+function getTool(name) {
+  return allTools.find((t) => t.name === name);
+}
+
+export {
+  getPreferences,
+  savePreferences,
+  getRepoMemory,
+  getWorkflows,
+  saveWorkflow,
+  deleteWorkflow,
+  addRepoNote,
+  clearAllMemory,
+  formatPreferences,
+  formatRepoMemory,
+  getEmbedding,
+  cosineSimilarity,
+  storeVector,
+  searchVectors,
+  clearVectors,
+  getVectorCount,
+  formatVectorResults,
+  getModeConfig,
+  createContext,
+  listModes,
+  getApproval,
+  scanDirectory,
+  printScanSummary,
+  detectProject,
+  printProjectInfo,
+  analyzeDependencies,
+  printDepGraph,
+  findCircularDeps,
+  generateSummary,
+  printSummary,
+  allTools,
+  getTool
+};