@chamba/core 0.3.1 → 0.4.0

package/dist/index.d.ts

@@ -420,6 +420,40 @@ declare class VaultWriter {
     write(input: WriteNoteInput): Promise<WriteNoteResult>;
 }
 
+interface RuleConvention {
+    editor: string;
+    /** Path relative to a repo root. */
+    path: string;
+    kind: 'file' | 'dir';
+}
+declare const RULE_SOURCES: readonly RuleConvention[];
+/** A concrete rule file found in a repo. */
+interface RuleSource {
+    /** Repo path relative to the workspace root (`.` for the root itself). */
+    repo: string;
+    editor: string;
+    /** Rule file path relative to the workspace root. */
+    path: string;
+}
+interface RuleExcerpt {
+    source: RuleSource;
+    excerpt: string;
+}
+/**
+ * Discover coding-rule files across the workspace root and each repo, for every
+ * editor convention in the catalog. Non-exclusive: a repo can match several.
+ * `repoDirs` are paths relative to the workspace root (`.` for the root).
+ */
+declare function detectRuleSources(fs: FilesystemPort, workspaceRoot: string, repoDirs: string[]): Promise<RuleSource[]>;
+/**
+ * Read each rule file fresh and return a clamped excerpt, bounded by a total
+ * budget so rules never crowd out the rest of the context.
+ */
+declare function readRuleExcerpts(fs: FilesystemPort, workspaceRoot: string, sources: RuleSource[], opts?: {
+    maxCharsPerRule?: number;
+    totalBudget?: number;
+}): Promise<RuleExcerpt[]>;
+
 /** Relative path (from workspace root) of the chamba workspace file. */
 declare const WORKSPACE_DIR = ".chamba";
 declare const WORKSPACE_FILE = "workspace.md";
@@ -438,6 +472,8 @@ interface Workspace {
     framework?: string;
     conventions: string[];
     projects: ProjectRef[];
+    /** Coding-rule files found across repos (Cursor, Claude, Trae, …). */
+    ruleSources: RuleSource[];
     /** Top-level directory names (without trailing slash), sorted. */
     folderMap: string[];
 }
@@ -588,6 +624,8 @@ interface ContextBuildInput {
     task: string;
     /** When set, search this Obsidian vault for notes relevant to the task. */
     vaultPath?: string;
+    /** Include a section with each repo's coding rules (default true). */
+    includeRules?: boolean;
     /** Soft cap on the produced context, in estimated tokens (~4 chars/token). */
     maxTokens?: number;
 }
@@ -604,12 +642,19 @@ declare class ContextBuilder {
     private readonly fs;
     constructor(fs: FilesystemPort);
     build(input: ContextBuildInput): Promise<BuiltContext>;
+    /** Each repo's coding rules (read fresh, clamped), non-exclusive across editors. */
+    private codingRulesSection;
     private workspaceSection;
     private notesSection;
     private searchNotes;
     private collectMarkdown;
     private tryRead;
 }
+/**
+ * All markdown notes under a vault (the same set `chamba_load_context` searches),
+ * skipping `.obsidian`, `.trash`, etc. Useful to show what chamba actually sees.
+ */
+declare function listVaultNotes(fs: FilesystemPort, root: string): Promise<string[]>;
 
 /**
  * Line-based diff (LCS) producing a readable unified-ish output:
@@ -627,6 +672,13 @@ interface VaultDetection {
     path?: string;
     noteCount?: number;
 }
+/**
+ * The vault is the directory that *contains* `.obsidian` — never `.obsidian`
+ * itself. A common mistake is to point `CHAMBA_OBSIDIAN_VAULT_PATH` at the
+ * `.obsidian` folder; correct it to its parent so writes and note search land
+ * in the real vault.
+ */
+declare function normalizeVaultPath(path: string): string;
 interface DetectOptions {
     /** Explicit vault path (e.g. from CHAMBA_OBSIDIAN_VAULT_PATH). Authoritative. */
     explicitPath?: string;
@@ -835,4 +887,4 @@ declare class MultiRepoWorktreeManager {
     private git;
 }
 
-export { AGENT_ROLES, type AgentConfig, type AgentRole, type BranchNameInput, type BuiltContext, type ChambaConfig, type CleanupMultiResult, type CleanupResult, type ClockPort, ConfigError, type ConfigFile, type ConfigSource, type ConfigSourceKind, type ContextBuildInput, ContextBuilder, type CreateMultiInput, type CreateWorktreeInput, DEFAULT_CONFIG, DEFAULT_WORKTREE_CONFIG, type DetectOptions, type DirEntry, EFFORT_LEVELS, type Effort, FakeProcess, FilesystemMemoryStore, type FilesystemPort, type GeneratePlanInput, GitDetector, type Issue, type IssueSeverity, type ListedWorktree, type LoadConfigOptions, type LoadConfigResult, MEMORY_DIR, MODEL_CATALOG, type Memory, MemoryFilesystem, type MemoryStore, type ModelInfo, type ModelProvider, MultiRepoWorktreeManager, type MultiRepoWorktreeResult, type NoteFields, ObsidianDetector, type ParseResult, type PartialWorktreeConfig, type PlanReview, type PlanWorktreesInput, type ProcessExecOptions, type ProcessHandler, type ProcessPort, type ProcessResult, type ProjectRef, REASONING_PRIORITIES, ROLE_DESCRIPTIONS, type ReasoningPriority, type RecordedCall, type RelevantNote, type RememberInput, type ResolvedConfig, type ReviewInput, Reviewer, type SubtaskSpec, VAULT_NOTES_DIR, type ValidatePlanInput, type ValidationResult, type VaultDetection, VaultWriter, WORKSPACE_DIR, WORKSPACE_FILE, WORKSPACE_RELATIVE_PATH, type WorkerKind, type Workspace, WorkspaceScanner, type WorktreeConfig, WorktreeError, type WorktreeHandle, type WorktreeLayout, WorktreeManager, type WorktreePlanItem, type WorktreeStatus, type WriteNoteInput, type WriteNoteResult, basename, buildBranchName, buildHint, buildTicketBranch, configFileSchema, copyEnvFiles, detectGitRepos, diffLines, dirname, editorWorkspaceContent, editorWorkspaceDir, extname, generatePlanTemplate, getModel, joinPath, loadConfig, modelsByProvider, parseChambaConfig, planWorktrees, renderNote, renderWorkspaceMarkdown, resolveEffort, resolveRole, resolveWorktreeConfig, safeTicket, slugify, slugifyForGit, suggestFilesLikelyTouched, suggestSubtasks, textsEqual, validatePlan, worktreeConfigSchema, worktreePathFor, worktreeRelativePath, writeEditorWorkspace };
+export { AGENT_ROLES, type AgentConfig, type AgentRole, type BranchNameInput, type BuiltContext, type ChambaConfig, type CleanupMultiResult, type CleanupResult, type ClockPort, ConfigError, type ConfigFile, type ConfigSource, type ConfigSourceKind, type ContextBuildInput, ContextBuilder, type CreateMultiInput, type CreateWorktreeInput, DEFAULT_CONFIG, DEFAULT_WORKTREE_CONFIG, type DetectOptions, type DirEntry, EFFORT_LEVELS, type Effort, FakeProcess, FilesystemMemoryStore, type FilesystemPort, type GeneratePlanInput, GitDetector, type Issue, type IssueSeverity, type ListedWorktree, type LoadConfigOptions, type LoadConfigResult, MEMORY_DIR, MODEL_CATALOG, type Memory, MemoryFilesystem, type MemoryStore, type ModelInfo, type ModelProvider, MultiRepoWorktreeManager, type MultiRepoWorktreeResult, type NoteFields, ObsidianDetector, type ParseResult, type PartialWorktreeConfig, type PlanReview, type PlanWorktreesInput, type ProcessExecOptions, type ProcessHandler, type ProcessPort, type ProcessResult, type ProjectRef, REASONING_PRIORITIES, ROLE_DESCRIPTIONS, RULE_SOURCES, type ReasoningPriority, type RecordedCall, type RelevantNote, type RememberInput, type ResolvedConfig, type ReviewInput, Reviewer, type RuleConvention, type RuleExcerpt, type RuleSource, type SubtaskSpec, VAULT_NOTES_DIR, type ValidatePlanInput, type ValidationResult, type VaultDetection, VaultWriter, WORKSPACE_DIR, WORKSPACE_FILE, WORKSPACE_RELATIVE_PATH, type WorkerKind, type Workspace, WorkspaceScanner, type WorktreeConfig, WorktreeError, type WorktreeHandle, type WorktreeLayout, WorktreeManager, type WorktreePlanItem, type WorktreeStatus, type WriteNoteInput, type WriteNoteResult, basename, buildBranchName, buildHint, buildTicketBranch, configFileSchema, copyEnvFiles, detectGitRepos, detectRuleSources, diffLines, dirname, editorWorkspaceContent, editorWorkspaceDir, extname, generatePlanTemplate, getModel, joinPath, listVaultNotes, loadConfig, modelsByProvider, normalizeVaultPath, parseChambaConfig, planWorktrees, readRuleExcerpts, renderNote, renderWorkspaceMarkdown, resolveEffort, resolveRole, resolveWorktreeConfig, safeTicket, slugify, slugifyForGit, suggestFilesLikelyTouched, suggestSubtasks, textsEqual, validatePlan, worktreeConfigSchema, worktreePathFor, worktreeRelativePath, writeEditorWorkspace };

package/dist/index.js

@@ -415,6 +415,19 @@ function renderWorkspaceMarkdown(ws) {
     lines.push("_None detected._");
   }
   lines.push("");
+  lines.push("## Coding rules");
+  lines.push("");
+  lines.push("> Rule files found per repo (read non-exclusively across editors). chamba");
+  lines.push("> loads their content into context at task time.");
+  lines.push("");
+  if (ws.ruleSources.length > 0) {
+    for (const r of ws.ruleSources) {
+      lines.push(`- \`${r.path}\` \u2014 ${r.editor} (${r.repo})`);
+    }
+  } else {
+    lines.push("_None detected._");
+  }
+  lines.push("");
   lines.push("## Active projects");
   lines.push("");
   if (ws.projects.length > 0) {
@@ -904,12 +917,12 @@ var MemoryFilesystem = class {
     const prefix = norm === "/" ? "/" : `${norm}/`;
     const seen = /* @__PURE__ */ new Set();
     const entries = [];
-    const pushChild = (full, isDir) => {
+    const pushChild = (full, isDir2) => {
       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;
+      const childIsDir = slash !== -1 || isDir2;
       if (name.length === 0 || seen.has(name)) return;
       seen.add(name);
       entries.push({ name, isDirectory: childIsDir, isFile: !childIsDir });
@@ -920,6 +933,90 @@ var MemoryFilesystem = class {
   }
 };
 
+// src/workspace/rules.ts
+var RULE_SOURCES = [
+  { editor: "Cursor", path: ".cursor/rules", kind: "dir" },
+  { editor: "Cursor", path: ".cursorrules", kind: "file" },
+  { editor: "Claude Code", path: "CLAUDE.md", kind: "file" },
+  { editor: "Claude Code", path: ".claude/rules", kind: "dir" },
+  { editor: "Windsurf", path: ".windsurfrules", kind: "file" },
+  { editor: "Windsurf", path: ".windsurf/rules", kind: "dir" },
+  { editor: "Trae", path: ".trae/rules", kind: "dir" },
+  { editor: "Trae", path: ".trae/project_rules.md", kind: "file" },
+  { editor: "GitHub Copilot", path: ".github/copilot-instructions.md", kind: "file" },
+  { editor: "Cline", path: ".clinerules", kind: "file" },
+  { editor: "Agents", path: "AGENTS.md", kind: "file" }
+];
+function isRuleFile(name) {
+  const lower = name.toLowerCase();
+  return lower.endsWith(".md") || lower.endsWith(".mdc");
+}
+async function isDir(fs, path) {
+  try {
+    await fs.readDir(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectRuleSources(fs, workspaceRoot, repoDirs) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (repo, editor, relPath) => {
+    if (seen.has(relPath)) return;
+    seen.add(relPath);
+    found.push({ repo, editor, path: relPath });
+  };
+  for (const repo of repoDirs) {
+    const repoAbs = repo === "." ? workspaceRoot : joinPath(workspaceRoot, repo);
+    for (const conv of RULE_SOURCES) {
+      const abs = joinPath(repoAbs, conv.path);
+      const rel = repo === "." ? conv.path : joinPath(repo, conv.path);
+      if (conv.kind === "file") {
+        if (await fs.exists(abs)) add(repo, conv.editor, rel);
+        continue;
+      }
+      if (!await isDir(fs, abs)) continue;
+      let entries;
+      try {
+        entries = await fs.readDir(abs);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (entry.isFile && isRuleFile(entry.name)) {
+          add(repo, conv.editor, joinPath(rel, entry.name));
+        }
+      }
+    }
+  }
+  return found;
+}
+async function readRuleExcerpts(fs, workspaceRoot, sources, opts = {}) {
+  const maxPer = opts.maxCharsPerRule ?? 400;
+  const total = opts.totalBudget ?? 1500;
+  const out = [];
+  let used = 0;
+  for (const source of sources) {
+    if (used >= total) break;
+    let text;
+    try {
+      text = await fs.readFile(joinPath(workspaceRoot, source.path));
+    } catch {
+      continue;
+    }
+    const budget = Math.min(maxPer, total - used);
+    const excerpt = clampExcerpt(text.trim(), budget);
+    used += excerpt.length;
+    out.push({ source, excerpt });
+  }
+  return out;
+}
+function clampExcerpt(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+}
+
 // src/workspace/context-builder.ts
 var DEFAULT_MAX_TOKENS = 2e3;
 var NOTE_SCAN_MAX_DEPTH = 8;
@@ -955,6 +1052,9 @@ var ContextBuilder = class {
   async build(input) {
     const sections2 = [this.workspaceSection(input.workspace)];
     let relevantNotes = [];
+    if (input.includeRules !== false && input.workspace.ruleSources.length > 0) {
+      sections2.push(await this.codingRulesSection(input.workspace));
+    }
     if (input.vaultPath) {
       const notes = await this.searchNotes(input.vaultPath, input.task);
       relevantNotes = notes.map((n) => n.path);
@@ -964,6 +1064,22 @@ var ContextBuilder = class {
     const context = clamp(sections2.join("\n\n"), maxChars);
     return { context, relevantNotes };
   }
+  /** Each repo's coding rules (read fresh, clamped), non-exclusive across editors. */
+  async codingRulesSection(ws) {
+    const excerpts = await readRuleExcerpts(this.fs, ws.root, ws.ruleSources);
+    if (excerpts.length === 0) return "## Coding rules\n\nNo readable rule files.";
+    const lines = [
+      "## Coding rules",
+      "",
+      "Follow these per-repo rules (any editor). Read the full file for details:",
+      ""
+    ];
+    for (const { source, excerpt } of excerpts) {
+      lines.push(`### \`${source.path}\` \u2014 ${source.editor} (${source.repo})`);
+      lines.push("", excerpt, "");
+    }
+    return lines.join("\n").trimEnd();
+  }
   workspaceSection(ws) {
     const lines = ["## Workspace context", "", ws.description.trim()];
     if (ws.languages.length > 0) lines.push("", `Languages: ${ws.languages.join(", ")}`);
@@ -1005,27 +1121,7 @@ var ContextBuilder = class {
     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;
+    return listVaultNotes(this.fs, root);
   }
   async tryRead(path) {
     try {
@@ -1035,6 +1131,29 @@ var ContextBuilder = class {
     }
   }
 };
+async function listVaultNotes(fs, root) {
+  const out = [];
+  const visit = async (dir, depth) => {
+    if (depth > NOTE_SCAN_MAX_DEPTH) return;
+    let entries;
+    try {
+      entries = await 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;
+}
 function extractKeywords(task) {
   const seen = /* @__PURE__ */ new Set();
   for (const raw of task.toLowerCase().split(/[^a-z0-9áéíóúñ]+/i)) {
@@ -1108,6 +1227,10 @@ function textsEqual(oldText, newText) {
 }
 
 // src/workspace/obsidian-detector.ts
+function normalizeVaultPath(path) {
+  const trimmed = path.replace(/[/\\]+$/, "");
+  return basename(trimmed) === ".obsidian" ? dirname(trimmed) : trimmed;
+}
 var COUNT_MAX_DEPTH = 8;
 var SKIP_DIRS2 = /* @__PURE__ */ new Set([".obsidian", ".trash", "node_modules", ".git"]);
 var ObsidianDetector = class {
@@ -1117,12 +1240,9 @@ var ObsidianDetector = class {
   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)
-        };
+      const vault = normalizeVaultPath(opts.explicitPath);
+      if (await this.fs.exists(vault)) {
+        return { found: true, path: vault, noteCount: await this.countNotes(vault) };
       }
       return { found: false };
     }
@@ -1157,6 +1277,30 @@ var ObsidianDetector = class {
   }
 };
 
+// src/worktree/git-repo-detector.ts
+async function hasGitDir(fs, dir) {
+  try {
+    const entries = await fs.readDir(dir);
+    return entries.some((e) => e.name === ".git" && e.isDirectory);
+  } catch {
+    return false;
+  }
+}
+async function detectGitRepos(fs, workspaceRoot) {
+  let entries;
+  try {
+    entries = await fs.readDir(workspaceRoot);
+  } catch {
+    return [];
+  }
+  const repos = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory) continue;
+    if (await hasGitDir(fs, joinPath(workspaceRoot, entry.name))) repos.push(entry.name);
+  }
+  return repos.sort();
+}
+
 // src/workspace/scanner.ts
 var MAX_DEPTH = 6;
 var DEFAULT_IGNORES = [
@@ -1226,6 +1370,10 @@ var WorkspaceScanner = class {
     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);
+    const repoDirs = [
+      .../* @__PURE__ */ new Set([".", ...await detectGitRepos(this.fs, root), ...projects.map((p) => p.path)])
+    ];
+    const ruleSources = await detectRuleSources(this.fs, root, repoDirs);
     return {
       root,
       description,
@@ -1233,6 +1381,7 @@ var WorkspaceScanner = class {
       framework,
       conventions,
       projects,
+      ruleSources,
       folderMap: [...acc.topDirs].sort()
     };
   }
@@ -1392,10 +1541,10 @@ function globToRegExp(glob) {
   }
   return out;
 }
-function isIgnored(rules, relPath, isDir) {
+function isIgnored(rules, relPath, isDir2) {
   const base = basename(relPath);
   for (const rule of rules) {
-    if (rule.dirOnly && !isDir) continue;
+    if (rule.dirOnly && !isDir2) continue;
     const target = rule.anchored ? relPath : base;
     if (rule.re.test(target)) return true;
   }
@@ -1559,30 +1708,6 @@ var GitDetector = class {
   }
 };
 
-// src/worktree/git-repo-detector.ts
-async function hasGitDir(fs, dir) {
-  try {
-    const entries = await fs.readDir(dir);
-    return entries.some((e) => e.name === ".git" && e.isDirectory);
-  } catch {
-    return false;
-  }
-}
-async function detectGitRepos(fs, workspaceRoot) {
-  let entries;
-  try {
-    entries = await fs.readDir(workspaceRoot);
-  } catch {
-    return [];
-  }
-  const repos = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory) continue;
-    if (await hasGitDir(fs, joinPath(workspaceRoot, entry.name))) repos.push(entry.name);
-  }
-  return repos.sort();
-}
-
 // src/worktree/manager.ts
 var WorktreeError = class extends Error {
   name = "WorktreeError";
@@ -1785,6 +1910,7 @@ export {
   ObsidianDetector,
   REASONING_PRIORITIES,
   ROLE_DESCRIPTIONS,
+  RULE_SOURCES,
   Reviewer,
   VAULT_NOTES_DIR,
   VaultWriter,
@@ -1801,6 +1927,7 @@ export {
   configFileSchema,
   copyEnvFiles,
   detectGitRepos,
+  detectRuleSources,
   diffLines,
   dirname,
   editorWorkspaceContent,
@@ -1809,10 +1936,13 @@ export {
   generatePlanTemplate,
   getModel,
   joinPath,
+  listVaultNotes,
   loadConfig,
   modelsByProvider,
+  normalizeVaultPath,
   parseChambaConfig,
   planWorktrees,
+  readRuleExcerpts,
   renderNote,
   renderWorkspaceMarkdown,
   resolveEffort,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chamba/core",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Core logic for chamba: workspace scanner, plan + heuristic reviewer, git worktrees, Obsidian, memory — no Node APIs, no LLM",
   "license": "MIT",
   "type": "module",