@chamba/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1218 @@
+// src/util/path.ts
+function joinPath(...parts) {
+  return parts.filter((p) => p.length > 0).join("/").replace(/\/{2,}/g, "/");
+}
+function basename(path) {
+  const trimmed = path.replace(/\/+$/, "");
+  const idx = trimmed.lastIndexOf("/");
+  return idx === -1 ? trimmed : trimmed.slice(idx + 1);
+}
+function dirname(path) {
+  const trimmed = path.replace(/\/+$/, "");
+  const idx = trimmed.lastIndexOf("/");
+  return idx === -1 ? "" : trimmed.slice(0, idx);
+}
+function extname(path) {
+  const base = basename(path);
+  const idx = base.lastIndexOf(".");
+  return idx <= 0 ? "" : base.slice(idx);
+}
+
+// src/workspace/workspace.ts
+var WORKSPACE_DIR = ".chamba";
+var WORKSPACE_FILE = "workspace.md";
+var WORKSPACE_RELATIVE_PATH = `${WORKSPACE_DIR}/${WORKSPACE_FILE}`;
+function renderWorkspaceMarkdown(ws) {
+  const lines = [];
+  lines.push("# Workspace");
+  lines.push("");
+  lines.push("> Generated by chamba. Editable by hand \u2014 chamba will not overwrite");
+  lines.push("> your edits; `workspace_reload` only proposes a diff.");
+  lines.push("");
+  lines.push("## Description");
+  lines.push("");
+  lines.push(
+    ws.description.trim().length > 0 ? ws.description.trim() : "_No description detected._"
+  );
+  lines.push("");
+  lines.push("## Languages");
+  lines.push("");
+  if (ws.languages.length > 0) {
+    for (const lang of ws.languages) lines.push(`- ${lang}`);
+  } else {
+    lines.push("_None detected._");
+  }
+  lines.push("");
+  lines.push("## Framework");
+  lines.push("");
+  lines.push(ws.framework ?? "_None detected._");
+  lines.push("");
+  lines.push("## Conventions");
+  lines.push("");
+  if (ws.conventions.length > 0) {
+    for (const c of ws.conventions) lines.push(`- ${c}`);
+  } else {
+    lines.push("_None detected._");
+  }
+  lines.push("");
+  lines.push("## Active projects");
+  lines.push("");
+  if (ws.projects.length > 0) {
+    for (const p of ws.projects) {
+      const meta = [p.language, p.framework].filter(Boolean).join(", ");
+      lines.push(`- **${p.name}** (\`${p.path}\`)${meta ? ` \u2014 ${meta}` : ""}`);
+    }
+  } else {
+    lines.push("_None detected._");
+  }
+  lines.push("");
+  lines.push("## Folder map");
+  lines.push("");
+  if (ws.folderMap.length > 0) {
+    for (const dir of ws.folderMap) lines.push(`- ${dir}/`);
+  } else {
+    lines.push("_Empty._");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/memory/filesystem-store.ts
+var MEMORY_DIR = `${WORKSPACE_DIR}/memory`;
+var FilesystemMemoryStore = class {
+  constructor(fs, clock, root) {
+    this.fs = fs;
+    this.clock = clock;
+    this.root = root;
+  }
+  fs;
+  clock;
+  root;
+  dir() {
+    return joinPath(this.root, MEMORY_DIR);
+  }
+  pathFor(key) {
+    return joinPath(this.dir(), `${slugifyKey(key)}.md`);
+  }
+  async remember(input) {
+    const path = this.pathFor(input.key);
+    const now = this.clock.now().toISOString();
+    const existing = await this.read(path);
+    let memory;
+    if (existing) {
+      memory = {
+        key: existing.key,
+        tags: [.../* @__PURE__ */ new Set([...existing.tags, ...input.tags ?? []])],
+        createdAt: existing.createdAt,
+        updatedAt: now,
+        content: `${existing.content.trimEnd()}
+
+## Update ${now}
+
+${input.content.trim()}`,
+        path
+      };
+    } else {
+      memory = {
+        key: input.key,
+        tags: input.tags ?? [],
+        createdAt: now,
+        updatedAt: now,
+        content: input.content.trim(),
+        path
+      };
+    }
+    await this.fs.mkdir(this.dir());
+    await this.fs.writeFile(path, render(memory));
+    return memory;
+  }
+  async recall(query) {
+    const keywords = query.toLowerCase().split(/\s+/).filter((w) => w.length > 0);
+    if (keywords.length === 0) return [];
+    let entries;
+    try {
+      entries = await this.fs.readDir(this.dir());
+    } catch {
+      return [];
+    }
+    const scored = [];
+    for (const entry of entries) {
+      if (!entry.isFile || !entry.name.toLowerCase().endsWith(".md")) continue;
+      const memory = await this.read(joinPath(this.dir(), entry.name));
+      if (!memory) continue;
+      const haystack = `${memory.key} ${memory.tags.join(" ")} ${memory.content}`.toLowerCase();
+      const score = keywords.filter((k) => haystack.includes(k)).length;
+      if (score > 0) scored.push({ memory, score });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.map((s) => s.memory);
+  }
+  async read(path) {
+    let text;
+    try {
+      text = await this.fs.readFile(path);
+    } catch {
+      return null;
+    }
+    return parse(text, path);
+  }
+};
+function slugifyKey(key) {
+  const slug = key.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "");
+  return slug.length > 0 ? slug : "memory";
+}
+function render(memory) {
+  const frontmatter = [
+    "---",
+    `key: ${memory.key}`,
+    `tags: [${memory.tags.join(", ")}]`,
+    `createdAt: ${memory.createdAt}`,
+    `updatedAt: ${memory.updatedAt}`,
+    "---"
+  ].join("\n");
+  return `${frontmatter}
+
+${memory.content.trim()}
+`;
+}
+function parse(text, path) {
+  const fm = text.match(/^---\n([\s\S]*?)\n---\n?/);
+  const meta = {};
+  if (fm?.[1]) {
+    for (const line of fm[1].split("\n")) {
+      const m = line.match(/^(\w+):\s*(.*)$/);
+      if (m?.[1]) meta[m[1]] = (m[2] ?? "").trim();
+    }
+  }
+  const body = fm ? text.slice(fm[0].length) : text;
+  const tagsRaw = (meta.tags ?? "").replace(/^\[|\]$/g, "");
+  const tags = tagsRaw.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+  return {
+    key: meta.key ?? slugFromPath(path),
+    tags,
+    createdAt: meta.createdAt ?? "",
+    updatedAt: meta.updatedAt ?? meta.createdAt ?? "",
+    content: body.trim(),
+    path
+  };
+}
+function slugFromPath(path) {
+  const file = path.slice(path.lastIndexOf("/") + 1);
+  return file.replace(/\.md$/, "");
+}
+
+// src/obsidian/note-template.ts
+function slugify(title) {
+  const slug = title.toLowerCase().normalize("NFD").replace(/\p{Diacritic}/gu, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug.length > 0 ? slug : "note";
+}
+function renderNote(fields) {
+  const tags = fields.tags.map((t) => slugify(t)).filter((t) => t.length > 0);
+  const frontmatter = [
+    "---",
+    `title: "${escapeYaml(fields.title)}"`,
+    `date: ${fields.date}`,
+    `tags: [${tags.join(", ")}]`,
+    "source: chamba",
+    "---"
+  ].join("\n");
+  return `${frontmatter}
+
+# ${fields.title}
+
+${fields.body.trim()}
+`;
+}
+function escapeYaml(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+// src/obsidian/vault-writer.ts
+var VAULT_NOTES_DIR = "proyectos";
+var VaultWriter = class {
+  constructor(fs, clock) {
+    this.fs = fs;
+    this.clock = clock;
+  }
+  fs;
+  clock;
+  async write(input) {
+    const date = this.clock.today();
+    const slug = slugify(input.projectSlug ?? input.title);
+    const dir = joinPath(input.vaultPath, VAULT_NOTES_DIR);
+    const notePath = joinPath(dir, `${date}-${slug}.md`);
+    const note = renderNote({
+      title: input.title,
+      date,
+      tags: input.tags && input.tags.length > 0 ? input.tags : ["chamba", "project"],
+      body: input.content
+    });
+    await this.fs.mkdir(dir);
+    await this.fs.writeFile(notePath, note);
+    return { notePath };
+  }
+};
+
+// src/plan/validator.ts
+var SENSITIVE_RE = /\b(auth|authentication|authorization|payments?|billing|migrations?|secrets?|credentials?|passwords?)\b/i;
+var SENSITIVE_PATH_RE = /(^|\/)(auth|payments|billing|migrations|secrets?|credentials)(\/|$)/i;
+var WORKER_RE = /\b(implementer|tester|reviewer|worker)\b/i;
+var TESTS_RE = /\b(tests?|vitest|jest|spec|unit test|integration test)\b/i;
+var PLACEHOLDER_RE = /\b(todo|tbd|fixme|placeholder)\b/i;
+var DEFAULT_MODULES = /* @__PURE__ */ new Set([
+  "packages",
+  "examples",
+  "src",
+  "test",
+  "tests",
+  "scripts",
+  "docs",
+  "app",
+  ".chamba",
+  ".github"
+]);
+function validatePlan(input) {
+  const plan = input.plan;
+  const lower = plan.toLowerCase();
+  const sec = sections(plan);
+  const issues = [];
+  const suggestions = [];
+  const riskFlags = [];
+  const acItems = listItems(getSection(sec, "acceptance criteria")).filter(isConcrete);
+  if (!lower.includes("acceptance criteria") || acItems.length === 0) {
+    issues.push({
+      code: "no-acceptance-criteria",
+      severity: "error",
+      message: "No explicit acceptance criteria with at least one concrete, checkable item."
+    });
+    suggestions.push('Add an "## Acceptance criteria" section with checkable bullets.');
+  }
+  const negatedTests = /\b(no|sin|without)\s+(unit\s+|integration\s+)?tests?\b/i.test(lower);
+  if (!TESTS_RE.test(lower) || negatedTests) {
+    issues.push({
+      code: "no-tests",
+      severity: "error",
+      message: "No tests mentioned. State how the change will be verified."
+    });
+    suggestions.push("Add a tester subtask or a test-related acceptance criterion.");
+  }
+  const subtaskItems = listItems(getSection(sec, "subtasks"));
+  if (subtaskItems.length === 0) {
+    issues.push({
+      code: "no-subtasks",
+      severity: "error",
+      message: "No subtasks listed. Break the work into concrete steps."
+    });
+  } else {
+    if (!subtaskItems.some((it) => WORKER_RE.test(it))) {
+      issues.push({
+        code: "subtask-without-worker",
+        severity: "error",
+        message: "Subtasks have no worker assigned (implementer / tester / reviewer)."
+      });
+      suggestions.push("Prefix each subtask with the responsible worker.");
+    }
+    const vague = subtaskItems.filter((it) => !isConcrete(it)).length;
+    if (vague > 0) {
+      issues.push({
+        code: "vague-subtask",
+        severity: "warning",
+        message: `${vague} subtask(s) lack a concrete description (placeholder or too short).`
+      });
+    }
+  }
+  const files = extractPaths(plan);
+  if (input.workspace && files.length > 0) {
+    const known = knownModules(input.workspace);
+    const outside = [...new Set(files.filter((f) => !known.has(topSegment(f))))];
+    if (outside.length > 0) {
+      riskFlags.push(`Touches files outside known modules: ${outside.join(", ")}`);
+      suggestions.push("Confirm these paths are intended; they are not in the workspace map.");
+    }
+  }
+  const sensitive = SENSITIVE_RE.test(plan) || files.some((f) => SENSITIVE_PATH_RE.test(f));
+  const hasRisk = listItems(getSection(sec, "risk")).filter(isConcrete).length > 0;
+  if (sensitive) {
+    riskFlags.push("References a sensitive area (auth / payments / migrations / secrets).");
+    if (!hasRisk) {
+      issues.push({
+        code: "missing-risk-assessment",
+        severity: "error",
+        message: "Touches a sensitive area but has no risk assessment in the Risks section."
+      });
+      suggestions.push('Add a concrete entry under "## Risks" describing the risk and mitigation.');
+    }
+  }
+  return { issues, suggestions, riskFlags };
+}
+function sections(plan) {
+  const map = /* @__PURE__ */ new Map([["", []]]);
+  let current = "";
+  for (const line of plan.split("\n")) {
+    const heading = line.match(/^#{1,6}\s+(.*)$/);
+    if (heading) {
+      current = (heading[1] ?? "").trim().toLowerCase();
+      if (!map.has(current)) map.set(current, []);
+    } else {
+      map.get(current)?.push(line);
+    }
+  }
+  return map;
+}
+function getSection(map, name) {
+  for (const [heading, lines] of map) {
+    if (heading.includes(name)) return lines;
+  }
+  return [];
+}
+function listItems(lines) {
+  const items = [];
+  for (const line of lines) {
+    const m = line.match(/^\s*(?:\d+\.|[-*])\s+(.*)$/);
+    if (m) items.push((m[1] ?? "").trim());
+  }
+  return items;
+}
+function isConcrete(item) {
+  const stripped = item.replace(/<!--.*?-->/g, "").replace(/\[[ xX]?\]/g, "").replace(/\*\*/g, "").trim();
+  if (stripped.length < 6) return false;
+  if (/^\.+$/.test(stripped)) return false;
+  if (PLACEHOLDER_RE.test(stripped)) return false;
+  return true;
+}
+function extractPaths(plan) {
+  const matches = plan.match(/[\w.@-]+(?:\/[\w.@-]+)+/g) ?? [];
+  return matches.filter((p) => !p.startsWith("http") && !p.includes("://"));
+}
+function topSegment(path) {
+  const clean = path.replace(/^\.\//, "").replace(/^\//, "");
+  return clean.split("/")[0] ?? clean;
+}
+function knownModules(ws) {
+  const known = new Set(DEFAULT_MODULES);
+  for (const dir of ws.folderMap) known.add(dir);
+  for (const p of ws.projects) {
+    if (p.path !== ".") known.add(topSegment(p.path));
+  }
+  return known;
+}
+
+// src/plan/reviewer.ts
+var Reviewer = class {
+  review(input) {
+    const { issues, suggestions, riskFlags } = validatePlan(input);
+    const approved = !issues.some((i) => i.severity === "error");
+    return { approved, issues, suggestions, riskFlags };
+  }
+};
+
+// src/plan/template.ts
+function suggestSubtasks() {
+  return [
+    {
+      title: "Implement the change",
+      worker: "implementer",
+      description: "<!-- what to build; keep it concrete -->",
+      filesLikelyTouched: []
+    },
+    {
+      title: "Write or extend tests",
+      worker: "tester",
+      description: "<!-- which behaviours to cover with tests -->",
+      filesLikelyTouched: []
+    }
+  ];
+}
+function suggestFilesLikelyTouched(workspace) {
+  if (!workspace) return [];
+  const fromProjects = workspace.projects.filter((p) => p.path !== ".").map((p) => p.path);
+  return fromProjects.length > 0 ? fromProjects : workspace.folderMap.map((d) => `${d}/`);
+}
+function generatePlanTemplate(input) {
+  const files = suggestFilesLikelyTouched(input.workspace);
+  const subtasks = suggestSubtasks();
+  const lines = [];
+  lines.push(`# Plan: ${input.task}`);
+  lines.push("");
+  if (input.context && input.context.trim().length > 0) {
+    lines.push("## Context");
+    lines.push("");
+    lines.push("<!-- Loaded context (from chamba_load_context). Use it; do not delete. -->");
+    lines.push(input.context.trim());
+    lines.push("");
+  }
+  lines.push("## Goal");
+  lines.push("");
+  lines.push('<!-- One sentence: what does "done" look like? -->');
+  lines.push("");
+  lines.push("## Acceptance criteria");
+  lines.push("");
+  lines.push("- [ ] <!-- a concrete, checkable criterion -->");
+  lines.push("- [ ] Tests cover the new behaviour");
+  lines.push("");
+  lines.push("## Subtasks");
+  lines.push("");
+  subtasks.forEach((s, i) => {
+    lines.push(`${i + 1}. **${s.worker}** \u2014 ${s.title}`);
+    lines.push(`   - ${s.description}`);
+    lines.push("   - files likely touched: <!-- list paths -->");
+  });
+  lines.push("");
+  lines.push("## Risks");
+  lines.push("");
+  lines.push("<!-- Flag anything touching auth, payments, or database migrations. -->");
+  lines.push('- <!-- risk or "none identified" -->');
+  lines.push("");
+  lines.push("## Files likely touched");
+  lines.push("");
+  if (files.length > 0) {
+    for (const f of files) lines.push(`- \`${f}\``);
+  } else {
+    lines.push("- <!-- list the files/modules this will change -->");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/testing/fake-process.ts
+var FakeProcess = class {
+  constructor(handler = () => ({})) {
+    this.handler = handler;
+  }
+  handler;
+  calls = [];
+  async exec(command, args, options) {
+    this.calls.push({ command, args, cwd: options?.cwd });
+    const out = this.handler(command, args);
+    return { stdout: out.stdout ?? "", stderr: out.stderr ?? "", exitCode: out.exitCode ?? 0 };
+  }
+};
+
+// src/testing/memory-filesystem.ts
+var MemoryFilesystem = class {
+  files = /* @__PURE__ */ new Map();
+  dirs = /* @__PURE__ */ new Set();
+  constructor(initial = {}) {
+    for (const [path, content] of Object.entries(initial)) {
+      this.set(path, content);
+    }
+  }
+  norm(path) {
+    const n = path.replace(/\/+$/, "");
+    return n.length === 0 ? "/" : n;
+  }
+  set(path, content) {
+    const norm = this.norm(path);
+    this.files.set(norm, content);
+    let dir = norm;
+    while (dir.includes("/")) {
+      const idx = dir.lastIndexOf("/");
+      dir = idx === 0 ? "/" : dir.slice(0, idx);
+      this.dirs.add(dir);
+      if (dir === "/") break;
+    }
+  }
+  async readFile(path) {
+    const content = this.files.get(this.norm(path));
+    if (content === void 0) throw new Error(`ENOENT: no such file '${path}'`);
+    return content;
+  }
+  async writeFile(path, content) {
+    this.set(path, content);
+  }
+  async exists(path) {
+    const norm = this.norm(path);
+    return this.files.has(norm) || this.dirs.has(norm);
+  }
+  async mkdir(path) {
+    this.dirs.add(this.norm(path));
+  }
+  async remove(path) {
+    const norm = this.norm(path);
+    this.files.delete(norm);
+    this.dirs.delete(norm);
+    const prefix = `${norm}/`;
+    for (const file of [...this.files.keys()]) {
+      if (file.startsWith(prefix)) this.files.delete(file);
+    }
+    for (const dir of [...this.dirs]) {
+      if (dir.startsWith(prefix)) this.dirs.delete(dir);
+    }
+  }
+  async readDir(path) {
+    const norm = this.norm(path);
+    const prefix = norm === "/" ? "/" : `${norm}/`;
+    const seen = /* @__PURE__ */ new Set();
+    const entries = [];
+    const pushChild = (full, isDir) => {
+      if (!full.startsWith(prefix) || full === norm) return;
+      const rest = full.slice(prefix.length);
+      const slash = rest.indexOf("/");
+      const name = slash === -1 ? rest : rest.slice(0, slash);
+      const childIsDir = slash !== -1 || isDir;
+      if (name.length === 0 || seen.has(name)) return;
+      seen.add(name);
+      entries.push({ name, isDirectory: childIsDir, isFile: !childIsDir });
+    };
+    for (const file of this.files.keys()) pushChild(file, false);
+    for (const dir of this.dirs) pushChild(dir, true);
+    return entries;
+  }
+};
+
+// src/workspace/context-builder.ts
+var DEFAULT_MAX_TOKENS = 2e3;
+var NOTE_SCAN_MAX_DEPTH = 8;
+var MAX_NOTES = 5;
+var SKIP_DIRS = /* @__PURE__ */ new Set([".obsidian", ".trash", "node_modules", ".git"]);
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "add",
+  "use",
+  "that",
+  "this",
+  "into",
+  "from",
+  "all",
+  "can",
+  "should",
+  "una",
+  "unos",
+  "para",
+  "con",
+  "los",
+  "las",
+  "del"
+]);
+var ContextBuilder = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  async build(input) {
+    const sections2 = [this.workspaceSection(input.workspace)];
+    let relevantNotes = [];
+    if (input.vaultPath) {
+      const notes = await this.searchNotes(input.vaultPath, input.task);
+      relevantNotes = notes.map((n) => n.path);
+      sections2.push(this.notesSection(notes));
+    }
+    const maxChars = (input.maxTokens ?? DEFAULT_MAX_TOKENS) * 4;
+    const context = clamp(sections2.join("\n\n"), maxChars);
+    return { context, relevantNotes };
+  }
+  workspaceSection(ws) {
+    const lines = ["## Workspace context", "", ws.description.trim()];
+    if (ws.languages.length > 0) lines.push("", `Languages: ${ws.languages.join(", ")}`);
+    if (ws.framework) lines.push(`Framework: ${ws.framework}`);
+    if (ws.projects.length > 0) {
+      lines.push("", "Projects:");
+      for (const p of ws.projects) lines.push(`- ${p.name} (\`${p.path}\`)`);
+    }
+    return lines.join("\n");
+  }
+  notesSection(notes) {
+    if (notes.length === 0) {
+      return "## Relevant notes\n\nNo vault notes matched this task.";
+    }
+    const lines = ["## Relevant notes", ""];
+    for (const note of notes) {
+      lines.push(`- \`${note.path}\` \u2014 ${note.snippet}`);
+    }
+    return lines.join("\n");
+  }
+  async searchNotes(vaultPath, task) {
+    const keywords = extractKeywords(task);
+    if (keywords.length === 0) return [];
+    const files = await this.collectMarkdown(vaultPath);
+    const scored = [];
+    for (const file of files) {
+      const text = await this.tryRead(file);
+      if (text === null) continue;
+      const lower = text.toLowerCase();
+      let score = 0;
+      for (const kw of keywords) {
+        score += occurrences(lower, kw);
+      }
+      if (score > 0) {
+        scored.push({ path: file, score, snippet: firstMatchingLine(text, keywords) });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, MAX_NOTES);
+  }
+  async collectMarkdown(root) {
+    const out = [];
+    const visit = async (dir, depth) => {
+      if (depth > NOTE_SCAN_MAX_DEPTH) return;
+      let entries;
+      try {
+        entries = await this.fs.readDir(dir);
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        const full = joinPath(dir, entry.name);
+        if (entry.isDirectory) {
+          if (SKIP_DIRS.has(entry.name)) continue;
+          await visit(full, depth + 1);
+        } else if (entry.name.toLowerCase().endsWith(".md")) {
+          out.push(full);
+        }
+      }
+    };
+    await visit(root, 0);
+    return out;
+  }
+  async tryRead(path) {
+    try {
+      return await this.fs.readFile(path);
+    } catch {
+      return null;
+    }
+  }
+};
+function extractKeywords(task) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of task.toLowerCase().split(/[^a-z0-9áéíóúñ]+/i)) {
+    const w = raw.trim();
+    if (w.length >= 3 && !STOPWORDS.has(w)) seen.add(w);
+  }
+  return [...seen];
+}
+function occurrences(haystack, needle) {
+  if (needle.length === 0) return 0;
+  let count = 0;
+  let idx = haystack.indexOf(needle);
+  while (idx !== -1) {
+    count++;
+    idx = haystack.indexOf(needle, idx + needle.length);
+  }
+  return count;
+}
+function firstMatchingLine(text, keywords) {
+  for (const raw of text.split("\n")) {
+    const line = raw.trim();
+    if (line.length === 0) continue;
+    const lower = line.toLowerCase();
+    if (keywords.some((kw) => lower.includes(kw))) {
+      return line.length > 120 ? `${line.slice(0, 117)}...` : line;
+    }
+  }
+  return "(matched)";
+}
+function clamp(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+}
+
+// src/workspace/diff.ts
+function diffLines(oldText, newText) {
+  const a = oldText.split("\n");
+  const b = newText.split("\n");
+  const n = a.length;
+  const m = b.length;
+  const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    const row = dp[i2];
+    const next = dp[i2 + 1];
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      row[j2] = a[i2] === b[j2] ? next[j2 + 1] + 1 : Math.max(next[j2], row[j2 + 1]);
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      out.push(`  ${a[i]}`);
+      i++;
+      j++;
+    } else if ((dp[i + 1]?.[j] ?? 0) >= (dp[i]?.[j + 1] ?? 0)) {
+      out.push(`- ${a[i]}`);
+      i++;
+    } else {
+      out.push(`+ ${b[j]}`);
+      j++;
+    }
+  }
+  while (i < n) out.push(`- ${a[i++]}`);
+  while (j < m) out.push(`+ ${b[j++]}`);
+  return out.join("\n");
+}
+function textsEqual(oldText, newText) {
+  return oldText === newText;
+}
+
+// src/workspace/obsidian-detector.ts
+var COUNT_MAX_DEPTH = 8;
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([".obsidian", ".trash", "node_modules", ".git"]);
+var ObsidianDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  async detect(opts) {
+    if (opts.explicitPath) {
+      if (await this.fs.exists(opts.explicitPath)) {
+        return {
+          found: true,
+          path: opts.explicitPath,
+          noteCount: await this.countNotes(opts.explicitPath)
+        };
+      }
+      return { found: false };
+    }
+    for (const root of opts.searchRoots ?? []) {
+      if (await this.fs.exists(joinPath(root, ".obsidian"))) {
+        return { found: true, path: root, noteCount: await this.countNotes(root) };
+      }
+    }
+    return { found: false };
+  }
+  async countNotes(vault) {
+    let count = 0;
+    const visit = async (dir, depth) => {
+      if (depth > COUNT_MAX_DEPTH) return;
+      let entries;
+      try {
+        entries = await this.fs.readDir(dir);
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory) {
+          if (SKIP_DIRS2.has(entry.name)) continue;
+          await visit(joinPath(dir, entry.name), depth + 1);
+        } else if (entry.name.toLowerCase().endsWith(".md")) {
+          count++;
+        }
+      }
+    };
+    await visit(vault, 0);
+    return count;
+  }
+};
+
+// src/workspace/scanner.ts
+var MAX_DEPTH = 6;
+var DEFAULT_IGNORES = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".turbo",
+  ".cache",
+  ".DS_Store"
+];
+var LANGUAGE_BY_EXT = {
+  ".ts": "TypeScript",
+  ".tsx": "TypeScript",
+  ".mts": "TypeScript",
+  ".cts": "TypeScript",
+  ".js": "JavaScript",
+  ".jsx": "JavaScript",
+  ".mjs": "JavaScript",
+  ".cjs": "JavaScript",
+  ".py": "Python",
+  ".rs": "Rust",
+  ".go": "Go",
+  ".rb": "Ruby",
+  ".java": "Java",
+  ".kt": "Kotlin",
+  ".php": "PHP",
+  ".cs": "C#",
+  ".swift": "Swift",
+  ".c": "C",
+  ".cpp": "C++",
+  ".sh": "Shell"
+};
+var MANIFEST_FILES = /* @__PURE__ */ new Set(["package.json", "pyproject.toml", "Cargo.toml", "go.mod"]);
+var FRAMEWORKS = [
+  ["next", "Next.js"],
+  ["@nestjs/core", "NestJS"],
+  ["@angular/core", "Angular"],
+  ["remix", "Remix"],
+  ["astro", "Astro"],
+  ["svelte", "Svelte"],
+  ["vue", "Vue"],
+  ["react", "React"],
+  ["hono", "Hono"],
+  ["fastify", "Fastify"],
+  ["express", "Express"]
+];
+var PY_FRAMEWORKS = [
+  ["django", "Django"],
+  ["fastapi", "FastAPI"],
+  ["flask", "Flask"]
+];
+var WorkspaceScanner = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  async scan(root) {
+    const rules = await this.loadIgnoreRules(root);
+    const acc = { topDirs: /* @__PURE__ */ new Set(), exts: /* @__PURE__ */ new Set(), manifests: [] };
+    await this.walk(root, "", 0, rules, acc);
+    const languages = this.detectLanguages(acc.exts);
+    const projects = await this.detectProjects(root, acc.manifests, languages);
+    const rootProject = projects.find((p) => p.path === ".");
+    const framework = rootProject?.framework ?? projects.find((p) => p.framework)?.framework;
+    const conventions = await this.detectConventions(root);
+    const description = await this.detectDescription(root, rootProject, framework, languages);
+    return {
+      root,
+      description,
+      languages,
+      framework,
+      conventions,
+      projects,
+      folderMap: [...acc.topDirs].sort()
+    };
+  }
+  async loadIgnoreRules(root) {
+    const patterns = [...DEFAULT_IGNORES];
+    for (const file of [".gitignore", ".dockerignore"]) {
+      const text = await this.tryRead(joinPath(root, file));
+      if (text !== null) patterns.push(...parseIgnoreFile(text));
+    }
+    return patterns.map(compileIgnore);
+  }
+  async walk(root, rel, depth, rules, acc) {
+    if (depth > MAX_DEPTH) return;
+    const dirPath = rel.length > 0 ? joinPath(root, rel) : root;
+    let entries;
+    try {
+      entries = await this.fs.readDir(dirPath);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const childRel = rel.length > 0 ? `${rel}/${entry.name}` : entry.name;
+      if (isIgnored(rules, childRel, entry.isDirectory)) continue;
+      if (entry.isDirectory) {
+        if (depth === 0) acc.topDirs.add(entry.name);
+        await this.walk(root, childRel, depth + 1, rules, acc);
+      } else {
+        const ext = extname(entry.name);
+        if (ext.length > 0) acc.exts.add(ext);
+        if (MANIFEST_FILES.has(entry.name)) acc.manifests.push(childRel);
+      }
+    }
+  }
+  detectLanguages(exts) {
+    const langs = /* @__PURE__ */ new Set();
+    for (const ext of exts) {
+      const lang = LANGUAGE_BY_EXT[ext];
+      if (lang) langs.add(lang);
+    }
+    return [...langs].sort();
+  }
+  async detectProjects(root, manifests, languages) {
+    const projects = [];
+    for (const manifestRel of manifests) {
+      const dir = dirname(manifestRel);
+      const name = basename(manifestRel);
+      const project = await this.readProject(root, manifestRel, dir, name, languages);
+      if (project) projects.push(project);
+    }
+    projects.sort(
+      (a, b) => a.path === "." ? -1 : b.path === "." ? 1 : a.path.localeCompare(b.path)
+    );
+    return projects;
+  }
+  async readProject(root, manifestRel, dir, manifestName, languages) {
+    const path = dir.length === 0 ? "." : dir;
+    const fallbackName = path === "." ? basename(root) : basename(dir);
+    if (manifestName === "package.json") {
+      const text = await this.tryRead(joinPath(root, manifestRel));
+      const pkg = text !== null ? safeJsonParse(text) : null;
+      const name = typeof pkg?.name === "string" && pkg.name.length > 0 ? pkg.name : fallbackName;
+      const language = languages.includes("TypeScript") ? "TypeScript" : "JavaScript";
+      return { name, path, language, framework: detectNodeFramework(pkg) };
+    }
+    if (manifestName === "pyproject.toml") {
+      const text = await this.tryRead(joinPath(root, manifestRel)) ?? "";
+      return {
+        name: tomlName(text) ?? fallbackName,
+        path,
+        language: "Python",
+        framework: detectPyFramework(text)
+      };
+    }
+    if (manifestName === "Cargo.toml") {
+      const text = await this.tryRead(joinPath(root, manifestRel)) ?? "";
+      return { name: tomlName(text) ?? fallbackName, path, language: "Rust" };
+    }
+    if (manifestName === "go.mod") {
+      return { name: fallbackName, path, language: "Go" };
+    }
+    return null;
+  }
+  async detectConventions(root) {
+    const conventions = [];
+    const has = (file) => this.fs.exists(joinPath(root, file));
+    if (await has("pnpm-workspace.yaml")) conventions.push("pnpm workspaces (monorepo)");
+    if (await has("biome.json")) conventions.push("Biome for lint + format");
+    if (await has("vitest.config.ts") || await has("vitest.config.js")) {
+      conventions.push("Vitest for tests");
+    }
+    if (await has("tsconfig.json")) conventions.push("TypeScript with shared tsconfig");
+    if (await has(".editorconfig")) conventions.push("EditorConfig");
+    const nvmrc = await this.tryRead(joinPath(root, ".nvmrc"));
+    if (nvmrc !== null) conventions.push(`Node ${nvmrc.trim()}`);
+    return conventions;
+  }
+  async detectDescription(root, rootProject, framework, languages) {
+    const readme = await this.findReadme(root);
+    if (readme !== null) {
+      const line = firstProseLine(readme);
+      if (line.length > 0) return line;
+    }
+    const name = rootProject?.name ?? basename(root);
+    const stack = framework ?? languages[0] ?? "project";
+    return `${name} \u2014 a ${stack} project.`;
+  }
+  async findReadme(root) {
+    let entries;
+    try {
+      entries = await this.fs.readDir(root);
+    } catch {
+      return null;
+    }
+    const readme = entries.find((e) => e.isFile && /^readme(\.|$)/i.test(e.name));
+    if (!readme) return null;
+    return this.tryRead(joinPath(root, readme.name));
+  }
+  async tryRead(path) {
+    try {
+      return await this.fs.readFile(path);
+    } catch {
+      return null;
+    }
+  }
+};
+function parseIgnoreFile(text) {
+  return text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#") && !l.startsWith("!"));
+}
+function compileIgnore(pattern) {
+  let p = pattern;
+  const dirOnly = p.endsWith("/");
+  if (dirOnly) p = p.slice(0, -1);
+  const leadingSlash = p.startsWith("/");
+  if (leadingSlash) p = p.slice(1);
+  const anchored = leadingSlash || p.includes("/");
+  return { re: new RegExp(`^${globToRegExp(p)}$`), anchored, dirOnly };
+}
+function globToRegExp(glob) {
+  let out = "";
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i];
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        out += ".*";
+        i++;
+      } else {
+        out += "[^/]*";
+      }
+    } else if (ch === "?") {
+      out += "[^/]";
+    } else if (/[.+^$(){}|[\]\\]/.test(ch)) {
+      out += `\\${ch}`;
+    } else {
+      out += ch;
+    }
+  }
+  return out;
+}
+function isIgnored(rules, relPath, isDir) {
+  const base = basename(relPath);
+  for (const rule of rules) {
+    if (rule.dirOnly && !isDir) continue;
+    const target = rule.anchored ? relPath : base;
+    if (rule.re.test(target)) return true;
+  }
+  return false;
+}
+function safeJsonParse(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function detectNodeFramework(pkg) {
+  if (!pkg) return void 0;
+  const deps = {
+    ...asRecord(pkg.dependencies) ?? {},
+    ...asRecord(pkg.devDependencies) ?? {}
+  };
+  for (const [dep, label] of FRAMEWORKS) {
+    if (dep in deps) return label;
+  }
+  return void 0;
+}
+function tomlName(toml) {
+  const match = toml.match(/^\s*name\s*=\s*["']([^"']+)["']/m);
+  return match?.[1];
+}
+function detectPyFramework(pyproject) {
+  const lower = pyproject.toLowerCase();
+  for (const [dep, label] of PY_FRAMEWORKS) {
+    if (lower.includes(dep)) return label;
+  }
+  return void 0;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function firstProseLine(markdown) {
+  for (const raw of markdown.split("\n")) {
+    const line = raw.trim().replace(/^>\s?/, "").trim();
+    if (line.length === 0) continue;
+    if (line.startsWith("#")) continue;
+    if (line.startsWith("![") || line.startsWith("<")) continue;
+    return line.length > 200 ? `${line.slice(0, 197)}...` : line;
+  }
+  return "";
+}
+
+// src/worktree/branch-naming.ts
+function slugifyForGit(value) {
+  const slug = value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/\.\.+/g, "-").replace(/^[-.]+|[-.]+$/g, "");
+  return slug.length > 0 ? slug : "x";
+}
+function buildBranchName(input) {
+  return `chamba/${input.date}-${slugifyForGit(input.taskSlug)}/${slugifyForGit(input.workerId)}`;
+}
+function worktreeRelativePath(taskSlug, workerId) {
+  return joinPath(WORKSPACE_DIR, "worktrees", slugifyForGit(taskSlug), slugifyForGit(workerId));
+}
+
+// src/worktree/git-detector.ts
+var GitDetector = class {
+  constructor(process) {
+    this.process = process;
+  }
+  process;
+  cache = /* @__PURE__ */ new Map();
+  async isGitRepo(root) {
+    const cached = this.cache.get(root);
+    if (cached !== void 0) return cached;
+    const result = await this.process.exec("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: root
+    });
+    const isRepo = result.exitCode === 0 && result.stdout.trim() === "true";
+    this.cache.set(root, isRepo);
+    return isRepo;
+  }
+};
+
+// src/worktree/manager.ts
+var WorktreeError = class extends Error {
+  name = "WorktreeError";
+};
+var WorktreeManager = class {
+  constructor(process) {
+    this.process = process;
+  }
+  process;
+  async create(input) {
+    const branch = buildBranchName({
+      date: input.date,
+      taskSlug: input.taskSlug,
+      workerId: input.workerId
+    });
+    const path = joinPath(input.root, worktreeRelativePath(input.taskSlug, input.workerId));
+    const args = ["worktree", "add", "-b", branch, path];
+    if (input.baseBranch) args.push(input.baseBranch);
+    const result = await this.process.exec("git", args, { cwd: input.root });
+    if (result.exitCode !== 0) {
+      throw new WorktreeError(
+        `git worktree add failed: ${result.stderr.trim() || "unknown error"}`
+      );
+    }
+    return { branch, path, taskSlug: input.taskSlug, workerId: input.workerId };
+  }
+  async list(root) {
+    const result = await this.process.exec("git", ["worktree", "list", "--porcelain"], {
+      cwd: root
+    });
+    if (result.exitCode !== 0) return [];
+    return parsePorcelain(result.stdout);
+  }
+  async cleanup(root, branch) {
+    const worktrees = await this.list(root);
+    const target = worktrees.find((w) => w.branch === branch);
+    if (!target) {
+      throw new WorktreeError(`No worktree found for branch '${branch}'.`);
+    }
+    const result = await this.process.exec("git", ["worktree", "remove", target.path], {
+      cwd: root
+    });
+    if (result.exitCode !== 0) {
+      throw new WorktreeError(
+        `git worktree remove failed (uncommitted changes?): ${result.stderr.trim() || "unknown error"}`
+      );
+    }
+    return { removed: true, branchKept: true, mergeSuggestion: `git merge --no-ff ${branch}` };
+  }
+};
+function parsePorcelain(output) {
+  const result = [];
+  for (const block of output.split(/\n\s*\n/)) {
+    let path;
+    let head;
+    let branch;
+    for (const raw of block.split("\n")) {
+      const line = raw.trim();
+      if (line.startsWith("worktree ")) path = line.slice("worktree ".length);
+      else if (line.startsWith("HEAD ")) head = line.slice("HEAD ".length);
+      else if (line.startsWith("branch "))
+        branch = line.slice("branch ".length).replace(/^refs\/heads\//, "");
+    }
+    if (path) result.push({ path, head, branch });
+  }
+  return result;
+}
+export {
+  ContextBuilder,
+  FakeProcess,
+  FilesystemMemoryStore,
+  GitDetector,
+  MEMORY_DIR,
+  MemoryFilesystem,
+  ObsidianDetector,
+  Reviewer,
+  VAULT_NOTES_DIR,
+  VaultWriter,
+  WORKSPACE_DIR,
+  WORKSPACE_FILE,
+  WORKSPACE_RELATIVE_PATH,
+  WorkspaceScanner,
+  WorktreeError,
+  WorktreeManager,
+  basename,
+  buildBranchName,
+  diffLines,
+  dirname,
+  extname,
+  generatePlanTemplate,
+  joinPath,
+  renderNote,
+  renderWorkspaceMarkdown,
+  slugify,
+  slugifyForGit,
+  suggestFilesLikelyTouched,
+  suggestSubtasks,
+  textsEqual,
+  validatePlan,
+  worktreeRelativePath
+};