@chamba/core 0.3.2 → 0.5.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,6 +642,8 @@ 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;
@@ -847,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, listVaultNotes, loadConfig, modelsByProvider, normalizeVaultPath, 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) {
@@ -619,6 +632,8 @@ var SENSITIVE_PATH_RE = /(^|\/)(auth|payments|billing|migrations|secrets?|creden
 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 DELETION_RE = /\b(delete[ds]?|deleting|remove[ds]?|removing|removal|drop(?:ping|s|ped)?|eliminat\w*|deprecat\w*|elimina\w*|borra\w*|quita\w*)\b/i;
+var ORPHAN_CHECK_RE = /\b(orphan\w*|dead[-\s]?code|unused\s+(?:export|import|symbol|function|code|reference)|referential|callers?|knip|ts-prune|depcheck|type-?check|typecheck|tsc|build\s+(?:passes|green|clean))\b/i;
 var DEFAULT_MODULES = /* @__PURE__ */ new Set([
   "packages",
   "examples",
@@ -703,6 +718,16 @@ function validatePlan(input) {
       suggestions.push('Add a concrete entry under "## Risks" describing the risk and mitigation.');
     }
   }
+  if (DELETION_RE.test(plan) && !ORPHAN_CHECK_RE.test(plan)) {
+    issues.push({
+      code: "deletion-without-orphan-check",
+      severity: "warning",
+      message: "The plan removes code but never mentions verifying referential closure: orphaned callers or now-unused exports left behind. Token grep alone misses these."
+    });
+    suggestions.push(
+      "After removing code, verify nothing was orphaned: run the build/typecheck and a dead-code check (e.g. knip / ts-prune), not just a grep."
+    );
+  }
   return { issues, suggestions, riskFlags };
 }
 function sections(plan) {
@@ -904,12 +929,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 +945,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 +1064,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 +1076,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(", ")}`);
@@ -1161,6 +1289,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 = [
@@ -1230,6 +1382,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,
@@ -1237,6 +1393,7 @@ var WorkspaceScanner = class {
       framework,
       conventions,
       projects,
+      ruleSources,
       folderMap: [...acc.topDirs].sort()
     };
   }
@@ -1396,10 +1553,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;
   }
@@ -1563,30 +1720,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";
@@ -1789,6 +1922,7 @@ export {
   ObsidianDetector,
   REASONING_PRIORITIES,
   ROLE_DESCRIPTIONS,
+  RULE_SOURCES,
   Reviewer,
   VAULT_NOTES_DIR,
   VaultWriter,
@@ -1805,6 +1939,7 @@ export {
   configFileSchema,
   copyEnvFiles,
   detectGitRepos,
+  detectRuleSources,
   diffLines,
   dirname,
   editorWorkspaceContent,
@@ -1819,6 +1954,7 @@ export {
   normalizeVaultPath,
   parseChambaConfig,
   planWorktrees,
+  readRuleExcerpts,
   renderNote,
   renderWorkspaceMarkdown,
   resolveEffort,

package/package.json

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