codymaster 4.8.0 → 7.0.0

package/dist/skill-execution-cache.js

@@ -0,0 +1,254 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillExecutionCache = void 0;
+exports.formatCacheStats = formatCacheStats;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const path_1 = __importDefault(require("path"));
+// ─── Schema ─────────────────────────────────────────────────────────────────
+const CACHE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS skill_cache (
+  id               INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_pattern     TEXT NOT NULL,
+  skill_chain_json TEXT NOT NULL,
+  effectiveness    REAL NOT NULL DEFAULT 0,
+  token_used       INTEGER NOT NULL DEFAULT 0,
+  hit_count        INTEGER NOT NULL DEFAULT 0,
+  last_hit         TEXT NOT NULL,
+  created_at       TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_skill_cache_pattern ON skill_cache(task_pattern);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS skill_cache_fts USING fts5(
+  task_pattern,
+  content=skill_cache, content_rowid=rowid
+);
+
+CREATE TRIGGER IF NOT EXISTS skill_cache_ai AFTER INSERT ON skill_cache BEGIN
+  INSERT INTO skill_cache_fts(rowid, task_pattern)
+  VALUES (new.rowid, new.task_pattern);
+END;
+
+CREATE TRIGGER IF NOT EXISTS skill_cache_ad AFTER DELETE ON skill_cache BEGIN
+  INSERT INTO skill_cache_fts(skill_cache_fts, rowid, task_pattern)
+  VALUES('delete', old.rowid, old.task_pattern);
+END;
+`;
+// ─── DB Cache (share connection with context-db) ─────────────────────────────
+const dbCache = new Map();
+function getDb(dbPath) {
+    if (dbCache.has(dbPath))
+        return dbCache.get(dbPath);
+    const db = new better_sqlite3_1.default(dbPath);
+    db.pragma('journal_mode = WAL');
+    dbCache.set(dbPath, db);
+    return db;
+}
+// ─── Skill Execution Cache ───────────────────────────────────────────────────
+// TRIZ #35 Parameter Changes — reuse successful execution patterns
+/**
+ * SkillExecutionCache — OpenSpace-inspired warm cache for skill chains.
+ *
+ * When a task succeeds with a specific skill chain, we cache the pattern.
+ * For similar future tasks, skip BM25 ranking entirely and reuse the chain.
+ *
+ * Token savings: ~2000 tokens/task (skip ranking + LLM selection).
+ */
+class SkillExecutionCache {
+    constructor(projectPath) {
+        this.dbPath = path_1.default.join(projectPath, '.cm', 'context.db');
+    }
+    /**
+     * Initialize cache tables. Call once before use.
+     */
+    initialize() {
+        const db = getDb(this.dbPath);
+        db.exec(CACHE_SCHEMA);
+    }
+    /**
+     * Cache a successful task execution pattern.
+     * Only caches executions with effectiveness >= 0.7.
+     */
+    cacheExecution(taskPattern, skillChain, effectiveness, tokenUsed) {
+        if (effectiveness < 0.7)
+            return; // Only cache good executions
+        if (!taskPattern.trim() || skillChain.length === 0)
+            return;
+        const db = getDb(this.dbPath);
+        const now = new Date().toISOString();
+        // Check if similar pattern already exists
+        const existing = this.findExactMatch(taskPattern);
+        if (existing) {
+            // Update existing entry if new execution is better
+            if (effectiveness >= existing.effectiveness) {
+                db.prepare(`
+          UPDATE skill_cache SET
+            skill_chain_json = ?,
+            effectiveness = ?,
+            token_used = ?,
+            hit_count = hit_count + 1,
+            last_hit = ?
+          WHERE task_pattern = ?
+        `).run(JSON.stringify(skillChain), effectiveness, tokenUsed, now, taskPattern);
+            }
+            else {
+                // Just increment hit count
+                db.prepare(`
+          UPDATE skill_cache SET hit_count = hit_count + 1, last_hit = ? WHERE task_pattern = ?
+        `).run(now, taskPattern);
+            }
+            return;
+        }
+        db.prepare(`
+      INSERT INTO skill_cache
+        (task_pattern, skill_chain_json, effectiveness, token_used, hit_count, last_hit, created_at)
+      VALUES (?, ?, ?, ?, 1, ?, ?)
+    `).run(taskPattern, JSON.stringify(skillChain), effectiveness, tokenUsed, now, now);
+    }
+    /**
+     * Find a cached chain for a task description using BM25 similarity.
+     * Returns null if no suitable match (effectiveness >= 0.7).
+     */
+    findCachedChain(taskDescription) {
+        const db = getDb(this.dbPath);
+        const query = this.normalizeForSearch(taskDescription);
+        if (!query)
+            return null;
+        try {
+            const row = db.prepare(`
+        SELECT skill_cache.* FROM skill_cache
+        JOIN skill_cache_fts ON skill_cache.rowid = skill_cache_fts.rowid
+        WHERE skill_cache_fts MATCH ?
+          AND skill_cache.effectiveness >= 0.7
+        ORDER BY bm25(skill_cache_fts) * skill_cache.effectiveness * (1.0 + skill_cache.hit_count * 0.1)
+        LIMIT 1
+      `).get(query);
+            if (!row)
+                return null;
+            return this.rowToCachedChain(row);
+        }
+        catch (_a) {
+            // FTS5 query might fail with special characters
+            return null;
+        }
+    }
+    /**
+     * Record a cache hit (increment counter, update timestamp).
+     */
+    recordHit(taskPattern) {
+        const db = getDb(this.dbPath);
+        db.prepare(`
+      UPDATE skill_cache SET hit_count = hit_count + 1, last_hit = ? WHERE task_pattern = ?
+    `).run(new Date().toISOString(), taskPattern);
+    }
+    /**
+     * Get cache statistics.
+     */
+    getStats() {
+        const db = getDb(this.dbPath);
+        try {
+            const stats = db.prepare(`
+        SELECT
+          COUNT(*) as total_entries,
+          COALESCE(SUM(hit_count), 0) as total_hits,
+          COALESCE(AVG(effectiveness), 0) as avg_effectiveness,
+          COALESCE(SUM(hit_count * token_used), 0) as estimated_tokens_saved
+        FROM skill_cache
+      `).get();
+            return {
+                totalEntries: stats.total_entries,
+                totalHits: stats.total_hits,
+                avgEffectiveness: Math.round(stats.avg_effectiveness * 100) / 100,
+                estimatedTokensSaved: stats.estimated_tokens_saved,
+            };
+        }
+        catch (_a) {
+            return { totalEntries: 0, totalHits: 0, avgEffectiveness: 0, estimatedTokensSaved: 0 };
+        }
+    }
+    /**
+     * List all cached chains.
+     */
+    listCachedChains(limit = 20) {
+        const db = getDb(this.dbPath);
+        try {
+            const rows = db.prepare('SELECT * FROM skill_cache ORDER BY hit_count DESC, effectiveness DESC LIMIT ?').all(limit);
+            return rows.map(r => this.rowToCachedChain(r));
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    /**
+     * Clear all cached chains.
+     */
+    clearCache() {
+        const db = getDb(this.dbPath);
+        const info = db.prepare('DELETE FROM skill_cache').run();
+        return info.changes;
+    }
+    /**
+     * Close the database connection.
+     */
+    close() {
+        const db = dbCache.get(this.dbPath);
+        if (db) {
+            try {
+                db.close();
+            }
+            catch ( /* already closed */_a) { /* already closed */ }
+            dbCache.delete(this.dbPath);
+        }
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    findExactMatch(taskPattern) {
+        const db = getDb(this.dbPath);
+        const row = db.prepare('SELECT * FROM skill_cache WHERE task_pattern = ? LIMIT 1').get(taskPattern);
+        return row ? this.rowToCachedChain(row) : null;
+    }
+    /**
+     * Normalize a task description for FTS5 search.
+     * Removes special characters that break FTS5 MATCH syntax.
+     */
+    normalizeForSearch(text) {
+        return text
+            .replace(/[^\w\s]/g, ' ') // Remove special chars
+            .replace(/\s+/g, ' ') // Collapse whitespace
+            .trim()
+            .split(' ')
+            .filter(w => w.length > 2) // Drop short words
+            .slice(0, 10) // Limit query length
+            .join(' ');
+    }
+    rowToCachedChain(row) {
+        let chain = [];
+        try {
+            chain = JSON.parse(String(row.skill_chain_json || '[]'));
+        }
+        catch ( /* empty */_a) { /* empty */ }
+        return {
+            taskPattern: String(row.task_pattern || ''),
+            skillChain: chain,
+            effectiveness: Number(row.effectiveness || 0),
+            tokenUsed: Number(row.token_used || 0),
+            hitCount: Number(row.hit_count || 0),
+            lastHit: String(row.last_hit || ''),
+        };
+    }
+}
+exports.SkillExecutionCache = SkillExecutionCache;
+// ─── Display Helpers ─────────────────────────────────────────────────────────
+function formatCacheStats(stats) {
+    const lines = [
+        `📦 Skill Execution Cache`,
+        `─`.repeat(50),
+        `Cached patterns:     ${stats.totalEntries}`,
+        `Total cache hits:    ${stats.totalHits}`,
+        `Avg effectiveness:   ${(stats.avgEffectiveness * 100).toFixed(1)}%`,
+        `Est. tokens saved:   ~${stats.estimatedTokensSaved.toLocaleString()}`,
+    ];
+    return lines.join('\n');
+}

package/dist/skills-lock.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Skills-Lock — record canonical hashes for every active skill.
+ *
+ * Stored as `skills-lock.json` at the package root. Each entry records the
+ * version (frontmatter), a sha256 of the SKILL.md content, and a generated
+ * timestamp. The postinstall verifier compares the current SKILL.md hashes
+ * against the lock and warns on drift.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSkillsLock = buildSkillsLock;
+exports.writeSkillsLock = writeSkillsLock;
+exports.verifySkillsLock = verifySkillsLock;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+function sha256OfFile(file) {
+    const buf = fs_1.default.readFileSync(file);
+    return crypto_1.default.createHash('sha256').update(buf).digest('hex');
+}
+function parseFrontmatter(text) {
+    const m = text.match(/^---\n([\s\S]*?)\n---/);
+    if (!m)
+        return {};
+    const out = {};
+    const v = m[1].match(/^version:\s*['"]?([\w.\-+]+)['"]?\s*$/m);
+    if (v)
+        out.version = v[1];
+    const d = m[1].match(/^deprecated:\s*(true|false)\s*$/m);
+    if (d)
+        out.deprecated = d[1] === 'true';
+    return out;
+}
+function buildSkillsLock(packageRoot) {
+    const skillsDir = path_1.default.join(packageRoot, 'skills');
+    const skills = {};
+    if (fs_1.default.existsSync(skillsDir)) {
+        for (const entry of fs_1.default.readdirSync(skillsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory() || !entry.name.startsWith('cm-'))
+                continue;
+            const skillFile = path_1.default.join(skillsDir, entry.name, 'SKILL.md');
+            if (!fs_1.default.existsSync(skillFile))
+                continue;
+            const text = fs_1.default.readFileSync(skillFile, 'utf8');
+            const fm = parseFrontmatter(text);
+            skills[entry.name] = Object.assign(Object.assign({ sha256: sha256OfFile(skillFile) }, (fm.version ? { version: fm.version } : {})), (fm.deprecated ? { deprecated: true } : {}));
+        }
+    }
+    return {
+        version: 2,
+        generated_at: new Date().toISOString(),
+        skills,
+    };
+}
+function writeSkillsLock(packageRoot) {
+    const lock = buildSkillsLock(packageRoot);
+    const file = path_1.default.join(packageRoot, 'skills-lock.json');
+    fs_1.default.writeFileSync(file, JSON.stringify(lock, null, 2) + '\n', 'utf8');
+    return file;
+}
+function verifySkillsLock(packageRoot) {
+    var _a, _b;
+    const lockPath = path_1.default.join(packageRoot, 'skills-lock.json');
+    const result = { ok: true, missing: [], drifted: [], unlocked: [] };
+    if (!fs_1.default.existsSync(lockPath)) {
+        result.ok = false;
+        return result;
+    }
+    let lock;
+    try {
+        lock = JSON.parse(fs_1.default.readFileSync(lockPath, 'utf8'));
+    }
+    catch (_c) {
+        result.ok = false;
+        return result;
+    }
+    const current = buildSkillsLock(packageRoot);
+    for (const [name, entry] of Object.entries((_a = lock.skills) !== null && _a !== void 0 ? _a : {})) {
+        const cur = current.skills[name];
+        if (!cur) {
+            result.missing.push(name);
+            continue;
+        }
+        if (cur.sha256 !== entry.sha256)
+            result.drifted.push(name);
+    }
+    for (const name of Object.keys(current.skills)) {
+        if (!((_b = lock.skills) !== null && _b !== void 0 ? _b : {})[name])
+            result.unlocked.push(name);
+    }
+    result.ok = result.missing.length === 0 && result.drifted.length === 0;
+    return result;
+}

package/dist/smart-brain-router.js

@@ -0,0 +1,184 @@
+"use strict";
+// ─── Smart Brain Router ─────────────────────────────────────────────────────
+// Task-type classifier + brain tier selector for CodyMaster's 5-Tier Brain.
+// TRIZ #1 Segmentation — load only the brain tiers needed for each task type.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyTask = classifyTask;
+exports.routeTask = routeTask;
+exports.estimateSavings = estimateSavings;
+exports.formatBrainPlan = formatBrainPlan;
+// ─── Tier Costs (average token estimates) ────────────────────────────────────
+const TIER_COSTS = {
+    1: { label: 'Sensory', avgTokens: 0, latencyMs: 0 },
+    2: { label: 'Working', avgTokens: 400, latencyMs: 0 },
+    3: { label: 'Long-term', avgTokens: 650, latencyMs: 50 },
+    4: { label: 'Semantic', avgTokens: 1500, latencyMs: 2000 },
+    5: { label: 'Structural', avgTokens: 3000, latencyMs: 5000 },
+};
+// ─── Task Classifier ────────────────────────────────────────────────────────
+// TRIZ #1 Segmentation — classify to load only what's needed
+/**
+ * Lightweight task classifier — keyword based, no LLM call.
+ * Cost: ~0 tokens, <1ms.
+ */
+function classifyTask(description) {
+    const lower = description.toLowerCase();
+    // Order matters: more specific patterns first
+    if (lower.match(/\b(resume|continue|what was|pick up|carry on|tiếp tục|đang làm gì)\b/)) {
+        return 'resume_session';
+    }
+    if (lower.match(/\b(deploy|ship|release|publish|push to prod|triển khai|xuất bản)\b/)) {
+        return 'deployment';
+    }
+    if (lower.match(/\b(blog|article|content|write about|documentation|bài viết|nội dung|tài liệu)\b/)) {
+        return 'content_creation';
+    }
+    if (lower.match(/\b(fix|bug|error|crash|broken|debug|sửa|lỗi|hỏng)\b/)) {
+        return 'code_change';
+    }
+    if (lower.match(/\b(build|create|implement|add|feature|system|xây|tạo|thêm|tính năng)\b/)) {
+        return 'complex_feature';
+    }
+    // Short descriptive queries are likely simple questions
+    if (lower.match(/\b(what|how|why|explain|status|where|show|list)\b/) && lower.length < 120) {
+        return 'simple_question';
+    }
+    return 'code_change'; // Safe default
+}
+// ─── Brain Router ────────────────────────────────────────────────────────────
+/**
+ * Smart Brain Router — selects minimal brain layers needed for a task.
+ *
+ * Problem solved:
+ *   Without routing, every task loads all 5 tiers = ~5550 tokens + 7s latency.
+ *   With routing, simple tasks use ~0-400 tokens, complex tasks scale progressively.
+ *
+ * Estimated savings: ~60-80% token reduction on brain context loading.
+ */
+function routeTask(taskDescription) {
+    const taskType = classifyTask(taskDescription);
+    switch (taskType) {
+        case 'simple_question':
+            return {
+                taskType,
+                tiers: [1],
+                totalBudget: 200,
+                progressiveLoad: false,
+                rationale: 'Simple question — Tier 1 (Sensory) only. No memory or code context needed.',
+            };
+        case 'resume_session':
+            return {
+                taskType,
+                tiers: [1, 2],
+                totalBudget: 500,
+                progressiveLoad: false,
+                rationale: 'Session resume — Tier 1 + Tier 2 (CONTINUITY.md) to recall working state.',
+            };
+        case 'code_change':
+            return {
+                taskType,
+                tiers: [1, 2, 3, 5],
+                tier3Scope: extractScope(taskDescription),
+                tier5Filter: extractFilePaths(taskDescription),
+                totalBudget: 3000,
+                progressiveLoad: false,
+                rationale: 'Code change — Tiers 1+2+3+5. Learnings scoped, CodeGraph for affected files.',
+            };
+        case 'deployment':
+            return {
+                taskType,
+                tiers: [1, 2, 3],
+                tier3Scope: 'deploy',
+                totalBudget: 1500,
+                progressiveLoad: false,
+                rationale: 'Deployment — Tiers 1+2+3. Scoped learnings for deploy patterns.',
+            };
+        case 'content_creation':
+            return {
+                taskType,
+                tiers: [1, 3, 4],
+                totalBudget: 2000,
+                progressiveLoad: false,
+                rationale: 'Content creation — Tiers 1+3+4. Semantic search for related content.',
+            };
+        case 'complex_feature':
+            return {
+                taskType,
+                tiers: [1, 2, 3, 4, 5],
+                totalBudget: 5000,
+                progressiveLoad: true,
+                rationale: 'Complex feature — All tiers, progressive loading. Start L0, upgrade on demand.',
+            };
+    }
+}
+// ─── Scope Extraction ────────────────────────────────────────────────────────
+/**
+ * Extract a module scope from the task description for Tier 3 scoping.
+ * Returns undefined if no clear scope detected.
+ */
+function extractScope(description) {
+    const lower = description.toLowerCase();
+    // Priority 1: Look for common scope keywords (most reliable)
+    const scopes = ['auth', 'api', 'deploy', 'test', 'build', 'db', 'ui', 'cli', 'i18n', 'security'];
+    const found = scopes.find(s => lower.includes(s));
+    if (found)
+        return found;
+    // Priority 2: Look for explicit "module: xxx" or "component: xxx" patterns
+    const moduleMatch = lower.match(/(?:module|component|service|package)[:\s]+(\w[\w-]*)/);
+    if (moduleMatch)
+        return moduleMatch[1];
+    return undefined;
+}
+/**
+ * Extract file paths mentioned in the task for Tier 5 filtering.
+ */
+function extractFilePaths(description) {
+    const matches = description.match(/[\w./-]+\.(ts|js|tsx|jsx|py|go|rs|md|json|yaml|yml)/g);
+    return matches && matches.length > 0 ? matches : undefined;
+}
+// ─── Token Savings Estimator ─────────────────────────────────────────────────
+/**
+ * Estimate token savings from smart routing vs loading all tiers.
+ */
+function estimateSavings(plan) {
+    const allTiersTokens = Object.values(TIER_COSTS).reduce((sum, t) => sum + t.avgTokens, 0);
+    const planTokens = plan.tiers.reduce((sum, tier) => sum + TIER_COSTS[tier].avgTokens, 0);
+    return {
+        withoutRouting: allTiersTokens,
+        withRouting: planTokens,
+        saved: allTiersTokens - planTokens,
+        percentage: Math.round(((allTiersTokens - planTokens) / allTiersTokens) * 100),
+    };
+}
+// ─── Display Helpers ─────────────────────────────────────────────────────────
+/**
+ * Format a BrainLoadPlan for CLI display.
+ */
+function formatBrainPlan(plan) {
+    const savings = estimateSavings(plan);
+    const tierLabels = plan.tiers.map(t => `  ${t}. ${TIER_COSTS[t].label} (~${TIER_COSTS[t].avgTokens} tokens)`);
+    const lines = [
+        `🧠 Brain Load Plan`,
+        `─`.repeat(50),
+        `Task type:   ${plan.taskType}`,
+        `Progressive: ${plan.progressiveLoad ? 'Yes' : 'No'}`,
+        `Budget:      ${plan.totalBudget.toLocaleString()} tokens`,
+        ``,
+        `Active tiers:`,
+        ...tierLabels,
+        ``,
+        `Token savings:`,
+        `  All tiers:   ~${savings.withoutRouting.toLocaleString()} tokens`,
+        `  This plan:   ~${savings.withRouting.toLocaleString()} tokens`,
+        `  Saved:       ~${savings.saved.toLocaleString()} tokens (${savings.percentage}%)`,
+        ``,
+        `Rationale: ${plan.rationale}`,
+    ];
+    if (plan.tier3Scope) {
+        lines.push(`Tier 3 scope: ${plan.tier3Scope}`);
+    }
+    if (plan.tier5Filter) {
+        lines.push(`Tier 5 filter: ${plan.tier5Filter.join(', ')}`);
+    }
+    return lines.join('\n');
+}

package/dist/sprint-pipeline.js

@@ -2,6 +2,10 @@
 /**
  * Opinionated sprint pipeline + Context Bus files under `.cm/sprint/`.
  * Complements root `context-bus.json` with step artifacts (ADR 002).
+ *
+ * v2.0: optional structured handoff JSON via `src/handoff/`. Sprint skills
+ * may call `completeSprintStepWithHandoff()` to emit a typed handoff file
+ * alongside the Markdown artifact.
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -12,6 +16,7 @@ exports.readSprintState = readSprintState;
 exports.writeSprintState = writeSprintState;
 exports.initSprint = initSprint;
 exports.completeSprintStep = completeSprintStep;
+exports.completeSprintStepWithHandoff = completeSprintStepWithHandoff;
 exports.skipSprintStep = skipSprintStep;
 exports.resetSprint = resetSprint;
 exports.sprintDryRun = sprintDryRun;
@@ -19,6 +24,7 @@ exports.sprintArtifactPreviewFromDisk = sprintArtifactPreviewFromDisk;
 exports.skillMappingForStep = skillMappingForStep;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const handoff_1 = require("./handoff");
 exports.SPRINT_STEPS = [
     'brainstorm',
     'plan',
@@ -109,6 +115,26 @@ function completeSprintStep(projectPath, step, artifactBody) {
     appendEvent(projectPath, { type: 'complete', step, at: state.updated_at });
     return state;
 }
+/**
+ * Complete a sprint step AND emit a typed handoff JSON under `.cm/handoff/`.
+ *
+ * Use this from sprint skills (cm-planning, cm-execution, cm-code-review,
+ * cm-quality-gate, cm-brainstorm-idea, cm-retro-cli) to make their output
+ * machine-readable for the next phase.
+ *
+ * The Markdown artifact is still written; handoff is additive.
+ */
+function completeSprintStepWithHandoff(projectPath, step, artifactBody, handoff) {
+    const state = completeSprintStep(projectPath, step, artifactBody);
+    const handoffFile = (0, handoff_1.writeHandoff)(projectPath, handoff);
+    appendEvent(projectPath, {
+        type: 'handoff',
+        step,
+        schema: handoff.schema,
+        at: state.updated_at,
+    });
+    return { state, handoffFile };
+}
 const SKIP_STUB = (step, at) => `# ${step}\n\n_Skipped via \`cm sprint skip\` at ${at}._\n`;
 function skipSprintStep(projectPath, step) {
     let state = readSprintState(projectPath);

package/dist/storage/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskService = exports.createProjectService = exports.createMessageRepo = exports.createActivityRepo = exports.isValidTransition = exports.createTaskRepo = exports.createProjectRepo = exports.DASHBOARD_DB_PATH = exports.runMigrations = exports.closeDashboardDb = exports.getDashboardDb = void 0;
+var sqlite_1 = require("./sqlite");
+Object.defineProperty(exports, "getDashboardDb", { enumerable: true, get: function () { return sqlite_1.getDashboardDb; } });
+Object.defineProperty(exports, "closeDashboardDb", { enumerable: true, get: function () { return sqlite_1.closeDashboardDb; } });
+Object.defineProperty(exports, "runMigrations", { enumerable: true, get: function () { return sqlite_1.runMigrations; } });
+Object.defineProperty(exports, "DASHBOARD_DB_PATH", { enumerable: true, get: function () { return sqlite_1.DASHBOARD_DB_PATH; } });
+var project_repo_1 = require("./repos/project-repo");
+Object.defineProperty(exports, "createProjectRepo", { enumerable: true, get: function () { return project_repo_1.createProjectRepo; } });
+var task_repo_1 = require("./repos/task-repo");
+Object.defineProperty(exports, "createTaskRepo", { enumerable: true, get: function () { return task_repo_1.createTaskRepo; } });
+Object.defineProperty(exports, "isValidTransition", { enumerable: true, get: function () { return task_repo_1.isValidTransition; } });
+var activity_repo_1 = require("./repos/activity-repo");
+Object.defineProperty(exports, "createActivityRepo", { enumerable: true, get: function () { return activity_repo_1.createActivityRepo; } });
+var message_repo_1 = require("./repos/message-repo");
+Object.defineProperty(exports, "createMessageRepo", { enumerable: true, get: function () { return message_repo_1.createMessageRepo; } });
+var project_service_1 = require("./services/project-service");
+Object.defineProperty(exports, "createProjectService", { enumerable: true, get: function () { return project_service_1.createProjectService; } });
+var task_service_1 = require("./services/task-service");
+Object.defineProperty(exports, "createTaskService", { enumerable: true, get: function () { return task_service_1.createTaskService; } });

package/dist/storage/repos/activity-repo.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActivityRepo = createActivityRepo;
+// ─── Repo ───────────────────────────────────────────────────────────────────
+function createActivityRepo(db) {
+    const insert = db.prepare(`
+    INSERT INTO activities (id, type, message, project_id, task_id, actor_type, actor_id, meta, created_at)
+    VALUES (@id, @type, @message, @project_id, @task_id, @actor_type, @actor_id, @meta, @created_at)
+  `);
+    const getById = db.prepare('SELECT * FROM activities WHERE id = ?');
+    const getByProject = db.prepare('SELECT * FROM activities WHERE project_id = ? ORDER BY created_at DESC LIMIT ?');
+    const getByTask = db.prepare('SELECT * FROM activities WHERE task_id = ? ORDER BY created_at DESC LIMIT ?');
+    const getRecent = db.prepare('SELECT * FROM activities ORDER BY created_at DESC LIMIT ?');
+    return {
+        create(input) {
+            var _a, _b, _c, _d;
+            const now = new Date().toISOString();
+            const row = {
+                id: input.id,
+                type: input.type,
+                message: input.message,
+                project_id: (_a = input.project_id) !== null && _a !== void 0 ? _a : null,
+                task_id: (_b = input.task_id) !== null && _b !== void 0 ? _b : null,
+                actor_type: (_c = input.actor_type) !== null && _c !== void 0 ? _c : null,
+                actor_id: (_d = input.actor_id) !== null && _d !== void 0 ? _d : null,
+                meta: input.meta ? JSON.stringify(input.meta) : null,
+                created_at: now,
+            };
+            insert.run(row);
+            return row;
+        },
+        getById(id) {
+            var _a;
+            return (_a = getById.get(id)) !== null && _a !== void 0 ? _a : null;
+        },
+        getByProject(projectId, limit = 50) {
+            return getByProject.all(projectId, limit);
+        },
+        getByTask(taskId, limit = 50) {
+            return getByTask.all(taskId, limit);
+        },
+        getRecent(limit = 50) {
+            return getRecent.all(limit);
+        },
+    };
+}