clitrigger 0.1.11 → 0.1.13

package/dist/server/routes/memory.js

@@ -0,0 +1,651 @@
+import { Router } from 'express';
+import { exec } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import * as queries from '../db/queries.js';
+import { buildMemoryBlock } from '../services/memory-injector.js';
+import { ingestSource, lintWiki, buildSourceTextFromTodo, buildSourceTextFromDiscussion } from '../services/memory-ingest.js';
+import { appendWikilinkToBody, findBacklinks, parseWikilinks, replaceTitleInBody, resolveWikilinks, } from '../services/memory-wikilinks.js';
+const router = Router();
+const VALID_RELATION_TYPES = new Set([
+    'related',
+    'precedes',
+    'example_of',
+    'counter_example',
+    'refines',
+]);
+function normalizeTags(input) {
+    if (input === undefined || input === null)
+        return null;
+    if (typeof input === 'string') {
+        if (!input.trim())
+            return null;
+        try {
+            const parsed = JSON.parse(input);
+            if (Array.isArray(parsed)) {
+                const cleaned = parsed.map(String).map(s => s.trim()).filter(Boolean);
+                return cleaned.length > 0 ? JSON.stringify(cleaned) : null;
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
+    if (Array.isArray(input)) {
+        const cleaned = input.map(String).map(s => s.trim()).filter(Boolean);
+        return cleaned.length > 0 ? JSON.stringify(cleaned) : null;
+    }
+    return null;
+}
+function isValidRelation(value) {
+    return typeof value === 'string' && VALID_RELATION_TYPES.has(value);
+}
+// ── Graph (combined) ──
+router.get('/projects/:id/memory/graph', (req, res) => {
+    try {
+        const project = queries.getProjectById(req.params.id);
+        if (!project) {
+            res.status(404).json({ error: 'Project not found' });
+            return;
+        }
+        const nodes = queries.getMemoryNodesByProjectId(req.params.id);
+        const edges = queries.getMemoryEdgesByProjectId(req.params.id);
+        res.json({ nodes, edges });
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+// ── Nodes ──
+router.get('/projects/:id/memory/nodes', (req, res) => {
+    try {
+        const project = queries.getProjectById(req.params.id);
+        if (!project) {
+            res.status(404).json({ error: 'Project not found' });
+            return;
+        }
+        res.json(queries.getMemoryNodesByProjectId(req.params.id));
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+router.post('/projects/:id/memory/nodes', (req, res) => {
+    try {
+        const project = queries.getProjectById(req.params.id);
+        if (!project) {
+            res.status(404).json({ error: 'Project not found' });
+            return;
+        }
+        const { title, body, tags, pinned } = req.body ?? {};
+        if (!title || typeof title !== 'string' || !title.trim()) {
+            res.status(400).json({ error: 'title is required' });
+            return;
+        }
+        const trimmedTitle = title.trim();
+        if (queries.getMemoryNodeByTitle(req.params.id, trimmedTitle)) {
+            res.status(409).json({ error: 'A memory node with this title already exists in this project' });
+            return;
+        }
+        try {
+            const node = queries.createMemoryNode(req.params.id, trimmedTitle, typeof body === 'string' ? body : '', normalizeTags(tags), pinned ? 1 : 0);
+            res.status(201).json(node);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes('UNIQUE')) {
+                res.status(409).json({ error: 'A memory node with this title already exists in this project' });
+                return;
+            }
+            throw err;
+        }
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+router.put('/memory/nodes/:nodeId', (req, res) => {
+    try {
+        const existing = queries.getMemoryNodeById(req.params.nodeId);
+        if (!existing) {
+            res.status(404).json({ error: 'Memory node not found' });
+            return;
+        }
+        const { title, body, tags, pinned } = req.body ?? {};
+        const updates = {};
+        let titleChange = null;
+        if (title !== undefined) {
+            if (typeof title !== 'string' || !title.trim()) {
+                res.status(400).json({ error: 'title cannot be empty' });
+                return;
+            }
+            const trimmed = title.trim();
+            if (trimmed.toLowerCase() !== existing.title.toLowerCase()) {
+                const conflict = queries.getMemoryNodeByTitle(existing.project_id, trimmed);
+                if (conflict && conflict.id !== existing.id) {
+                    res.status(409).json({ error: 'A memory node with this title already exists in this project' });
+                    return;
+                }
+            }
+            if (trimmed !== existing.title) {
+                titleChange = { from: existing.title, to: trimmed };
+            }
+            updates.title = trimmed;
+        }
+        if (body !== undefined)
+            updates.body = typeof body === 'string' ? body : '';
+        if (tags !== undefined)
+            updates.tags = normalizeTags(tags);
+        if (pinned !== undefined)
+            updates.pinned = pinned ? 1 : 0;
+        let updated;
+        try {
+            updated = queries.updateMemoryNode(req.params.nodeId, updates);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes('UNIQUE')) {
+                res.status(409).json({ error: 'A memory node with this title already exists in this project' });
+                return;
+            }
+            throw err;
+        }
+        // Cascade rename: rewrite [[oldTitle]] → [[newTitle]] across other nodes' bodies
+        if (titleChange) {
+            const others = queries.getMemoryNodesByProjectId(existing.project_id);
+            for (const other of others) {
+                if (other.id === existing.id)
+                    continue;
+                if (!other.body)
+                    continue;
+                const rewritten = replaceTitleInBody(other.body, titleChange.from, titleChange.to);
+                if (rewritten !== other.body) {
+                    queries.updateMemoryNode(other.id, { body: rewritten });
+                }
+            }
+        }
+        res.json(updated);
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+router.put('/memory/nodes/:nodeId/position', (req, res) => {
+    try {
+        const existing = queries.getMemoryNodeById(req.params.nodeId);
+        if (!existing) {
+            res.status(404).json({ error: 'Memory node not found' });
+            return;
+        }
+        const { position_x, position_y } = req.body ?? {};
+        const x = Number(position_x);
+        const y = Number(position_y);
+        if (!Number.isFinite(x) || !Number.isFinite(y)) {
+            res.status(400).json({ error: 'position_x and position_y must be numbers' });
+            return;
+        }
+        queries.updateMemoryNodePosition(req.params.nodeId, x, y);
+        res.status(204).send();
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+router.delete('/memory/nodes/:nodeId', (req, res) => {
+    try {
+        const existing = queries.getMemoryNodeById(req.params.nodeId);
+        if (!existing) {
+            res.status(404).json({ error: 'Memory node not found' });
+            return;
+        }
+        queries.deleteMemoryNode(req.params.nodeId);
+        res.status(204).send();
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+// ── Wikilinks (body-level references) ──
+router.get('/memory/nodes/:nodeId/backlinks', (req, res) => {
+    try {
+        const node = queries.getMemoryNodeById(req.params.nodeId);
+        if (!node) {
+            res.status(404).json({ error: 'Memory node not found' });
+            return;
+        }
+        const hits = findBacklinks(node.project_id, node.title, node.id);
+        res.json(hits.map(h => ({
+            id: h.source.id,
+            title: h.source.title,
+            snippet: h.snippet,
+        })));
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+router.post('/memory/nodes/:nodeId/insert-link', (req, res) => {
+    try {
+        const source = queries.getMemoryNodeById(req.params.nodeId);
+        if (!source) {
+            res.status(404).json({ error: 'Source node not found' });
+            return;
+        }
+        const { targetTitle, targetNodeId } = req.body ?? {};
+        let title;
+        if (targetNodeId) {
+            const target = queries.getMemoryNodeById(String(targetNodeId));
+            if (!target || target.project_id !== source.project_id) {
+                res.status(404).json({ error: 'Target node not found in this project' });
+                return;
+            }
+            title = target.title;
+        }
+        else if (typeof targetTitle === 'string' && targetTitle.trim()) {
+            title = targetTitle.trim();
+        }
+        else {
+            res.status(400).json({ error: 'targetTitle or targetNodeId required' });
+            return;
+        }
+        const newBody = appendWikilinkToBody(source.body || '', title);
+        const updated = queries.updateMemoryNode(source.id, { body: newBody });
+        res.json(updated);
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+router.post('/projects/:id/memory/wikilinks/resolve', (req, res) => {
+    try {
+        const project = queries.getProjectById(req.params.id);
+        if (!project) {
+            res.status(404).json({ error: 'Project not found' });
+            return;
+        }
+        const { body, titles } = req.body ?? {};
+        let titleList = [];
+        if (Array.isArray(titles)) {
+            titleList = titles.map(String).filter(Boolean);
+        }
+        else if (typeof body === 'string') {
+            titleList = parseWikilinks(body).map(r => r.title);
+        }
+        else {
+            res.status(400).json({ error: 'Provide body or titles[]' });
+            return;
+        }
+        const resolved = resolveWikilinks(req.params.id, titleList);
+        res.json(resolved);
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+// ── Edges ──
+router.post('/projects/:id/memory/edges', (req, res) => {
+    try {
+        const project = queries.getProjectById(req.params.id);
+        if (!project) {
+            res.status(404).json({ error: 'Project not found' });
+            return;
+        }
+        const { from_node_id, to_node_id, relation_type, label } = req.body ?? {};
+        if (!from_node_id || !to_node_id) {
+            res.status(400).json({ error: 'from_node_id and to_node_id are required' });
+            return;
+        }
+        if (from_node_id === to_node_id) {
+            res.status(400).json({ error: 'Self-edges are not allowed' });
+            return;
+        }
+        const fromNode = queries.getMemoryNodeById(from_node_id);
+        const toNode = queries.getMemoryNodeById(to_node_id);
+        if (!fromNode || !toNode) {
+            res.status(404).json({ error: 'Source or target node not found' });
+            return;
+        }
+        if (fromNode.project_id !== req.params.id || toNode.project_id !== req.params.id) {
+            res.status(400).json({ error: 'Nodes must belong to this project' });
+            return;
+        }
+        const rt = isValidRelation(relation_type) ? relation_type : 'related';
+        try {
+            const edge = queries.createMemoryEdge(req.params.id, from_node_id, to_node_id, rt, label ?? null);
+            res.status(201).json(edge);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes('UNIQUE')) {
+                res.status(409).json({ error: 'An edge with this relation already exists between these nodes' });
+                return;
+            }
+            throw err;
+        }
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+router.put('/memory/edges/:edgeId', (req, res) => {
+    try {
+        const existing = queries.getMemoryEdgeById(req.params.edgeId);
+        if (!existing) {
+            res.status(404).json({ error: 'Memory edge not found' });
+            return;
+        }
+        const { relation_type, label } = req.body ?? {};
+        const updates = {};
+        if (relation_type !== undefined) {
+            if (!isValidRelation(relation_type)) {
+                res.status(400).json({ error: 'Invalid relation_type' });
+                return;
+            }
+            updates.relation_type = relation_type;
+        }
+        if (label !== undefined)
+            updates.label = label === null ? null : String(label);
+        const updated = queries.updateMemoryEdge(req.params.edgeId, updates);
+        res.json(updated);
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+router.delete('/memory/edges/:edgeId', (req, res) => {
+    try {
+        const existing = queries.getMemoryEdgeById(req.params.edgeId);
+        if (!existing) {
+            res.status(404).json({ error: 'Memory edge not found' });
+            return;
+        }
+        queries.deleteMemoryEdge(req.params.edgeId);
+        res.status(204).send();
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+// ── Ingest (LLM-driven wiki update from raw source) ──
+router.post('/projects/:id/memory/ingest', async (req, res) => {
+    try {
+        const project = queries.getProjectById(req.params.id);
+        if (!project) {
+            res.status(404).json({ error: 'Project not found' });
+            return;
+        }
+        const { source_text, source_type, source_id } = req.body ?? {};
+        const stype = typeof source_type === 'string' ? source_type : null;
+        const sid = typeof source_id === 'string' ? source_id : null;
+        let text;
+        let titleHint = null;
+        if (stype === 'todo' && sid) {
+            const todo = queries.getTodoById(sid);
+            if (!todo || todo.project_id !== project.id) {
+                res.status(404).json({ error: 'Todo not found' });
+                return;
+            }
+            const built = buildSourceTextFromTodo(sid);
+            if (!built) {
+                res.status(400).json({ error: 'Todo has no ingestable content yet' });
+                return;
+            }
+            text = built;
+            titleHint = todo.title;
+        }
+        else if (stype === 'discussion' && sid) {
+            const discussion = queries.getDiscussionById(sid);
+            if (!discussion || discussion.project_id !== project.id) {
+                res.status(404).json({ error: 'Discussion not found' });
+                return;
+            }
+            const built = buildSourceTextFromDiscussion(sid);
+            if (!built) {
+                res.status(400).json({ error: 'Discussion has no ingestable content yet' });
+                return;
+            }
+            text = built;
+            titleHint = discussion.title;
+        }
+        else {
+            // manual paste (or any direct source_text)
+            if (!source_text || typeof source_text !== 'string' || !source_text.trim()) {
+                res.status(400).json({ error: 'source_text is required for manual ingest' });
+                return;
+            }
+            text = source_text.trim();
+        }
+        const result = await ingestSource(req.params.id, text, stype === 'todo' || stype === 'discussion' ? stype : 'manual', sid, titleHint);
+        res.json(result);
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+// ── Raw source viewer ──
+const RAW_SOURCE_TYPES = ['todo', 'discussion', 'manual'];
+const RAW_DIR = '.clitrigger/raw';
+router.get('/projects/:id/memory/raw-files', (req, res) => {
+    try {
+        const project = queries.getProjectById(req.params.id);
+        if (!project) {
+            res.status(404).json({ error: 'Project not found' });
+            return;
+        }
+        if (!project.path) {
+            res.json({ files: [] });
+            return;
+        }
+        const allNodes = queries.getMemoryNodesByProjectId(req.params.id);
+        const derivedByPath = new Map();
+        for (const n of allNodes) {
+            if (!n.source_path)
+                continue;
+            const list = derivedByPath.get(n.source_path);
+            if (list)
+                list.push(n.id);
+            else
+                derivedByPath.set(n.source_path, [n.id]);
+        }
+        const projectRoot = path.resolve(project.path);
+        const files = [];
+        for (const sourceType of RAW_SOURCE_TYPES) {
+            const dir = path.join(projectRoot, RAW_DIR, sourceType);
+            if (!fs.existsSync(dir))
+                continue;
+            let entries;
+            try {
+                entries = fs.readdirSync(dir);
+            }
+            catch {
+                continue;
+            }
+            for (const filename of entries) {
+                if (filename.startsWith('.'))
+                    continue;
+                const absPath = path.join(dir, filename);
+                const resolvedAbs = path.resolve(absPath);
+                const resolvedDir = path.resolve(dir);
+                if (!resolvedAbs.startsWith(resolvedDir + path.sep))
+                    continue;
+                let stat;
+                try {
+                    stat = fs.statSync(absPath);
+                }
+                catch {
+                    continue;
+                }
+                if (!stat.isFile())
+                    continue;
+                const relativePath = `${RAW_DIR}/${sourceType}/${filename}`;
+                files.push({
+                    source_type: sourceType,
+                    filename,
+                    relative_path: relativePath,
+                    size: stat.size,
+                    mtime: stat.mtime.toISOString(),
+                    derived_node_ids: derivedByPath.get(relativePath) ?? [],
+                });
+            }
+        }
+        files.sort((a, b) => b.mtime.localeCompare(a.mtime));
+        res.json({ files });
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+router.get('/projects/:id/memory/raw-files/content', (req, res) => {
+    try {
+        const project = queries.getProjectById(req.params.id);
+        if (!project || !project.path) {
+            res.status(404).json({ error: 'Project not found' });
+            return;
+        }
+        const relPathRaw = req.query.path;
+        if (typeof relPathRaw !== 'string' || !relPathRaw.trim()) {
+            res.status(400).json({ error: 'path query param is required' });
+            return;
+        }
+        const projectRoot = path.resolve(project.path);
+        const rawRoot = path.resolve(projectRoot, RAW_DIR);
+        const absPath = path.resolve(projectRoot, relPathRaw);
+        if (!absPath.startsWith(rawRoot + path.sep)) {
+            res.status(400).json({ error: 'Path must be within the raw sources directory' });
+            return;
+        }
+        if (!fs.existsSync(absPath)) {
+            res.status(404).json({ error: 'Raw file not found', path: relPathRaw });
+            return;
+        }
+        const stat = fs.statSync(absPath);
+        if (!stat.isFile()) {
+            res.status(400).json({ error: 'Path is not a file' });
+            return;
+        }
+        const content = fs.readFileSync(absPath, 'utf-8');
+        res.type('text/markdown; charset=utf-8').send(content);
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+router.post('/projects/:id/memory/raw-files/open', (req, res) => {
+    try {
+        const project = queries.getProjectById(req.params.id);
+        if (!project || !project.path) {
+            res.status(404).json({ error: 'Project not found' });
+            return;
+        }
+        const { path: relPathRaw, mode } = req.body ?? {};
+        if (typeof relPathRaw !== 'string' || !relPathRaw.trim()) {
+            res.status(400).json({ error: 'path is required' });
+            return;
+        }
+        const projectRoot = path.resolve(project.path);
+        const rawRoot = path.resolve(projectRoot, RAW_DIR);
+        const absPath = path.resolve(projectRoot, relPathRaw);
+        if (!absPath.startsWith(rawRoot + path.sep)) {
+            res.status(400).json({ error: 'Path must be within the raw sources directory' });
+            return;
+        }
+        if (!fs.existsSync(absPath)) {
+            res.status(404).json({ error: 'Raw file not found', path: relPathRaw });
+            return;
+        }
+        // mode === 'reveal' → open the containing folder, else open the file itself
+        const target = mode === 'reveal' ? path.dirname(absPath) : absPath;
+        if (process.platform === 'win32') {
+            if (mode === 'reveal') {
+                exec(`explorer.exe /select,"${absPath}"`);
+            }
+            else {
+                exec(`start "" "${target}"`, { windowsHide: true });
+            }
+        }
+        else if (process.platform === 'darwin') {
+            exec(mode === 'reveal' ? `open -R "${absPath}"` : `open "${target}"`);
+        }
+        else {
+            exec(`xdg-open "${target}"`);
+        }
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+router.get('/memory/nodes/:nodeId/raw', (req, res) => {
+    try {
+        const node = queries.getMemoryNodeById(req.params.nodeId);
+        if (!node) {
+            res.status(404).json({ error: 'Memory node not found' });
+            return;
+        }
+        if (!node.source_path) {
+            res.status(404).json({ error: 'No raw source associated with this node' });
+            return;
+        }
+        const project = queries.getProjectById(node.project_id);
+        if (!project || !project.path) {
+            res.status(404).json({ error: 'Project path unavailable' });
+            return;
+        }
+        // Path traversal guard: resolved path must be under project root
+        const absPath = path.resolve(project.path, node.source_path);
+        const projectRoot = path.resolve(project.path);
+        if (!absPath.startsWith(projectRoot + path.sep) && absPath !== projectRoot) {
+            res.status(400).json({ error: 'Invalid source path' });
+            return;
+        }
+        if (!fs.existsSync(absPath)) {
+            res.status(404).json({ error: 'Raw source file no longer exists', path: node.source_path });
+            return;
+        }
+        const content = fs.readFileSync(absPath, 'utf-8');
+        res.type('text/markdown; charset=utf-8').send(content);
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+// ── Lint (LLM-driven wiki health check) ──
+router.post('/projects/:id/memory/lint', async (req, res) => {
+    try {
+        const project = queries.getProjectById(req.params.id);
+        if (!project) {
+            res.status(404).json({ error: 'Project not found' });
+            return;
+        }
+        const issues = await lintWiki(req.params.id);
+        res.json({ issues });
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+// ── Preview (build prompt block) ──
+router.post('/projects/:id/memory/preview', (req, res) => {
+    try {
+        const project = queries.getProjectById(req.params.id);
+        if (!project) {
+            res.status(404).json({ error: 'Project not found' });
+            return;
+        }
+        const { mode, nodeIds } = req.body ?? {};
+        const m = (mode === 'all' || mode === 'selected') ? mode : 'none';
+        const ids = Array.isArray(nodeIds) ? nodeIds.map(String).filter(Boolean) : [];
+        const result = buildMemoryBlock({ projectId: req.params.id, mode: m, nodeIds: ids });
+        res.json({
+            prompt: result?.block ?? '',
+            nodeCount: result?.nodeCount ?? 0,
+            edgeCount: result?.edgeCount ?? 0,
+        });
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Unknown error' });
+    }
+});
+export default router;
+//# sourceMappingURL=memory.js.map