codymaster 5.2.0 → 7.0.0

package/dist/learnings.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * Per-project learnings — append-only JSONL log under `.cm/learnings.jsonl`.
+ *
+ * Each learning is a small structured note that future sessions read at start
+ * (via cm-continuity) so the agent doesn't repeat past pitfalls or forget
+ * preferences. Inspired by gstack `/learn` but simpler — no sync required.
+ *
+ * Format (one JSON object per line):
+ *   { "ts": "2026-05-07T12:00:00Z",
+ *     "type": "pitfall" | "preference" | "pattern" | "fact",
+ *     "scope": "deploy" | "ui" | "test" | ...,
+ *     "note": "human readable note",
+ *     "source": "cm-retro-cli" | "manual" | ... }
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LearningError = void 0;
+exports.learningsPath = learningsPath;
+exports.addLearning = addLearning;
+exports.listLearnings = listLearnings;
+exports.pruneLearnings = pruneLearnings;
+exports.anonymize = anonymize;
+exports.learningKey = learningKey;
+exports.mergeLearnings = mergeLearnings;
+exports.readLearningsFile = readLearningsFile;
+exports.writeLearningsFile = writeLearningsFile;
+exports.renderLearningsForContinuity = renderLearningsForContinuity;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const LEARNING_TYPES = new Set(['pitfall', 'preference', 'pattern', 'fact']);
+function learningsPath(projectPath) {
+    return path_1.default.join(projectPath, '.cm', 'learnings.jsonl');
+}
+function ensureDir(file) {
+    const d = path_1.default.dirname(file);
+    if (!fs_1.default.existsSync(d))
+        fs_1.default.mkdirSync(d, { recursive: true });
+}
+class LearningError extends Error {
+}
+exports.LearningError = LearningError;
+function validate(input) {
+    if (!LEARNING_TYPES.has(input.type)) {
+        throw new LearningError(`invalid learning type: ${input.type}`);
+    }
+    if (!input.scope || typeof input.scope !== 'string') {
+        throw new LearningError('learning.scope is required (string)');
+    }
+    if (!input.note || typeof input.note !== 'string') {
+        throw new LearningError('learning.note is required (string)');
+    }
+    if (input.note.length > 500) {
+        throw new LearningError(`learning.note too long (${input.note.length} > 500)`);
+    }
+}
+function addLearning(projectPath, input) {
+    var _a;
+    validate(input);
+    const learning = Object.assign({ ts: (_a = input.ts) !== null && _a !== void 0 ? _a : new Date().toISOString(), type: input.type, scope: input.scope, note: input.note }, (input.source ? { source: input.source } : {}));
+    const file = learningsPath(projectPath);
+    ensureDir(file);
+    fs_1.default.appendFileSync(file, JSON.stringify(learning) + '\n', 'utf8');
+    return learning;
+}
+function listLearnings(projectPath, query = {}) {
+    const file = learningsPath(projectPath);
+    if (!fs_1.default.existsSync(file))
+        return [];
+    const raw = fs_1.default.readFileSync(file, 'utf8');
+    const out = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (_a) {
+            continue; // skip malformed lines
+        }
+        if (query.type && parsed.type !== query.type)
+            continue;
+        if (query.scope && parsed.scope !== query.scope)
+            continue;
+        if (query.since && parsed.ts < query.since)
+            continue;
+        out.push(parsed);
+    }
+    // Newest first.
+    out.reverse();
+    if (query.limit && out.length > query.limit)
+        return out.slice(0, query.limit);
+    return out;
+}
+/**
+ * Remove learnings older than `maxAgeDays` (default 180).
+ * Returns the number of pruned entries.
+ */
+function pruneLearnings(projectPath, maxAgeDays = 180) {
+    const file = learningsPath(projectPath);
+    if (!fs_1.default.existsSync(file))
+        return 0;
+    const cutoff = new Date(Date.now() - maxAgeDays * 24 * 60 * 60 * 1000).toISOString();
+    const raw = fs_1.default.readFileSync(file, 'utf8');
+    const kept = [];
+    let pruned = 0;
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.ts >= cutoff) {
+                kept.push(line);
+            }
+            else {
+                pruned++;
+            }
+        }
+        catch (_a) {
+            kept.push(line); // keep malformed lines as-is
+        }
+    }
+    fs_1.default.writeFileSync(file, kept.join('\n') + (kept.length ? '\n' : ''), 'utf8');
+    return pruned;
+}
+/**
+ * Strip user-identifying / token-looking material from a learning before it
+ * leaves the project. Used by `cm learn sync` to push to a shared remote
+ * without leaking absolute paths, emails, or long credentials.
+ */
+function anonymize(l) {
+    const stripPath = (s) => s
+        .replace(/\/Users\/[^/\s"']+/g, '~')
+        .replace(/\/home\/[^/\s"']+/g, '~')
+        .replace(/[A-Za-z]:\\Users\\[^\\\s"']+/g, '~');
+    const stripEmail = (s) => s.replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '<email>');
+    const stripToken = (s) => 
+    // Long opaque tokens — runs of 24+ url-safe chars without spaces.
+    s.replace(/[A-Za-z0-9_\-]{24,}/g, '<token>');
+    const clean = (s) => stripToken(stripEmail(stripPath(s)));
+    return Object.assign({ ts: l.ts, type: l.type, scope: clean(l.scope), note: clean(l.note) }, (l.source ? { source: clean(l.source) } : {}));
+}
+/**
+ * Stable identity hash for dedup across machines. Excludes `ts` so the same
+ * note appearing on two days collapses to one entry.
+ */
+function learningKey(l) {
+    return `${l.type}|${l.scope}|${l.note}`;
+}
+/**
+ * Merge two learning lists, dropping duplicates by `learningKey`. The earliest
+ * timestamp wins (we treat the original observation as canonical).
+ */
+function mergeLearnings(a, b) {
+    const map = new Map();
+    for (const l of [...a, ...b]) {
+        const k = learningKey(l);
+        const prev = map.get(k);
+        if (!prev || l.ts < prev.ts)
+            map.set(k, l);
+    }
+    return Array.from(map.values()).sort((x, y) => (x.ts < y.ts ? -1 : 1));
+}
+/**
+ * Read the JSONL file at an arbitrary path (used by sync to read the remote
+ * mirror copy). Returns [] if the file is missing.
+ */
+function readLearningsFile(file) {
+    if (!fs_1.default.existsSync(file))
+        return [];
+    const out = [];
+    for (const line of fs_1.default.readFileSync(file, 'utf8').split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch (_a) {
+            // skip malformed
+        }
+    }
+    return out;
+}
+function writeLearningsFile(file, list) {
+    const dir = path_1.default.dirname(file);
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    const body = list.map(l => JSON.stringify(l)).join('\n');
+    fs_1.default.writeFileSync(file, list.length ? body + '\n' : '', 'utf8');
+}
+/**
+ * Render the most recent N learnings as a compact Markdown block, suitable
+ * for injection into CONTINUITY.md by cm-continuity at session start.
+ */
+function renderLearningsForContinuity(projectPath, limit = 10) {
+    const recent = listLearnings(projectPath, { limit });
+    if (recent.length === 0)
+        return '';
+    const lines = ['## Recent Learnings (auto-loaded)'];
+    for (const l of recent) {
+        const date = l.ts.slice(0, 10);
+        lines.push(`- [${date}] **${l.type}/${l.scope}**: ${l.note}`);
+    }
+    return lines.join('\n') + '\n';
+}

package/dist/middleware/metrics.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incMetric = incMetric;
+exports.setMetric = setMetric;
+exports.metricsHandler = metricsHandler;
+const metrics = {
+    cm_tasks_running: 0,
+    cm_dispatch_total: 0,
+    cm_dispatch_duration_seconds_sum: 0,
+    cm_dispatch_duration_seconds_count: 0,
+    cm_backend_errors_total: 0,
+    cm_requests_total: 0,
+};
+function incMetric(name, value = 1) {
+    if (name in metrics) {
+        metrics[name] += value;
+    }
+}
+function setMetric(name, value) {
+    metrics[name] = value;
+}
+function metricsHandler(_req, res) {
+    let output = '';
+    for (const [key, value] of Object.entries(metrics)) {
+        output += `# TYPE ${key} counter\n`;
+        output += `${key} ${value}\n`;
+    }
+    res.setHeader('Content-Type', 'text/plain; version=0.0.4');
+    res.send(output);
+}

package/dist/middleware/security-headers.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.securityHeaders = securityHeaders;
+function securityHeaders() {
+    return (_req, res, next) => {
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('X-Frame-Options', 'DENY');
+        res.setHeader('X-XSS-Protection', '1; mode=block');
+        res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+        res.setHeader('Permissions-Policy', 'camera=(), microphone=(), geolocation=()');
+        res.setHeader('Content-Security-Policy', "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self';");
+        next();
+    };
+}

package/dist/realtime/event-bus.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventBus = exports.EventBus = void 0;
+const events_1 = require("events");
+class EventBus extends events_1.EventEmitter {
+    emit(event, data) {
+        return super.emit(event, data);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    emitTask(event) {
+        this.emit('task', event);
+        this.emit(event.type, event);
+    }
+    emitActivity(event) {
+        this.emit('activity', event);
+        this.emit(event.type, event);
+    }
+    emitAgent(event) {
+        this.emit('agent', event);
+        this.emit(event.type, event);
+    }
+}
+exports.EventBus = EventBus;
+exports.eventBus = new EventBus();

package/dist/realtime/ws-hub.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.broadcastToProject = broadcastToProject;
+exports.broadcastAll = broadcastAll;
+exports.initWsHub = initWsHub;
+const ws_1 = require("ws");
+const event_bus_1 = require("./event-bus");
+const HEARTBEAT_INTERVAL = 15000;
+const MAX_BUFFER = 100;
+const clients = new Set();
+function send(client, event) {
+    if (client.ws.readyState !== ws_1.WebSocket.OPEN)
+        return;
+    client.buffer.push(event);
+    if (client.buffer.length > MAX_BUFFER) {
+        client.buffer.shift();
+    }
+    client.ws.send(JSON.stringify(event));
+}
+function broadcastToProject(projectId, event) {
+    for (const client of clients) {
+        if (client.projectId === projectId) {
+            send(client, event);
+        }
+    }
+}
+function broadcastAll(event) {
+    for (const client of clients) {
+        send(client, event);
+    }
+}
+function initWsHub(server) {
+    const wss = new ws_1.WebSocketServer({ server, path: '/ws' });
+    wss.on('connection', (ws) => {
+        const client = { ws, buffer: [], alive: true };
+        clients.add(client);
+        ws.on('message', (raw) => {
+            let msg;
+            try {
+                msg = JSON.parse(raw.toString());
+            }
+            catch (_a) {
+                return;
+            }
+            if (msg.action === 'subscribe' && msg.projectId) {
+                client.projectId = msg.projectId;
+                ws.send(JSON.stringify({ type: 'subscribed', projectId: msg.projectId }));
+            }
+            else if (msg.action === 'unsubscribe') {
+                client.projectId = undefined;
+                ws.send(JSON.stringify({ type: 'unsubscribed' }));
+            }
+        });
+        ws.on('pong', () => {
+            client.alive = true;
+        });
+        ws.on('close', () => {
+            clients.delete(client);
+        });
+        ws.on('error', () => {
+            clients.delete(client);
+        });
+    });
+    const heartbeat = setInterval(() => {
+        for (const client of clients) {
+            if (!client.alive) {
+                client.ws.terminate();
+                clients.delete(client);
+                continue;
+            }
+            client.alive = false;
+            client.ws.ping();
+        }
+    }, HEARTBEAT_INTERVAL);
+    wss.on('close', () => {
+        clearInterval(heartbeat);
+    });
+    event_bus_1.eventBus.on('task', (event) => {
+        if ('projectId' in event) {
+            broadcastToProject(event.projectId, event);
+        }
+    });
+    event_bus_1.eventBus.on('activity', (event) => {
+        if ('activity' in event && event.activity.projectId) {
+            broadcastToProject(event.activity.projectId, event);
+        }
+    });
+    event_bus_1.eventBus.on('agent', (event) => {
+        broadcastAll(event);
+    });
+}

package/dist/schemas/task-schema.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectSchema = exports.autoSyncSchema = exports.updateTaskSchema = exports.createTaskSchema = void 0;
+exports.createTaskSchema = {
+    type: 'object',
+    required: ['projectId', 'title'],
+    properties: {
+        projectId: { type: 'string', minLength: 1 },
+        title: { type: 'string', minLength: 1 },
+        description: { type: 'string' },
+        column: { type: 'string', enum: ['backlog', 'in-progress', 'review', 'done'] },
+        priority: { type: 'string', enum: ['low', 'medium', 'high', 'urgent'] },
+        agent: { type: 'string' },
+        skill: { type: 'string' },
+    },
+    additionalProperties: false,
+};
+exports.updateTaskSchema = {
+    type: 'object',
+    properties: {
+        title: { type: 'string', minLength: 1 },
+        description: { type: 'string' },
+        priority: { type: 'string', enum: ['low', 'medium', 'high', 'urgent'] },
+    },
+    additionalProperties: false,
+    minProperties: 1,
+};
+exports.autoSyncSchema = {
+    type: 'object',
+    required: ['conversationId', 'title'],
+    properties: {
+        conversationId: { type: 'string', minLength: 1 },
+        title: { type: 'string', minLength: 1 },
+        status: { type: 'string' },
+        column: { type: 'string', enum: ['backlog', 'in-progress', 'review', 'done'] },
+    },
+    additionalProperties: true,
+};
+exports.createProjectSchema = {
+    type: 'object',
+    required: ['name'],
+    properties: {
+        name: { type: 'string', minLength: 1 },
+        path: { type: 'string' },
+        agents: { type: 'array', items: { type: 'string' } },
+    },
+    additionalProperties: false,
+};

package/dist/schemas/validate.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBody = validateBody;
+const ajv_1 = __importDefault(require("ajv"));
+const ajv = new ajv_1.default();
+function validateBody(schema) {
+    const validate = ajv.compile(schema);
+    return (req, res, next) => {
+        if (!validate(req.body)) {
+            res.status(400).json({ error: 'Validation failed', details: validate.errors });
+            return;
+        }
+        next();
+    };
+}

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/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);
+        },
+    };
+}