superintent 0.0.1

package/dist/commands/search.js

@@ -0,0 +1,153 @@
+import { Command } from 'commander';
+import { getClient, closeClient } from '../db/client.js';
+import { parseSearchRow } from '../db/parsers.js';
+import { trackUsage } from '../db/usage.js';
+import { embed } from '../embed/model.js';
+export const searchCommand = new Command('search')
+    .description('Semantic search knowledge base')
+    .argument('<query>', 'Search query')
+    .option('--namespace <namespace>', 'Filter by namespace (project)')
+    .option('--category <category>', 'Filter by category')
+    .option('--ticket-type <type>', 'Filter by origin ticket type (feature|bugfix|refactor|docs|chore|test)')
+    .option('--tags <tags...>', 'Filter by tags (OR logic)')
+    .option('--min-score <n>', 'Minimum similarity score 0-1', '0')
+    .option('--limit <n>', 'Max results', '5')
+    .action(async (query, options) => {
+    try {
+        const client = await getClient();
+        // Generate query embedding
+        const queryEmbedding = await embed(query);
+        // Build query with filters
+        const conditions = ['k.active = 1'];
+        const limit = parseInt(options.limit, 10);
+        const topK = limit * 2; // Fetch extra for filtering
+        const args = [
+            JSON.stringify(queryEmbedding),
+            JSON.stringify(queryEmbedding),
+        ];
+        if (options.namespace) {
+            conditions.push('k.namespace = ?');
+            args.push(options.namespace);
+        }
+        if (options.category) {
+            conditions.push('k.category = ?');
+            args.push(options.category);
+        }
+        if (options.ticketType) {
+            conditions.push('k.origin_ticket_type = ?');
+            args.push(options.ticketType);
+        }
+        // Build SQL with vector search (k must be literal, not bound parameter)
+        const sql = `
+        SELECT
+          k.id, k.namespace, k.chunk_index, k.title, k.content,
+          k.category, k.tags, k.source, k.origin_ticket_id, k.origin_ticket_type, k.confidence, k.active, k.decision_scope,
+          k.usage_count, k.last_used_at, k.created_at,
+          vector_distance_cos(k.embedding, vector32(?)) as distance
+        FROM vector_top_k('knowledge_embedding_idx', vector32(?), ${topK}) AS v
+        JOIN knowledge k ON k.rowid = v.id
+        WHERE ${conditions.join(' AND ')}
+        ORDER BY distance ASC
+        LIMIT ${limit}
+      `;
+        const result = await client.execute({ sql, args });
+        // Filter by min score and tags
+        const minScore = parseFloat(options.minScore);
+        let results = result.rows
+            .map((row) => parseSearchRow(row))
+            .filter((r) => r.score >= minScore);
+        // Filter by tags (OR logic) if provided
+        if (options.tags && options.tags.length > 0) {
+            results = results.filter((r) => {
+                if (!r.tags)
+                    return false;
+                return options.tags.some((tag) => r.tags.includes(tag));
+            });
+        }
+        // Track usage for returned results
+        await trackUsage(results.map(r => r.id));
+        closeClient();
+        const response = {
+            success: true,
+            data: {
+                query,
+                results,
+            },
+        };
+        console.log(JSON.stringify(response));
+    }
+    catch (error) {
+        // Fallback to non-indexed search if vector index doesn't exist or fails
+        const errorMessage = error.message;
+        if (errorMessage.includes('vector_top_k') || errorMessage.includes('vector index') || errorMessage.includes('no such table')) {
+            try {
+                const client = await getClient();
+                const queryEmbedding = await embed(query);
+                const conditions = ['active = 1'];
+                const args = [JSON.stringify(queryEmbedding)];
+                if (options.namespace) {
+                    conditions.push('namespace = ?');
+                    args.push(options.namespace);
+                }
+                if (options.category) {
+                    conditions.push('category = ?');
+                    args.push(options.category);
+                }
+                if (options.ticketType) {
+                    conditions.push('origin_ticket_type = ?');
+                    args.push(options.ticketType);
+                }
+                const sql = `
+            SELECT
+              id, namespace, chunk_index, title, content,
+              category, tags, source, origin_ticket_id, origin_ticket_type, confidence, active, decision_scope,
+              usage_count, last_used_at, created_at,
+              vector_distance_cos(embedding, vector32(?)) as distance
+            FROM knowledge
+            WHERE ${conditions.join(' AND ')}
+            ORDER BY distance ASC
+            LIMIT ?
+          `;
+                args.push(parseInt(options.limit, 10));
+                const result = await client.execute({ sql, args });
+                const minScore = parseFloat(options.minScore);
+                let results = result.rows
+                    .map((row) => parseSearchRow(row))
+                    .filter((r) => r.score >= minScore);
+                if (options.tags && options.tags.length > 0) {
+                    results = results.filter((r) => {
+                        if (!r.tags)
+                            return false;
+                        return options.tags.some((tag) => r.tags.includes(tag));
+                    });
+                }
+                // Track usage for returned results
+                await trackUsage(results.map(r => r.id));
+                closeClient();
+                const response = {
+                    success: true,
+                    data: {
+                        query,
+                        results,
+                    },
+                };
+                console.log(JSON.stringify(response));
+                return;
+            }
+            catch (fallbackError) {
+                const response = {
+                    success: false,
+                    error: `Search failed: ${fallbackError.message}`,
+                };
+                console.log(JSON.stringify(response));
+                process.exit(1);
+            }
+        }
+        const response = {
+            success: false,
+            error: `Search failed: ${errorMessage}`,
+        };
+        console.log(JSON.stringify(response));
+        process.exit(1);
+    }
+});

package/dist/commands/spec.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const specCommand: Command;

package/dist/commands/spec.js

@@ -0,0 +1,283 @@
+import { Command } from 'commander';
+import { getClient, closeClient } from '../db/client.js';
+import { parseSpecRow } from '../db/parsers.js';
+import { readStdin } from '../utils/io.js';
+import { generateId } from '../utils/id.js';
+/**
+ * Parse markdown spec format matching SKILL.md:
+ *
+ * # {spec name}
+ *
+ * ## Summary
+ * ...rest of spec content...
+ */
+function parseMarkdownSpec(markdown) {
+    const lines = markdown.split('\n');
+    const result = { title: '', content: '' };
+    let contentStartIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        // Parse title: # {spec name}
+        if (trimmed.startsWith('# ') && !trimmed.startsWith('## ')) {
+            result.title = trimmed.substring(2).trim();
+            contentStartIndex = i + 1;
+            break;
+        }
+    }
+    // Everything after the title line is content
+    result.content = lines.slice(contentStartIndex).join('\n').trim();
+    return result;
+}
+export const specCommand = new Command('spec')
+    .description('Manage specs');
+// Create subcommand
+specCommand
+    .command('create')
+    .description('Create a new spec from stdin')
+    .option('--stdin', 'Read spec markdown from stdin')
+    .option('--title <title>', 'Spec title')
+    .option('--content <content>', 'Spec content')
+    .action(async (options) => {
+    try {
+        let id;
+        let title;
+        let content;
+        if (options.stdin) {
+            const markdown = await readStdin();
+            const parsed = parseMarkdownSpec(markdown);
+            // Field-level validation
+            const missing = [];
+            if (!parsed.title)
+                missing.push('title: Missing # Title header');
+            if (!parsed.content)
+                missing.push('content: No content found after header');
+            if (missing.length > 0) {
+                const response = {
+                    success: false,
+                    error: missing.join('; '),
+                };
+                console.log(JSON.stringify(response));
+                process.exit(1);
+            }
+            id = generateId('SPEC');
+            title = parsed.title;
+            content = parsed.content;
+        }
+        else {
+            if (!options.title) {
+                const response = {
+                    success: false,
+                    error: 'Required: --title (or use --stdin)',
+                };
+                console.log(JSON.stringify(response));
+                process.exit(1);
+            }
+            id = generateId('SPEC');
+            title = options.title;
+            content = options.content || '';
+        }
+        const client = await getClient();
+        await client.execute({
+            sql: `INSERT INTO specs (id, title, content) VALUES (?, ?, ?)`,
+            args: [id, title, content],
+        });
+        closeClient();
+        const response = {
+            success: true,
+            data: { id, status: 'created' },
+        };
+        console.log(JSON.stringify(response));
+    }
+    catch (error) {
+        const response = {
+            success: false,
+            error: `Failed to create spec: ${error.message}`,
+        };
+        console.log(JSON.stringify(response));
+        process.exit(1);
+    }
+});
+// Get subcommand
+specCommand
+    .command('get')
+    .description('Get a spec by ID')
+    .argument('<id>', 'Spec ID')
+    .action(async (id) => {
+    try {
+        const client = await getClient();
+        const result = await client.execute({
+            sql: 'SELECT * FROM specs WHERE id = ?',
+            args: [id],
+        });
+        closeClient();
+        if (result.rows.length === 0) {
+            const response = {
+                success: false,
+                error: `Spec ${id} not found`,
+            };
+            console.log(JSON.stringify(response));
+            process.exit(1);
+        }
+        const spec = parseSpecRow(result.rows[0]);
+        const response = {
+            success: true,
+            data: spec,
+        };
+        console.log(JSON.stringify(response));
+    }
+    catch (error) {
+        const response = {
+            success: false,
+            error: `Failed to get spec: ${error.message}`,
+        };
+        console.log(JSON.stringify(response));
+        process.exit(1);
+    }
+});
+// List subcommand
+specCommand
+    .command('list')
+    .description('List specs')
+    .option('--limit <n>', 'Limit results', '20')
+    .action(async (options) => {
+    try {
+        const client = await getClient();
+        const result = await client.execute({
+            sql: 'SELECT * FROM specs ORDER BY created_at DESC LIMIT ?',
+            args: [parseInt(options.limit, 10)],
+        });
+        closeClient();
+        const specs = result.rows.map((row) => parseSpecRow(row));
+        const response = {
+            success: true,
+            data: specs,
+        };
+        console.log(JSON.stringify(response));
+    }
+    catch (error) {
+        const response = {
+            success: false,
+            error: `Failed to list specs: ${error.message}`,
+        };
+        console.log(JSON.stringify(response));
+        process.exit(1);
+    }
+});
+// Update subcommand
+specCommand
+    .command('update')
+    .description('Update a spec')
+    .argument('<id>', 'Spec ID')
+    .option('--title <title>', 'New title')
+    .option('--content-stdin', 'Read new content from stdin')
+    .action(async (id, options) => {
+    try {
+        const client = await getClient();
+        const updates = [];
+        const args = [];
+        // Read stdin — parse as full spec markdown if it has a # title
+        let stdinParsed;
+        if (options.contentStdin) {
+            const raw = await readStdin();
+            const parsed = parseMarkdownSpec(raw);
+            if (parsed.title) {
+                stdinParsed = parsed;
+            }
+            else {
+                // Plain content text (no title header)
+                updates.push('content = ?');
+                args.push(raw.trim());
+            }
+        }
+        if (options.title) {
+            updates.push('title = ?');
+            args.push(options.title);
+        }
+        else if (stdinParsed?.title) {
+            updates.push('title = ?');
+            args.push(stdinParsed.title);
+        }
+        if (stdinParsed?.content) {
+            updates.push('content = ?');
+            args.push(stdinParsed.content);
+        }
+        if (updates.length === 0) {
+            closeClient();
+            const response = {
+                success: false,
+                error: 'No updates provided. Use --title or --content-stdin',
+            };
+            console.log(JSON.stringify(response));
+            process.exit(1);
+        }
+        updates.push("updated_at = datetime('now')");
+        args.push(id);
+        const result = await client.execute({
+            sql: `UPDATE specs SET ${updates.join(', ')} WHERE id = ?`,
+            args,
+        });
+        closeClient();
+        if (result.rowsAffected === 0) {
+            const response = {
+                success: false,
+                error: `Spec ${id} not found`,
+            };
+            console.log(JSON.stringify(response));
+            process.exit(1);
+        }
+        const response = {
+            success: true,
+            data: { id, status: 'updated' },
+        };
+        console.log(JSON.stringify(response));
+    }
+    catch (error) {
+        const response = {
+            success: false,
+            error: `Failed to update spec: ${error.message}`,
+        };
+        console.log(JSON.stringify(response));
+        process.exit(1);
+    }
+});
+// Delete subcommand
+specCommand
+    .command('delete')
+    .description('Delete a spec by ID')
+    .argument('<id>', 'Spec ID')
+    .action(async (id) => {
+    try {
+        const client = await getClient();
+        const existing = await client.execute({
+            sql: 'SELECT id FROM specs WHERE id = ?',
+            args: [id],
+        });
+        if (existing.rows.length === 0) {
+            closeClient();
+            const response = {
+                success: false,
+                error: `Spec ${id} not found`,
+            };
+            console.log(JSON.stringify(response));
+            process.exit(1);
+        }
+        await client.execute({
+            sql: 'DELETE FROM specs WHERE id = ?',
+            args: [id],
+        });
+        closeClient();
+        const response = {
+            success: true,
+            data: { id, status: 'deleted' },
+        };
+        console.log(JSON.stringify(response));
+    }
+    catch (error) {
+        const response = {
+            success: false,
+            error: `Failed to delete spec: ${error.message}`,
+        };
+        console.log(JSON.stringify(response));
+        process.exit(1);
+    }
+});

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const statusCommand: Command;

package/dist/commands/status.js

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { loadConfig, configExists } from '../utils/config.js';
+import { getClient, closeClient } from '../db/client.js';
+export const statusCommand = new Command('status')
+    .description('Check Turso connection status')
+    .action(async () => {
+    try {
+        // Check config
+        if (!configExists()) {
+            const response = {
+                success: false,
+                error: 'Not configured. Run: superintent init --url <url> --token <token>',
+            };
+            console.log(JSON.stringify(response));
+            process.exit(1);
+        }
+        const config = loadConfig();
+        // Test connection
+        const client = await getClient();
+        // Get counts
+        const ticketCount = await client.execute('SELECT COUNT(*) as count FROM tickets');
+        const knowledgeCount = await client.execute('SELECT COUNT(*) as count FROM knowledge');
+        closeClient();
+        const response = {
+            success: true,
+            data: {
+                connected: true,
+                url: config.url.replace(/\/\/.*:.*@/, '//***@'), // Hide token in URL if present
+                tickets: ticketCount.rows[0].count,
+                knowledge: knowledgeCount.rows[0].count,
+            },
+        };
+        console.log(JSON.stringify(response));
+    }
+    catch (error) {
+        const response = {
+            success: false,
+            error: `Connection failed: ${error.message}`,
+        };
+        console.log(JSON.stringify(response));
+        process.exit(1);
+    }
+});

package/dist/commands/ticket.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import type { Ticket, KnowledgeInput } from '../types.js';
+export declare function generateExtractProposals(ticket: Ticket, namespace: string): KnowledgeInput[];
+export declare const ticketCommand: Command;