codymaster 4.5.4 → 4.8.0

package/dist/mcp-context-server.js

@@ -3,7 +3,7 @@
 /**
  * CodyMaster MCP Context Server
  *
- * Exposes 7 tools over JSON-RPC 2.0 / stdio (Content-Length framing):
+ * Exposes 13 tools over JSON-RPC 2.0 / stdio (Content-Length framing):
  *   cm_query         — FTS5 search across learnings + decisions
  *   cm_resolve       — resolve a cm:// URI at L0/L1/L2
  *   cm_bus_read      — read context bus state
@@ -11,6 +11,7 @@
  *   cm_budget_check  — check token budget for a category
  *   cm_memory_decay  — TTL cleanup for learnings
  *   cm_index_refresh — regenerate L0 indexes
+ *   cm_plan / cm_review / cm_qa / cm_deploy / cm_search / cm_memory_query — engineering kit bridge
  *
  * Usage (stdio MCP):
  *   node dist/mcp-context-server.js --project /path/to/project
@@ -44,6 +45,7 @@ const uri_resolver_1 = require("./uri-resolver");
 const context_bus_1 = require("./context-bus");
 const token_budget_1 = require("./token-budget");
 const l0_indexer_1 = require("./l0-indexer");
+const mcp_skills_tools_1 = require("./mcp-skills-tools");
 // ─── Config ──────────────────────────────────────────────────────────────────
 const SERVER_NAME = 'cm-context';
 const SERVER_VERSION = '1.0.0';
@@ -295,6 +297,51 @@ const TOOLS = [
             },
         },
     },
+    {
+        name: 'cm_plan',
+        description: 'Sprint + context bus snapshot: pipeline state, next skill hint, artifact paths.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cm_review',
+        description: 'Read sprint review artifact preview if present; points to cm-code-review workflow.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cm_qa',
+        description: 'QA hints: browse daemon, visual QA CLI, quality gates.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cm_deploy',
+        description: 'Deploy workflow hints (cm-safe-deploy, canary).',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'cm_search',
+        description: 'Search learnings + decisions (same backing store as cm_query).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                scope: { type: 'string', enum: ['learnings', 'decisions', 'all'] },
+                limit: { type: 'number' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'cm_memory_query',
+        description: 'Alias-style memory search across learnings and decisions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                limit: { type: 'number' },
+            },
+            required: ['query'],
+        },
+    },
 ];
 // ─── MCP stdio protocol (JSON-RPC 2.0, Content-Length framing) ───────────────
 function sendMessage(msg) {
@@ -344,6 +391,18 @@ function handleRequest(msg) {
                     result = cmMemoryDecay(a);
                 else if (name === 'cm_index_refresh')
                     result = cmIndexRefresh(a);
+                else if (name === 'cm_plan')
+                    result = (0, mcp_skills_tools_1.cmPlanTool)(PROJECT_PATH);
+                else if (name === 'cm_review')
+                    result = (0, mcp_skills_tools_1.cmReviewTool)(PROJECT_PATH);
+                else if (name === 'cm_qa')
+                    result = (0, mcp_skills_tools_1.cmQaTool)(PROJECT_PATH);
+                else if (name === 'cm_deploy')
+                    result = (0, mcp_skills_tools_1.cmDeployTool)(PROJECT_PATH);
+                else if (name === 'cm_search')
+                    result = (0, mcp_skills_tools_1.cmSearchTool)(PROJECT_PATH, a);
+                else if (name === 'cm_memory_query')
+                    result = (0, mcp_skills_tools_1.cmMemoryQueryTool)(PROJECT_PATH, a);
                 else
                     throw new Error(`Unknown tool: ${name}`);
                 respond(id, {

package/dist/mcp-skills-tools.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Extra MCP tool handlers: plan/review/qa/deploy/search — bridge to sprint + memory.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmPlanTool = cmPlanTool;
+exports.cmReviewTool = cmReviewTool;
+exports.cmQaTool = cmQaTool;
+exports.cmDeployTool = cmDeployTool;
+exports.cmSearchTool = cmSearchTool;
+exports.cmMemoryQueryTool = cmMemoryQueryTool;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const context_bus_1 = require("./context-bus");
+const sprint_pipeline_1 = require("./sprint-pipeline");
+const context_db_1 = require("./context-db");
+function cmPlanTool(projectPath) {
+    const sprint = (0, sprint_pipeline_1.readSprintState)(projectPath);
+    const bus = (0, context_bus_1.readBus)(projectPath);
+    const preview = (0, sprint_pipeline_1.sprintArtifactPreviewFromDisk)(projectPath);
+    return {
+        sprint_active: !!sprint,
+        sprint: sprint !== null && sprint !== void 0 ? sprint : null,
+        context_bus: bus,
+        default_pipeline: sprint_pipeline_1.SPRINT_STEPS,
+        next_skill_hint: sprint
+            ? sprint.current_index >= sprint.pipeline.length
+                ? '(sprint complete — run cm-retro)'
+                : (0, sprint_pipeline_1.skillMappingForStep)(sprint.pipeline[sprint.current_index])
+            : 'cm-planning',
+        artifact_paths: preview.artifacts,
+    };
+}
+function cmReviewTool(projectPath) {
+    const artDir = path_1.default.join(projectPath, '.cm', 'sprint', 'artifacts', 'review.md');
+    let review = '';
+    if (fs_1.default.existsSync(artDir))
+        review = fs_1.default.readFileSync(artDir, 'utf8');
+    return {
+        review_artifact: artDir,
+        has_content: review.length > 0,
+        preview: review.slice(0, 4000),
+        hint: 'Use cm-code-review skill for full checklist; paste diff + requirements.',
+    };
+}
+function cmQaTool(projectPath) {
+    return {
+        browse_daemon: 'Run: cm browse start --token <secret> then POST /session/start',
+        visual: 'cm qa-visual --url http://localhost:3000',
+        gates: ['cm-quality-gate', 'cm-test-gate'],
+    };
+}
+function cmDeployTool(projectPath) {
+    return {
+        hint: 'Use cm-safe-deploy skill; after ship run cm canary --url <prod>',
+        project: projectPath,
+    };
+}
+function cmSearchTool(projectPath, args) {
+    const { query, scope = 'all', limit = 10 } = args;
+    const dbPath = (0, context_db_1.getDbPath)(projectPath);
+    (0, context_db_1.openDb)(dbPath);
+    const results = [];
+    if (scope === 'all' || scope === 'learnings') {
+        for (const l of (0, context_db_1.queryLearnings)(dbPath, query, undefined, limit)) {
+            results.push(Object.assign({ type: 'learning' }, l));
+        }
+    }
+    if (scope === 'all' || scope === 'decisions') {
+        for (const d of (0, context_db_1.queryDecisions)(dbPath, query, limit)) {
+            results.push(Object.assign({ type: 'decision' }, d));
+        }
+    }
+    return { query, scope, count: results.length, results };
+}
+function cmMemoryQueryTool(projectPath, args) {
+    return cmSearchTool(projectPath, Object.assign(Object.assign({}, args), { scope: 'all' }));
+}

package/dist/retro-summary.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Aggregate `.cm/operational-learnings.jsonl` for `cm retro summary`.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRetroEntries = loadRetroEntries;
+exports.filterSince = filterSince;
+exports.countByTool = countByTool;
+exports.formatRetroMarkdown = formatRetroMarkdown;
+exports.formatRetroJson = formatRetroJson;
+const fs_1 = __importDefault(require("fs"));
+function loadRetroEntries(filePath) {
+    if (!fs_1.default.existsSync(filePath))
+        return [];
+    const out = [];
+    for (const line of fs_1.default.readFileSync(filePath, 'utf8').split('\n')) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        try {
+            const o = JSON.parse(t);
+            if (typeof o.ts === 'string' && typeof o.note === 'string') {
+                out.push({
+                    ts: o.ts,
+                    tool: typeof o.tool === 'string' ? o.tool : 'unknown',
+                    note: o.note,
+                });
+            }
+        }
+        catch (_a) {
+            /* skip malformed line */
+        }
+    }
+    return out;
+}
+function filterSince(entries, sinceIso) {
+    const t0 = new Date(sinceIso).getTime();
+    if (Number.isNaN(t0))
+        return entries;
+    return entries.filter((e) => new Date(e.ts).getTime() >= t0);
+}
+function countByTool(entries) {
+    const m = {};
+    for (const e of entries) {
+        m[e.tool] = (m[e.tool] || 0) + 1;
+    }
+    return m;
+}
+function formatRetroMarkdown(entries, byTool) {
+    const lines = ['# Retro summary', '', `**Total entries:** ${entries.length}`, ''];
+    lines.push('## By tool');
+    for (const [tool, n] of Object.entries(byTool).sort((a, b) => b[1] - a[1])) {
+        lines.push(`- **${tool}:** ${n}`);
+    }
+    lines.push('', '## Entries (chronological)');
+    for (const e of entries.sort((a, b) => a.ts.localeCompare(b.ts))) {
+        lines.push(`- \`${e.ts}\` [${e.tool}] ${e.note}`);
+    }
+    return lines.join('\n');
+}
+function formatRetroJson(entries, byTool) {
+    return JSON.stringify({
+        total: entries.length,
+        by_tool: byTool,
+        entries: entries.sort((a, b) => a.ts.localeCompare(b.ts)),
+    }, null, 2);
+}

package/dist/second-opinion-providers.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Redaction + secondary-model review for `cm second-opinion`.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactDiffForReview = redactDiffForReview;
+exports.reviewWithOpenAI = reviewWithOpenAI;
+exports.reviewWithAnthropic = reviewWithAnthropic;
+const SYSTEM = 'You are a senior reviewer. List risks, bugs, and missing tests. Be concise. Do not restate the entire diff.';
+function redactDiffForReview(text, maxLen = 120000) {
+    let t = text.slice(0, maxLen);
+    t = t.replace(/^(\s*(?:#\s*)?(?:API_KEY|API_SECRET|SECRET|PASSWORD|ACCESS_TOKEN|AUTH_TOKEN|BEARER|Authorization)\s*[:=]\s*)\S+.*$/gim, '$1[REDACTED]');
+    t = t.replace(/\b(sk-[a-zA-Z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|ghp_[A-Za-z0-9]{36,}|gho_[A-Za-z0-9]{36,}|AKIA[0-9A-Z]{16})\b/g, '[REDACTED_TOKEN]');
+    return t;
+}
+function reviewWithOpenAI(diffText) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const key = process.env.OPENAI_API_KEY;
+        if (!key)
+            throw new Error('OPENAI_API_KEY is not set');
+        const model = process.env.CM_SECOND_OPINION_MODEL || 'gpt-4o-mini';
+        const res = yield fetch('https://api.openai.com/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${key}`,
+            },
+            body: JSON.stringify({
+                model,
+                messages: [
+                    { role: 'system', content: SYSTEM },
+                    { role: 'user', content: `Review this diff:\n\n${diffText}` },
+                ],
+            }),
+        });
+        if (!res.ok)
+            throw new Error(yield res.text());
+        const data = (yield res.json());
+        return (_d = (_c = (_b = (_a = data.choices) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.message) === null || _c === void 0 ? void 0 : _c.content) !== null && _d !== void 0 ? _d : '';
+    });
+}
+function reviewWithAnthropic(diffText) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const key = process.env.ANTHROPIC_API_KEY;
+        if (!key)
+            throw new Error('ANTHROPIC_API_KEY is not set');
+        const model = process.env.CM_ANTHROPIC_MODEL || 'claude-3-5-haiku-20241022';
+        const res = yield fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': key,
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: 4096,
+                system: SYSTEM,
+                messages: [{ role: 'user', content: `Review this diff:\n\n${diffText}` }],
+            }),
+        });
+        if (!res.ok)
+            throw new Error(yield res.text());
+        const data = (yield res.json());
+        const block = (_a = data.content) === null || _a === void 0 ? void 0 : _a.find((c) => c.type === 'text');
+        return (_b = block === null || block === void 0 ? void 0 : block.text) !== null && _b !== void 0 ? _b : '';
+    });
+}

package/dist/sprint-pipeline.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * Opinionated sprint pipeline + Context Bus files under `.cm/sprint/`.
+ * Complements root `context-bus.json` with step artifacts (ADR 002).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPRINT_STEPS = void 0;
+exports.readSprintState = readSprintState;
+exports.writeSprintState = writeSprintState;
+exports.initSprint = initSprint;
+exports.completeSprintStep = completeSprintStep;
+exports.skipSprintStep = skipSprintStep;
+exports.resetSprint = resetSprint;
+exports.sprintDryRun = sprintDryRun;
+exports.sprintArtifactPreviewFromDisk = sprintArtifactPreviewFromDisk;
+exports.skillMappingForStep = skillMappingForStep;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.SPRINT_STEPS = [
+    'brainstorm',
+    'plan',
+    'design',
+    'tdd',
+    'build',
+    'review',
+    'qa',
+    'security',
+    'ship',
+    'monitor',
+    'retro',
+];
+function sprintDir(projectPath) {
+    return path_1.default.join(projectPath, '.cm', 'sprint');
+}
+function statePath(projectPath) {
+    return path_1.default.join(sprintDir(projectPath), 'state.json');
+}
+function ensureSprintDir(projectPath) {
+    const d = sprintDir(projectPath);
+    const art = path_1.default.join(d, 'artifacts');
+    if (!fs_1.default.existsSync(art))
+        fs_1.default.mkdirSync(art, { recursive: true });
+}
+function normalizeSprintState(raw) {
+    var _a;
+    return Object.assign(Object.assign({}, raw), { version: raw.version === 2 ? 2 : 1, skipped: (_a = raw.skipped) !== null && _a !== void 0 ? _a : [] });
+}
+function readSprintState(projectPath) {
+    const p = statePath(projectPath);
+    if (!fs_1.default.existsSync(p))
+        return null;
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+        return normalizeSprintState(raw);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function writeSprintState(projectPath, state) {
+    ensureSprintDir(projectPath);
+    fs_1.default.writeFileSync(statePath(projectPath), JSON.stringify(state, null, 2), 'utf8');
+}
+function initSprint(projectPath, fromStep) {
+    ensureSprintDir(projectPath);
+    const now = new Date().toISOString();
+    let pipeline = [...exports.SPRINT_STEPS];
+    let startIdx = 0;
+    if (fromStep) {
+        const i = pipeline.indexOf(fromStep);
+        if (i >= 0)
+            startIdx = i;
+    }
+    const state = {
+        version: 2,
+        pipeline,
+        current_index: startIdx,
+        completed: [],
+        skipped: [],
+        started_at: now,
+        updated_at: now,
+        artifacts_dir: path_1.default.join(sprintDir(projectPath), 'artifacts'),
+    };
+    writeSprintState(projectPath, state);
+    appendEvent(projectPath, { type: 'init', from: fromStep !== null && fromStep !== void 0 ? fromStep : null, at: now });
+    return state;
+}
+function completeSprintStep(projectPath, step, artifactBody) {
+    let state = readSprintState(projectPath);
+    if (!state)
+        state = initSprint(projectPath);
+    if (state.current_index >= state.pipeline.length) {
+        throw new Error('Sprint pipeline already finished');
+    }
+    const expected = state.pipeline[state.current_index];
+    if (expected !== step) {
+        throw new Error(`Expected step "${expected}", got "${step}"`);
+    }
+    const artFile = path_1.default.join(state.artifacts_dir, `${step}.md`);
+    fs_1.default.writeFileSync(artFile, artifactBody, 'utf8');
+    state.completed.push(step);
+    state.current_index = Math.min(state.current_index + 1, state.pipeline.length);
+    state.updated_at = new Date().toISOString();
+    state.version = 2;
+    writeSprintState(projectPath, state);
+    appendEvent(projectPath, { type: 'complete', step, at: state.updated_at });
+    return state;
+}
+const SKIP_STUB = (step, at) => `# ${step}\n\n_Skipped via \`cm sprint skip\` at ${at}._\n`;
+function skipSprintStep(projectPath, step) {
+    let state = readSprintState(projectPath);
+    if (!state)
+        state = initSprint(projectPath);
+    if (state.current_index >= state.pipeline.length) {
+        throw new Error('Sprint pipeline already finished');
+    }
+    const expected = state.pipeline[state.current_index];
+    if (expected !== step) {
+        throw new Error(`Expected step "${expected}", got "${step}"`);
+    }
+    const at = new Date().toISOString();
+    const artFile = path_1.default.join(state.artifacts_dir, `${step}.md`);
+    fs_1.default.writeFileSync(artFile, SKIP_STUB(step, at), 'utf8');
+    state.skipped.push(step);
+    state.current_index = Math.min(state.current_index + 1, state.pipeline.length);
+    state.updated_at = at;
+    state.version = 2;
+    writeSprintState(projectPath, state);
+    appendEvent(projectPath, { type: 'skip', step, at });
+    return state;
+}
+function backupDirName() {
+    return new Date().toISOString().replace(/:/g, '-');
+}
+/** Remove sprint state; optional backup under `.cm/sprint/backup/<timestamp>/`. */
+function resetSprint(projectPath, options) {
+    const backup = (options === null || options === void 0 ? void 0 : options.backup) !== false;
+    const sd = sprintDir(projectPath);
+    const st = statePath(projectPath);
+    const ev = eventsPath(projectPath);
+    const art = path_1.default.join(sd, 'artifacts');
+    const hasState = fs_1.default.existsSync(st);
+    let hasEvents = false;
+    if (fs_1.default.existsSync(ev)) {
+        try {
+            hasEvents = fs_1.default.statSync(ev).size > 0;
+        }
+        catch (_a) {
+            hasEvents = false;
+        }
+    }
+    let hasArtifacts = false;
+    if (fs_1.default.existsSync(art)) {
+        try {
+            hasArtifacts = fs_1.default.readdirSync(art).length > 0;
+        }
+        catch (_b) {
+            hasArtifacts = false;
+        }
+    }
+    if (!hasState && !hasEvents && !hasArtifacts) {
+        return { ok: false, reason: 'no_sprint_data' };
+    }
+    let backupPath;
+    if (backup) {
+        const stamp = backupDirName();
+        backupPath = path_1.default.join(sd, 'backup', stamp);
+        fs_1.default.mkdirSync(backupPath, { recursive: true });
+        if (hasState)
+            fs_1.default.copyFileSync(st, path_1.default.join(backupPath, 'state.json'));
+        if (fs_1.default.existsSync(ev))
+            fs_1.default.copyFileSync(ev, path_1.default.join(backupPath, 'events.jsonl'));
+        if (fs_1.default.existsSync(art)) {
+            const destArt = path_1.default.join(backupPath, 'artifacts');
+            fs_1.default.cpSync(art, destArt, { recursive: true });
+        }
+    }
+    fs_1.default.rmSync(st, { force: true });
+    fs_1.default.rmSync(ev, { force: true });
+    fs_1.default.rmSync(art, { recursive: true, force: true });
+    fs_1.default.mkdirSync(art, { recursive: true });
+    return { ok: true, backupDir: backupPath };
+}
+function sprintDryRun(projectPath) {
+    var _a;
+    const state = (_a = readSprintState(projectPath)) !== null && _a !== void 0 ? _a : initSprint(projectPath);
+    return sprintArtifactPreview(state);
+}
+/** Read-only preview without creating files (for MCP / status). */
+function sprintArtifactPreviewFromDisk(projectPath) {
+    const state = readSprintState(projectPath);
+    if (!state) {
+        const base = path_1.default.join(projectPath, '.cm', 'sprint', 'artifacts');
+        const artifacts = exports.SPRINT_STEPS.map((s) => path_1.default.join(base, `${s}.md`));
+        return { steps: [...exports.SPRINT_STEPS], artifacts };
+    }
+    return sprintArtifactPreview(state);
+}
+function sprintArtifactPreview(state) {
+    const artifacts = state.pipeline.map((s) => path_1.default.join(state.artifacts_dir, `${s}.md`));
+    return { steps: [...state.pipeline], artifacts };
+}
+function eventsPath(projectPath) {
+    return path_1.default.join(sprintDir(projectPath), 'events.jsonl');
+}
+function appendEvent(projectPath, rec) {
+    ensureSprintDir(projectPath);
+    fs_1.default.appendFileSync(eventsPath(projectPath), JSON.stringify(rec) + '\n', 'utf8');
+}
+function skillMappingForStep(step) {
+    const map = {
+        brainstorm: 'cm-brainstorm-idea',
+        plan: 'cm-planning',
+        design: 'cm-ui-preview / cm-design-system',
+        tdd: 'cm-tdd',
+        build: 'cm-execution',
+        review: 'cm-code-review',
+        qa: 'cm-quality-gate / cm-test-gate',
+        security: 'cm-secret-shield / cm-security-gate',
+        ship: 'cm-safe-deploy',
+        monitor: 'cm-canary (post-deploy)',
+        retro: 'cm-retro',
+    };
+    return map[step];
+}

package/dist/storage-backend.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VikingBackend = exports.SqliteBackend = void 0;
+exports.getBackend = getBackend;
+const context_db_1 = require("./context-db");
+const viking_backend_1 = require("./backends/viking-backend");
+Object.defineProperty(exports, "VikingBackend", { enumerable: true, get: function () { return viking_backend_1.VikingBackend; } });
+const viking_http_client_1 = require("./backends/viking-http-client");
+const cm_config_1 = require("./cm-config");
+// ─── SqliteBackend ────────────────────────────────────────────────────────────
+/**
+ * Default backend — thin wrapper around context-db.ts (better-sqlite3 + FTS5).
+ * context-db.ts is NOT modified; this class is purely additive.
+ */
+class SqliteBackend {
+    constructor(projectPath) {
+        this.dbPath = (0, context_db_1.getDbPath)(projectPath);
+    }
+    initialize() { (0, context_db_1.openDb)(this.dbPath); }
+    close() { (0, context_db_1.closeDb)(this.dbPath); }
+    insertLearning(l) { (0, context_db_1.insertLearning)(this.dbPath, l); }
+    getLearningById(id) { return (0, context_db_1.getLearningById)(this.dbPath, id); }
+    queryLearnings(q, scope, limit = 10) {
+        return (0, context_db_1.queryLearnings)(this.dbPath, q, scope, limit);
+    }
+    insertDecision(d) { (0, context_db_1.insertDecision)(this.dbPath, d); }
+    queryDecisions(q, limit = 10) { return (0, context_db_1.queryDecisions)(this.dbPath, q, limit); }
+    upsertIndex(resource, level, content, sourceHash) {
+        (0, context_db_1.upsertIndex)(this.dbPath, resource, level, content, sourceHash);
+    }
+    getIndex(resource, level) {
+        return (0, context_db_1.getIndex)(this.dbPath, resource, level);
+    }
+    writeSkillOutput(o) { (0, context_db_1.writeSkillOutput)(this.dbPath, o); }
+    getSkillOutputs(sessionId) { return (0, context_db_1.getSkillOutputs)(this.dbPath, sessionId); }
+}
+exports.SqliteBackend = SqliteBackend;
+// ─── Factory ─────────────────────────────────────────────────────────────────
+/**
+ * Returns the configured StorageBackend for the given project.
+ *
+ * Reads `.cm/config.yaml → storage.backend` via `loadCmConfig` (default: `sqlite`).
+ * For `viking` backend, reads `storage.viking.*` for connection config.
+ *
+ * Usage:
+ *   const backend = getBackend('/path/to/project');
+ *   backend.initialize();
+ *   const results = backend.queryLearnings('i18n locale');
+ */
+function getBackend(projectPath) {
+    var _a, _b, _c;
+    const cfg = (0, cm_config_1.loadCmConfig)(projectPath);
+    const engine = ((_b = (_a = cfg.storage) === null || _a === void 0 ? void 0 : _a.backend) !== null && _b !== void 0 ? _b : 'sqlite').toLowerCase();
+    switch (engine) {
+        case 'viking': {
+            const vikingConfig = Object.assign(Object.assign({}, viking_http_client_1.DEFAULT_VIKING_CONFIG), (_c = cfg.storage) === null || _c === void 0 ? void 0 : _c.viking);
+            return new viking_backend_1.VikingBackend(vikingConfig);
+        }
+        case 'sqlite':
+        default:
+            return new SqliteBackend(projectPath);
+    }
+}