@chamba/core 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,12 +1,52 @@
+import { z } from 'zod';
+
+/** The roles a model can play when the editor delegates work. */
+type AgentRole = 'orchestrator' | 'planner' | 'reviewer' | 'implementer' | 'tester' | 'summarizer' | 'researcher';
+/** Canonical order — this is also the order the install wizard walks. */
+declare const AGENT_ROLES: readonly AgentRole[];
 /**
- * Time behind a port so date-dependent logic (plan filenames, vault notes) is
- * testable and `@chamba/core` stays free of ambient `Date` calls.
+ * Abstract effort level. chamba is multi-editor, so this is a provider-neutral
+ * enum; each model in the catalog maps these four levels to its own native
+ * vocabulary (Claude Code `effort:`, OpenAI `reasoning_effort`, Gemini
+ * `thinkingLevel`, …). `extreme` is the ceiling — e.g. it becomes `max` in
+ * Claude Code and `xhigh` in OpenAI.
  */
-interface ClockPort {
-    now(): Date;
-    /** Current date as `YYYY-MM-DD`. */
-    today(): string;
+type Effort = 'low' | 'medium' | 'high' | 'extreme';
+declare const EFFORT_LEVELS: readonly Effort[];
+/** Semantic hint the editor's model can read to decide how to delegate. */
+type ReasoningPriority = 'speed' | 'balanced' | 'thoroughness';
+declare const REASONING_PRIORITIES: readonly ReasoningPriority[];
+/** One-line description per role, shown in the wizard and `chamba-config show`. */
+declare const ROLE_DESCRIPTIONS: Record<AgentRole, string>;
+
+/** What model + effort to use for one role. */
+interface AgentConfig {
+    /** A model id from the catalog (e.g. `claude-opus-4-8`). */
+    model: string;
+    effort: Effort;
+    reasoning_priority: ReasoningPriority;
+}
+/**
+ * The in-memory config. `defaults` always has all seven roles fully populated
+ * (the compiled `DEFAULT_CONFIG` provides them); `overrides` is an optional,
+ * partial set of per-role, per-field tweaks layered on top.
+ */
+interface ChambaConfig {
+    version: 1;
+    defaults: Record<AgentRole, AgentConfig>;
+    overrides?: Partial<Record<AgentRole, Partial<AgentConfig>>>;
 }
+/** A fully-resolved config: every role present, every field filled. */
+type ResolvedConfig = Record<AgentRole, AgentConfig>;
+
+/**
+ * The compiled, hardcoded defaults — the single source of truth for the
+ * recommended reparto of models per role. The philosophy: critical reasoning
+ * gets powerful models, mechanical execution gets fast/cheap ones. Users
+ * override these via `~/.chamba/config.json`; they are never written to disk
+ * unless the user runs the wizard or `chamba-config`.
+ */
+declare const DEFAULT_CONFIG: ChambaConfig;
 
 /** A single entry returned when listing a directory. */
 interface DirEntry {
@@ -30,6 +70,124 @@ interface FilesystemPort {
     remove(path: string): Promise<void>;
 }
 
+/** Raised when a config is invalid and the caller asked to fail hard. */
+declare class ConfigError extends Error {
+    constructor(message: string);
+}
+type ConfigSourceKind = 'default' | 'global' | 'project';
+/** Where a layer came from and whether it applied. */
+interface ConfigSource {
+    kind: ConfigSourceKind;
+    path?: string;
+    status: 'applied' | 'missing' | 'invalid';
+    error?: string;
+}
+interface LoadConfigResult {
+    config: ResolvedConfig;
+    sources: ConfigSource[];
+}
+interface LoadConfigOptions {
+    /** Path to `~/.chamba/config.json`. */
+    globalPath?: string;
+    /** Path to `<cwd>/.chamba/config.json`. */
+    projectPath?: string;
+}
+/**
+ * Resolve the effective config by layering DEFAULT_CONFIG ← global ← project,
+ * per role and per field. A missing file is skipped; an invalid one (bad JSON
+ * or failed schema) is skipped with a recorded warning — loading never throws,
+ * so a corrupt config can never take down the MCP server.
+ */
+declare function loadConfig(fs: FilesystemPort, opts?: LoadConfigOptions): Promise<LoadConfigResult>;
+
+/** The resolved config for one role. */
+declare function resolveRole(config: ResolvedConfig, role: AgentRole): AgentConfig;
+/**
+ * A short, deterministic (no-LLM) hint the editor's model can read to decide
+ * how to delegate this role — e.g. "use a model optimized for deep reasoning;
+ * suggested: claude-opus-4-8 with maximum effort."
+ */
+declare function buildHint(role: AgentRole, cfg: AgentConfig): string;
+
+/**
+ * What a config file on disk may contain. Both `defaults` and `overrides` are
+ * optional and partial per role — a project file can carry just one role's one
+ * field. Unknown roles and unknown models are rejected with clear messages.
+ */
+declare const configFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    defaults: z.ZodOptional<z.ZodRecord<z.ZodEnum<[AgentRole, ...AgentRole[]]>, z.ZodObject<{
+        model: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        effort: z.ZodOptional<z.ZodEnum<[Effort, ...Effort[]]>>;
+        reasoning_priority: z.ZodOptional<z.ZodEnum<[ReasoningPriority, ...ReasoningPriority[]]>>;
+    }, "strip", z.ZodTypeAny, {
+        model?: string | undefined;
+        effort?: Effort | undefined;
+        reasoning_priority?: ReasoningPriority | undefined;
+    }, {
+        model?: string | undefined;
+        effort?: Effort | undefined;
+        reasoning_priority?: ReasoningPriority | undefined;
+    }>>>;
+    overrides: z.ZodOptional<z.ZodRecord<z.ZodEnum<[AgentRole, ...AgentRole[]]>, z.ZodObject<{
+        model: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        effort: z.ZodOptional<z.ZodEnum<[Effort, ...Effort[]]>>;
+        reasoning_priority: z.ZodOptional<z.ZodEnum<[ReasoningPriority, ...ReasoningPriority[]]>>;
+    }, "strip", z.ZodTypeAny, {
+        model?: string | undefined;
+        effort?: Effort | undefined;
+        reasoning_priority?: ReasoningPriority | undefined;
+    }, {
+        model?: string | undefined;
+        effort?: Effort | undefined;
+        reasoning_priority?: ReasoningPriority | undefined;
+    }>>>;
+}, "strict", z.ZodTypeAny, {
+    version: 1;
+    defaults?: Partial<Record<AgentRole, {
+        model?: string | undefined;
+        effort?: Effort | undefined;
+        reasoning_priority?: ReasoningPriority | undefined;
+    }>> | undefined;
+    overrides?: Partial<Record<AgentRole, {
+        model?: string | undefined;
+        effort?: Effort | undefined;
+        reasoning_priority?: ReasoningPriority | undefined;
+    }>> | undefined;
+}, {
+    version: 1;
+    defaults?: Partial<Record<AgentRole, {
+        model?: string | undefined;
+        effort?: Effort | undefined;
+        reasoning_priority?: ReasoningPriority | undefined;
+    }>> | undefined;
+    overrides?: Partial<Record<AgentRole, {
+        model?: string | undefined;
+        effort?: Effort | undefined;
+        reasoning_priority?: ReasoningPriority | undefined;
+    }>> | undefined;
+}>;
+type ConfigFile = z.infer<typeof configFileSchema>;
+type ParseResult = {
+    ok: true;
+    value: ConfigFile;
+} | {
+    ok: false;
+    error: string;
+};
+/** Validate raw (parsed-JSON) data as a chamba config file. */
+declare function parseChambaConfig(raw: unknown): ParseResult;
+
+/**
+ * Time behind a port so date-dependent logic (plan filenames, vault notes) is
+ * testable and `@chamba/core` stays free of ambient `Date` calls.
+ */
+interface ClockPort {
+    now(): Date;
+    /** Current date as `YYYY-MM-DD`. */
+    today(): string;
+}
+
 interface Memory {
     key: string;
     content: string;
@@ -77,6 +235,34 @@ declare class FilesystemMemoryStore implements MemoryStore {
     private read;
 }
 
+type ModelProvider = 'anthropic' | 'openai' | 'google' | 'ollama';
+interface ModelInfo {
+    /** The exact id used by the provider / editor (e.g. `claude-opus-4-8`). */
+    id: string;
+    provider: ModelProvider;
+    /** Human label for the wizard. */
+    label: string;
+    /** One-line description for the wizard. */
+    description: string;
+    /** Whether the model has an adjustable thinking/reasoning budget. */
+    supports_thinking: boolean;
+    /**
+     * Maps chamba's abstract effort to the provider's native value, or `null`
+     * when the provider has no effort knob (effort is then advisory only).
+     */
+    effortMap: Record<Effort, string | null>;
+}
+declare const MODEL_CATALOG: readonly ModelInfo[];
+/** Look up a model by exact id. */
+declare function getModel(id: string): ModelInfo | undefined;
+/** All models for a given provider. */
+declare function modelsByProvider(provider: ModelProvider): ModelInfo[];
+/**
+ * Translate chamba's abstract effort to the model's native value. Returns
+ * `null` when the provider has no effort knob (effort is advisory).
+ */
+declare function resolveEffort(model: ModelInfo, effort: Effort): string | null;
+
 interface NoteFields {
     title: string;
     /** `YYYY-MM-DD`. */
@@ -430,4 +616,4 @@ declare class WorktreeManager {
     cleanup(root: string, branch: string): Promise<CleanupResult>;
 }
 
-export { type BranchNameInput, type BuiltContext, type CleanupResult, type ClockPort, type ContextBuildInput, ContextBuilder, type CreateWorktreeInput, type DetectOptions, type DirEntry, FakeProcess, FilesystemMemoryStore, type FilesystemPort, type GeneratePlanInput, GitDetector, type Issue, type IssueSeverity, type ListedWorktree, MEMORY_DIR, type Memory, MemoryFilesystem, type MemoryStore, type NoteFields, ObsidianDetector, type PlanReview, type ProcessExecOptions, type ProcessHandler, type ProcessPort, type ProcessResult, type ProjectRef, type RecordedCall, type RelevantNote, type RememberInput, 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, WorktreeError, type WorktreeHandle, WorktreeManager, type WriteNoteInput, type WriteNoteResult, basename, buildBranchName, diffLines, dirname, extname, generatePlanTemplate, joinPath, renderNote, renderWorkspaceMarkdown, slugify, slugifyForGit, suggestFilesLikelyTouched, suggestSubtasks, textsEqual, validatePlan, worktreeRelativePath };
+export { AGENT_ROLES, type AgentConfig, type AgentRole, type BranchNameInput, type BuiltContext, type ChambaConfig, type CleanupResult, type ClockPort, ConfigError, type ConfigFile, type ConfigSource, type ConfigSourceKind, type ContextBuildInput, ContextBuilder, type CreateWorktreeInput, DEFAULT_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, type NoteFields, ObsidianDetector, type ParseResult, type PlanReview, 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, WorktreeError, type WorktreeHandle, WorktreeManager, type WriteNoteInput, type WriteNoteResult, basename, buildBranchName, buildHint, configFileSchema, diffLines, dirname, extname, generatePlanTemplate, getModel, joinPath, loadConfig, modelsByProvider, parseChambaConfig, renderNote, renderWorkspaceMarkdown, resolveEffort, resolveRole, slugify, slugifyForGit, suggestFilesLikelyTouched, suggestSubtasks, textsEqual, validatePlan, worktreeRelativePath };

package/dist/index.js

@@ -1,3 +1,302 @@
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  version: 1,
+  defaults: {
+    // The brain: decomposes and decides. Worth the tokens.
+    orchestrator: { model: "claude-opus-4-8", effort: "high", reasoning_priority: "thoroughness" },
+    // Max reasoning when planning is delegated; invoked rarely, so it's cheap overall.
+    planner: { model: "claude-opus-4-8", effort: "extreme", reasoning_priority: "thoroughness" },
+    // Critical audit; deep reasoning but doesn't need the very latest model.
+    reviewer: { model: "claude-opus-4-7", effort: "high", reasoning_priority: "thoroughness" },
+    // Executes clear specs; speed matters, medium reasoning is enough.
+    implementer: { model: "claude-sonnet-4-6", effort: "medium", reasoning_priority: "balanced" },
+    // Tests over already-implemented code; same profile as the implementer.
+    tester: { model: "claude-sonnet-4-6", effort: "medium", reasoning_priority: "balanced" },
+    // Summaries are mechanical; a fast, cheap model is perfect.
+    summarizer: { model: "claude-haiku-4-5", effort: "low", reasoning_priority: "speed" },
+    // Research and synthesis; high reasoning, but doesn't need Opus 4.8.
+    researcher: { model: "claude-opus-4-7", effort: "high", reasoning_priority: "thoroughness" }
+  }
+};
+
+// src/config/roles.ts
+var AGENT_ROLES = [
+  "orchestrator",
+  "planner",
+  "reviewer",
+  "implementer",
+  "tester",
+  "summarizer",
+  "researcher"
+];
+var EFFORT_LEVELS = ["low", "medium", "high", "extreme"];
+var REASONING_PRIORITIES = [
+  "speed",
+  "balanced",
+  "thoroughness"
+];
+var ROLE_DESCRIPTIONS = {
+  orchestrator: "Decomposes the task, plans, and decides \u2014 the brain.",
+  planner: "Produces the detailed plan when the orchestrator delegates planning.",
+  reviewer: "Audits the plan and code with critical judgement.",
+  implementer: "Writes code against a clear, reviewed spec.",
+  tester: "Writes and runs tests over already-implemented code.",
+  summarizer: "Summarizes what happened \u2014 mechanical, cheap.",
+  researcher: "Investigates context, reads docs, synthesizes."
+};
+
+// src/config/schema.ts
+import { z } from "zod";
+
+// src/models/catalog.ts
+var ANTHROPIC_EFFORT = {
+  low: "low",
+  medium: "medium",
+  high: "high",
+  extreme: "max"
+};
+var OPENAI_EFFORT = {
+  low: "low",
+  medium: "medium",
+  high: "high",
+  extreme: "xhigh"
+};
+var GEMINI_FLASH_EFFORT = {
+  low: "low",
+  medium: "medium",
+  high: "high",
+  extreme: "high"
+};
+var GEMINI_PRO_EFFORT = {
+  low: "low",
+  medium: "high",
+  high: "high",
+  extreme: "high"
+};
+var NO_EFFORT = {
+  low: null,
+  medium: null,
+  high: null,
+  extreme: null
+};
+var MODEL_CATALOG = [
+  {
+    id: "claude-opus-4-8",
+    provider: "anthropic",
+    label: "Claude Opus 4.8",
+    description: "Flagship reasoning. Best for critical decomposition and planning.",
+    supports_thinking: true,
+    effortMap: ANTHROPIC_EFFORT
+  },
+  {
+    id: "claude-opus-4-7",
+    provider: "anthropic",
+    label: "Claude Opus 4.7",
+    description: "Previous-gen reasoning, still strong. Good for review and research.",
+    supports_thinking: true,
+    effortMap: ANTHROPIC_EFFORT
+  },
+  {
+    id: "claude-sonnet-4-6",
+    provider: "anthropic",
+    label: "Claude Sonnet 4.6",
+    description: "Balanced and fast. Ideal for implementation against clear specs.",
+    supports_thinking: true,
+    effortMap: ANTHROPIC_EFFORT
+  },
+  {
+    id: "claude-haiku-4-5",
+    provider: "anthropic",
+    label: "Claude Haiku 4.5",
+    description: "Cheapest and fastest. Perfect for mechanical work like summaries.",
+    supports_thinking: true,
+    effortMap: ANTHROPIC_EFFORT
+  },
+  {
+    id: "gpt-5.5",
+    provider: "openai",
+    label: "GPT-5.5",
+    description: "OpenAI flagship reasoning model.",
+    supports_thinking: true,
+    effortMap: OPENAI_EFFORT
+  },
+  {
+    id: "gpt-5.5-mini",
+    provider: "openai",
+    label: "GPT-5.5 mini",
+    description: "Smaller, faster OpenAI model for execution.",
+    supports_thinking: true,
+    // `xhigh` is unconfirmed for the mini; cap `extreme` at `high` to be safe.
+    effortMap: { low: "low", medium: "medium", high: "high", extreme: "high" }
+  },
+  {
+    id: "gemini-3.1-pro-preview",
+    provider: "google",
+    label: "Gemini 3.1 Pro (preview)",
+    description: "Google flagship reasoning model. thinkingLevel: low | high.",
+    supports_thinking: true,
+    effortMap: GEMINI_PRO_EFFORT
+  },
+  {
+    id: "gemini-3.5-flash",
+    provider: "google",
+    label: "Gemini 3.5 Flash",
+    description: "Fast, cheap, GA. thinkingLevel: minimal | low | medium | high.",
+    supports_thinking: true,
+    effortMap: GEMINI_FLASH_EFFORT
+  },
+  {
+    id: "qwen2.5-coder:7b",
+    provider: "ollama",
+    label: "Qwen2.5 Coder 7B (Ollama)",
+    description: "Local coding model via Ollama. No adjustable thinking.",
+    supports_thinking: false,
+    effortMap: NO_EFFORT
+  },
+  {
+    id: "deepseek-r1:7b",
+    provider: "ollama",
+    label: "DeepSeek-R1 7B (Ollama)",
+    description: "Local reasoning model via Ollama. Thinks natively (always on).",
+    supports_thinking: true,
+    effortMap: NO_EFFORT
+  },
+  {
+    id: "llama3.1:8b",
+    provider: "ollama",
+    label: "Llama 3.1 8B (Ollama)",
+    description: "General-purpose local model via Ollama.",
+    supports_thinking: false,
+    effortMap: NO_EFFORT
+  }
+];
+function getModel(id) {
+  return MODEL_CATALOG.find((m) => m.id === id);
+}
+function modelsByProvider(provider) {
+  return MODEL_CATALOG.filter((m) => m.provider === provider);
+}
+function resolveEffort(model, effort) {
+  return model.effortMap[effort];
+}
+
+// src/config/schema.ts
+var effortSchema = z.enum([...EFFORT_LEVELS]);
+var reasoningPrioritySchema = z.enum([...REASONING_PRIORITIES]);
+var roleSchema = z.enum([...AGENT_ROLES]);
+var modelSchema = z.string().refine(
+  (id) => getModel(id) !== void 0,
+  (id) => ({
+    message: `unknown model '${id}'; run the config 'models' command to list valid model ids`
+  })
+);
+var agentConfigSchema = z.object({
+  model: modelSchema,
+  effort: effortSchema,
+  reasoning_priority: reasoningPrioritySchema
+});
+var partialAgentConfigSchema = agentConfigSchema.partial();
+var configFileSchema = z.object({
+  version: z.literal(1),
+  defaults: z.record(roleSchema, partialAgentConfigSchema).optional(),
+  overrides: z.record(roleSchema, partialAgentConfigSchema).optional()
+}).strict();
+function parseChambaConfig(raw) {
+  const result = configFileSchema.safeParse(raw);
+  if (result.success) return { ok: true, value: result.data };
+  const error = result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+  return { ok: false, error };
+}
+
+// src/config/loader.ts
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+async function loadConfig(fs, opts = {}) {
+  const sources = [{ kind: "default", status: "applied" }];
+  const config = cloneDefaults();
+  const layers = [
+    { kind: "global", path: opts.globalPath },
+    { kind: "project", path: opts.projectPath }
+  ];
+  for (const layer of layers) {
+    if (!layer.path) continue;
+    const loaded = await readLayer(fs, layer.path);
+    if (loaded.status === "missing") {
+      sources.push({ kind: layer.kind, path: layer.path, status: "missing" });
+      continue;
+    }
+    if (loaded.status === "invalid") {
+      sources.push({ kind: layer.kind, path: layer.path, status: "invalid", error: loaded.error });
+      continue;
+    }
+    applyLayer(config, loaded.file);
+    sources.push({ kind: layer.kind, path: layer.path, status: "applied" });
+  }
+  return { config, sources };
+}
+function cloneDefaults() {
+  const out = {};
+  for (const role of AGENT_ROLES) {
+    out[role] = { ...DEFAULT_CONFIG.defaults[role] };
+  }
+  return out;
+}
+function applyLayer(config, file) {
+  for (const part of [file.defaults, file.overrides]) {
+    if (!part) continue;
+    for (const role of AGENT_ROLES) {
+      const patch = part[role];
+      if (!patch) continue;
+      config[role] = { ...config[role], ...stripUndefined(patch) };
+    }
+  }
+}
+function stripUndefined(patch) {
+  const out = {};
+  if (patch.model !== void 0) out.model = patch.model;
+  if (patch.effort !== void 0) out.effort = patch.effort;
+  if (patch.reasoning_priority !== void 0) out.reasoning_priority = patch.reasoning_priority;
+  return out;
+}
+async function readLayer(fs, path) {
+  let text;
+  try {
+    if (!await fs.exists(path)) return { status: "missing" };
+    text = await fs.readFile(path);
+  } catch {
+    return { status: "missing" };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (e) {
+    return { status: "invalid", error: `invalid JSON: ${e.message}` };
+  }
+  const parsed = parseChambaConfig(raw);
+  if (!parsed.ok) return { status: "invalid", error: parsed.error };
+  return { status: "applied", file: parsed.value };
+}
+
+// src/config/resolve.ts
+function resolveRole(config, role) {
+  return config[role];
+}
+var PRIORITY_PHRASE = {
+  speed: "optimized for speed on mechanical work",
+  balanced: "balanced between speed and reasoning",
+  thoroughness: "optimized for deep reasoning"
+};
+function buildHint(role, cfg) {
+  const model = getModel(cfg.model);
+  const effortPhrase = cfg.effort === "extreme" ? "maximum" : cfg.effort;
+  const advisory = model && !model.supports_thinking ? " (this model has no adjustable thinking, so effort is advisory)" : "";
+  return `For the ${role} role, use a model ${PRIORITY_PHRASE[cfg.reasoning_priority]}; suggested: ${cfg.model} with ${effortPhrase} effort${advisory}.`;
+}
+
 // src/util/path.ts
 function joinPath(...parts) {
   return parts.filter((p) => p.length > 0).join("/").replace(/\/{2,}/g, "/");
@@ -1183,13 +1482,20 @@ function parsePorcelain(output) {
   return result;
 }
 export {
+  AGENT_ROLES,
+  ConfigError,
   ContextBuilder,
+  DEFAULT_CONFIG,
+  EFFORT_LEVELS,
   FakeProcess,
   FilesystemMemoryStore,
   GitDetector,
   MEMORY_DIR,
+  MODEL_CATALOG,
   MemoryFilesystem,
   ObsidianDetector,
+  REASONING_PRIORITIES,
+  ROLE_DESCRIPTIONS,
   Reviewer,
   VAULT_NOTES_DIR,
   VaultWriter,
@@ -1201,13 +1507,21 @@ export {
   WorktreeManager,
   basename,
   buildBranchName,
+  buildHint,
+  configFileSchema,
   diffLines,
   dirname,
   extname,
   generatePlanTemplate,
+  getModel,
   joinPath,
+  loadConfig,
+  modelsByProvider,
+  parseChambaConfig,
   renderNote,
   renderWorkspaceMarkdown,
+  resolveEffort,
+  resolveRole,
   slugify,
   slugifyForGit,
   suggestFilesLikelyTouched,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chamba/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Core logic for chamba: workspace scanner, plan + heuristic reviewer, git worktrees, Obsidian, memory — no Node APIs, no LLM",
   "license": "MIT",
   "type": "module",
@@ -34,6 +34,9 @@
     "obsidian",
     "git-worktree"
   ],
+  "dependencies": {
+    "zod": "^3.23.0"
+  },
   "devDependencies": {
     "typescript": "^5.6.0",
     "vitest": "^2.0.0"