codehere 0.1.1 → 0.2.2

package/dist/infrastructure/storage/sqlite-embedding-repository.js

@@ -53,43 +53,33 @@ function cosineSimilarityOptimized(queryEmbedding, queryNorm, docEmbedding) {
     return denominator === 0 ? 0 : dotProduct / denominator;
 }
 export class SQLiteEmbeddingRepository {
-    dbPath = null;
+    dbPath;
     db = null;
-    providedDbPath;
-    cwd;
     /**
      * @param dbPath - Optional database path. If not provided, uses per-repo path via getEmbeddingsDbPath()
      * @param cwd - Optional current working directory for codebase root detection (defaults to process.cwd())
      */
     constructor(dbPath, cwd) {
-        // Store parameters for lazy initialization to avoid sync filesystem operations in constructor
-        this.providedDbPath = dbPath;
-        this.cwd = cwd;
-    }
-    getDbPath() {
-        if (this.dbPath)
-            return this.dbPath;
-        if (this.providedDbPath) {
-            this.dbPath = this.providedDbPath;
+        if (dbPath) {
+            // Use provided path
+            this.dbPath = dbPath;
         }
         else {
-            // Lazy initialization - only compute path when actually needed
-            const pathInfo = getEmbeddingsDbPath(this.cwd);
+            // Use per-repo path based on codebase root
+            const pathInfo = getEmbeddingsDbPath(cwd);
             this.dbPath = pathInfo.dbPath;
         }
-        return this.dbPath;
     }
     async getDb() {
         if (this.db)
             return this.db;
-        const dbPath = this.getDbPath();
         const SQL = await initSqlJs();
-        const dbDir = dirname(dbPath);
+        const dbDir = dirname(this.dbPath);
         if (!existsSync(dbDir)) {
             mkdirSync(dbDir, { recursive: true });
         }
-        if (existsSync(dbPath)) {
-            const buffer = readFileSync(dbPath);
+        if (existsSync(this.dbPath)) {
+            const buffer = readFileSync(this.dbPath);
             this.db = new SQL.Database(buffer);
         }
         else {
@@ -170,8 +160,7 @@ export class SQLiteEmbeddingRepository {
      */
     async hasEmbeddings() {
         // Check if DB file exists
-        const dbPath = this.getDbPath();
-        if (!existsSync(dbPath)) {
+        if (!existsSync(this.dbPath)) {
             return false;
         }
         const db = await this.getDb();
@@ -191,8 +180,7 @@ export class SQLiteEmbeddingRepository {
             return;
         const data = this.db.export();
         const buffer = Buffer.from(data);
-        const dbPath = this.getDbPath();
-        writeFileSync(dbPath, buffer);
+        writeFileSync(this.dbPath, buffer);
     }
     /**
      * Search with pre-computed query embedding

package/dist/infrastructure/storage/sqlite-knowledge-graph-repository.js

@@ -7,13 +7,17 @@
  */
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import initSqlJs from 'sql.js';
 import { randomUUID } from 'crypto';
-import { getConfigManager } from '../config/config-manager.js';
 function getDbPath() {
-    const config = getConfigManager();
-    const dataDir = config.getDataDir();
-    return join(dataDir, 'knowledge-graph.sqlite');
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const agentDir = join(__dirname, '../../..');
+    if (existsSync(join(agentDir, 'package.json'))) {
+        return join(agentDir, 'data', 'knowledge-graph.sqlite');
+    }
+    return join(process.cwd(), 'agent', 'data', 'knowledge-graph.sqlite');
 }
 export class SQLiteKnowledgeGraphRepository {
     dbPath;

package/dist/infrastructure/storage/sqlite-knowledge-preservation-repository.js

@@ -7,13 +7,17 @@
  */
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import initSqlJs from 'sql.js';
 import { randomUUID } from 'crypto';
-import { getConfigManager } from '../config/config-manager.js';
 function getDbPath() {
-    const config = getConfigManager();
-    const dataDir = config.getDataDir();
-    return join(dataDir, 'knowledge_preservation.sqlite');
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const agentDir = join(__dirname, '../../..');
+    if (existsSync(join(agentDir, 'package.json'))) {
+        return join(agentDir, 'data', 'knowledge_preservation.sqlite');
+    }
+    return join(process.cwd(), 'agent', 'data', 'knowledge_preservation.sqlite');
 }
 export class SQLiteKnowledgePreservationRepository {
     dbPath;

package/dist/infrastructure/storage/sqlite-memory-repository.js

@@ -4,13 +4,17 @@
  */
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import initSqlJs from 'sql.js';
 import { randomUUID } from 'crypto';
-import { getConfigManager } from '../config/config-manager.js';
 function getDbPath() {
-    const config = getConfigManager();
-    const dataDir = config.getDataDir();
-    return join(dataDir, 'memory_stream.sqlite');
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const agentDir = join(__dirname, '../../..');
+    if (existsSync(join(agentDir, 'package.json'))) {
+        return join(agentDir, 'data', 'memory_stream.sqlite');
+    }
+    return join(process.cwd(), 'agent', 'data', 'memory_stream.sqlite');
 }
 export class SQLiteMemoryRepository {
     dbPath;

package/dist/infrastructure/storage/sqlite-pattern-repository.js

@@ -4,13 +4,17 @@
  */
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import initSqlJs from 'sql.js';
 import { randomUUID } from 'crypto';
-import { getConfigManager } from '../config/config-manager.js';
 function getDbPath() {
-    const config = getConfigManager();
-    const dataDir = config.getDataDir();
-    return join(dataDir, 'patterns.sqlite');
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const agentDir = join(__dirname, '../../..');
+    if (existsSync(join(agentDir, 'package.json'))) {
+        return join(agentDir, 'data', 'patterns.sqlite');
+    }
+    return join(process.cwd(), 'agent', 'data', 'patterns.sqlite');
 }
 export class SQLitePatternRepository {
     dbPath;

package/dist/infrastructure/ux/stream-markdown.js

@@ -0,0 +1,151 @@
+/**
+ * Incremental Markdown Renderer for Streaming Output
+ *
+ * Converts markdown to terminal formatting as tokens arrive.
+ * Handles: ## headers, **bold**, `code`, ```code blocks```, - bullets
+ */
+import chalk from 'chalk';
+export function createMarkdownStream() {
+    let buffer = '';
+    let inCodeBlock = false;
+    let codeBlockLang = '';
+    let lineStart = true; // Are we at the start of a new line?
+    function emit(text) {
+        process.stdout.write(text);
+    }
+    function processLine(line) {
+        // Code block fence
+        if (line.startsWith('```')) {
+            if (!inCodeBlock) {
+                inCodeBlock = true;
+                codeBlockLang = line.slice(3).trim();
+                return chalk.dim('  ┌' + (codeBlockLang ? ' ' + codeBlockLang : ''));
+            }
+            else {
+                inCodeBlock = false;
+                codeBlockLang = '';
+                return chalk.dim('  └');
+            }
+        }
+        // Inside code block — dim, indented
+        if (inCodeBlock) {
+            return chalk.cyan('  │ ') + line;
+        }
+        // Headers
+        if (line.startsWith('### ')) {
+            return chalk.bold(line.slice(4));
+        }
+        if (line.startsWith('## ')) {
+            return '\n' + chalk.bold(line.slice(3));
+        }
+        if (line.startsWith('# ')) {
+            return '\n' + chalk.bold(line.slice(2));
+        }
+        // Bullet points
+        if (line.startsWith('- ') || line.startsWith('* ')) {
+            return '  • ' + formatInline(line.slice(2));
+        }
+        // Numbered list
+        const numMatch = line.match(/^(\d+)\.\s/);
+        if (numMatch) {
+            return '  ' + numMatch[1] + '. ' + formatInline(line.slice(numMatch[0].length));
+        }
+        // Regular line
+        return formatInline(line);
+    }
+    function formatInline(text) {
+        // Bold: **text**
+        text = text.replace(/\*\*(.+?)\*\*/g, (_, content) => chalk.bold(content));
+        // Inline code: `text`
+        text = text.replace(/`([^`]+)`/g, (_, content) => chalk.cyan(content));
+        // Italic: *text* (but not inside **)
+        text = text.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, content) => chalk.dim(content));
+        return text;
+    }
+    return {
+        write(token) {
+            buffer += token;
+            // Process complete lines
+            while (buffer.includes('\n')) {
+                const newlineIdx = buffer.indexOf('\n');
+                const line = buffer.slice(0, newlineIdx);
+                buffer = buffer.slice(newlineIdx + 1);
+                const formatted = processLine(line);
+                emit(formatted + '\n');
+                lineStart = true;
+            }
+            // If there's remaining buffer without a newline, check for inline patterns
+            // Don't emit yet — wait for the line to complete
+            // Exception: if buffer is getting long (>200 chars without newline), flush it
+            if (buffer.length > 200) {
+                emit(formatInline(buffer));
+                buffer = '';
+                lineStart = false;
+            }
+        },
+        flush() {
+            if (buffer.length > 0) {
+                const formatted = processLine(buffer);
+                emit(formatted);
+                buffer = '';
+            }
+        },
+    };
+}
+/**
+ * Format a complete markdown string for terminal display (returns string, doesn't write to stdout).
+ */
+export function formatMarkdownForTerminal(text) {
+    const output = [];
+    let inCodeBlock = false;
+    let codeBlockLang = '';
+    function fmtInline(t) {
+        t = t.replace(/\*\*(.+?)\*\*/g, (_, c) => chalk.bold(c));
+        t = t.replace(/`([^`]+)`/g, (_, c) => chalk.cyan(c));
+        t = t.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, c) => chalk.dim(c));
+        return t;
+    }
+    for (const line of text.split('\n')) {
+        if (line.startsWith('```')) {
+            if (!inCodeBlock) {
+                inCodeBlock = true;
+                codeBlockLang = line.slice(3).trim();
+                output.push(chalk.dim('  ┌' + (codeBlockLang ? ' ' + codeBlockLang : '')));
+            }
+            else {
+                inCodeBlock = false;
+                codeBlockLang = '';
+                output.push(chalk.dim('  └'));
+            }
+            continue;
+        }
+        if (inCodeBlock) {
+            output.push(chalk.cyan('  │ ') + line);
+            continue;
+        }
+        if (line.startsWith('### ')) {
+            output.push(chalk.bold(line.slice(4)));
+            continue;
+        }
+        if (line.startsWith('## ')) {
+            output.push('\n' + chalk.bold(line.slice(3)));
+            continue;
+        }
+        if (line.startsWith('# ')) {
+            output.push('\n' + chalk.bold(line.slice(2)));
+            continue;
+        }
+        if (line.startsWith('- ') || line.startsWith('* ')) {
+            output.push('  • ' + fmtInline(line.slice(2)));
+            continue;
+        }
+        const numMatch = line.match(/^(\d+)\.\s/);
+        if (numMatch) {
+            output.push('  ' + numMatch[1] + '. ' + fmtInline(line.slice(numMatch[0].length)));
+            continue;
+        }
+        output.push(fmtInline(line));
+    }
+    return output.join('\n');
+}
+//# sourceMappingURL=stream-markdown.js.map

package/dist/infrastructure/ux/transparency.js

@@ -0,0 +1,71 @@
+/**
+ * Transparency Bar — show timing, tokens, model after every AI response
+ *
+ * v0.3.0: Makes every interaction feel measurable.
+ */
+import chalk from 'chalk';
+const dim = chalk.dim;
+/**
+ * Format a transparency line for display after an AI response.
+ * Example: "  2.4s · ~320 tokens · Claude Sonnet"
+ */
+export function formatTransparency(info) {
+    const parts = [];
+    // Elapsed time
+    const seconds = (info.elapsedMs / 1000).toFixed(1);
+    parts.push(`${seconds}s`);
+    // Token estimate
+    if (info.tokenEstimate && info.tokenEstimate > 0) {
+        parts.push(`~${info.tokenEstimate} tokens`);
+    }
+    // Model name (clean up long IDs)
+    if (info.model) {
+        parts.push(cleanModelName(info.model));
+    }
+    return dim('  ' + parts.join(' · '));
+}
+/**
+ * Format hook block stats for display.
+ * Example: "  blocked 5 times this session · 72 total"
+ */
+export function formatBlockStats(sessionBlocks, totalBlocks) {
+    const parts = [];
+    if (sessionBlocks > 0) {
+        parts.push(`blocked ${sessionBlocks} time${sessionBlocks !== 1 ? 's' : ''} this session`);
+    }
+    if (totalBlocks > 0) {
+        parts.push(`${totalBlocks} total`);
+    }
+    if (parts.length === 0)
+        return '';
+    return dim('  ' + parts.join(' · '));
+}
+/**
+ * Clean up model ID to a short display name.
+ * "claude-sonnet-4-20250514" → "Claude Sonnet"
+ * "gpt-4o" → "GPT-4o"
+ */
+function cleanModelName(model) {
+    const lower = model.toLowerCase();
+    if (lower.includes('claude') && lower.includes('opus'))
+        return 'Claude Opus';
+    if (lower.includes('claude') && lower.includes('sonnet'))
+        return 'Claude Sonnet';
+    if (lower.includes('claude') && lower.includes('haiku'))
+        return 'Claude Haiku';
+    if (lower.includes('gpt-4o'))
+        return 'GPT-4o';
+    if (lower.includes('gpt-4'))
+        return 'GPT-4';
+    if (lower.includes('gpt-3.5'))
+        return 'GPT-3.5';
+    // Fallback: return as-is but truncated
+    return model.length > 30 ? model.slice(0, 27) + '...' : model;
+}
+/**
+ * Estimate token count from text (rough: ~4 chars per token for English).
+ */
+export function estimateTokens(text) {
+    return Math.round(text.length / 4);
+}
+//# sourceMappingURL=transparency.js.map

package/dist/infrastructure/validation/agent-feedback.js

@@ -1,71 +1,19 @@
 /**
  * Agent Feedback
  * Records and manages feedback about agent operations
- * Now with file persistence for Trust Dashboard
  *
  * Phase 1: v0.5.0-alpha.0
  */
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { getConfigManager } from '../config/config-manager.js';
 /**
- * Agent Feedback Manager with file persistence
+ * Agent Feedback Manager
  */
 class AgentFeedbackManager {
     feedbackRecords = [];
     maxRecords = 1000;
-    feedbackDir;
-    feedbackFile;
-    initialized = false;
-    constructor() {
-        const config = getConfigManager();
-        const cacheDir = config.getCacheDir();
-        this.feedbackDir = cacheDir;
-        this.feedbackFile = join(this.feedbackDir, 'feedback.json');
-    }
-    /**
-     * Load existing feedback from disk
-     */
-    ensureLoaded() {
-        if (this.initialized)
-            return;
-        this.initialized = true;
-        try {
-            if (!existsSync(this.feedbackDir)) {
-                mkdirSync(this.feedbackDir, { recursive: true });
-            }
-            if (existsSync(this.feedbackFile)) {
-                const data = readFileSync(this.feedbackFile, 'utf-8');
-                const parsed = JSON.parse(data);
-                if (Array.isArray(parsed)) {
-                    this.feedbackRecords = parsed;
-                }
-            }
-        }
-        catch {
-            // Ignore load errors - start fresh
-            this.feedbackRecords = [];
-        }
-    }
-    /**
-     * Persist feedback to disk
-     */
-    persist() {
-        try {
-            if (!existsSync(this.feedbackDir)) {
-                mkdirSync(this.feedbackDir, { recursive: true });
-            }
-            writeFileSync(this.feedbackFile, JSON.stringify(this.feedbackRecords, null, 2));
-        }
-        catch {
-            // Ignore persist errors - trust data will be lost on restart
-        }
-    }
     /**
      * Record feedback for an agent operation
      */
     recordFeedback(feedback) {
-        this.ensureLoaded();
         const record = {
             ...feedback,
             timestamp: feedback.timestamp || Date.now(),
@@ -75,14 +23,13 @@ class AgentFeedbackManager {
         if (this.feedbackRecords.length > this.maxRecords) {
             this.feedbackRecords = this.feedbackRecords.slice(-this.maxRecords);
         }
-        // Persist to disk
-        this.persist();
+        // In alpha, feedback is stored in memory only
+        // Can be enhanced later to persist to disk
     }
     /**
      * Get feedback records for an agent
      */
     getFeedbackForAgent(agentName, limit = 10) {
-        this.ensureLoaded();
         return this.feedbackRecords
             .filter(r => r.agentName === agentName)
             .slice(-limit)
@@ -92,9 +39,17 @@ class AgentFeedbackManager {
      * Get all feedback records
      */
     getAllFeedback(limit = 100) {
-        this.ensureLoaded();
         return this.feedbackRecords.slice(-limit).reverse();
     }
 }
 export const agentFeedbackManager = new AgentFeedbackManager();
+/**
+ * AgentFeedback class (kept for backward compatibility)
+ */
+export class AgentFeedback {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+}
 //# sourceMappingURL=agent-feedback.js.map

package/dist/monitoring.js

@@ -126,9 +126,10 @@ function checkApi() {
     if (circuitState === 'HALF_OPEN') {
         return { status: 'error', message: 'API circuit breaker is HALF_OPEN - recovering' };
     }
-    // Check if API key is configured
-    if (!process.env.COHERE_API_KEY) {
-        return { status: 'error', message: 'COHERE_API_KEY not configured' };
+    // Check if any API key is configured
+    const hasKey = !!(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.COHERE_API_KEY || process.env.OPENROUTER_API_KEY);
+    if (!hasKey) {
+        return { status: 'error', message: 'No API key configured' };
     }
     return { status: 'ok', message: 'API accessible' };
 }
@@ -229,21 +230,11 @@ export function getMetrics() {
  * Format health status for display
  */
 export function formatHealthStatus(health) {
-    const statusIcon = {
-        healthy: '✓',
-        degraded: '⚠',
-        unhealthy: '✗',
-    }[health.status];
-    const statusColor = {
-        healthy: 'green',
-        degraded: 'yellow',
-        unhealthy: 'red',
-    }[health.status];
-    let output = `${statusIcon} System Status: ${health.status.toUpperCase()}\n\n`;
-    output += 'Component Checks:\n';
+    const statusIcon = health.status === 'healthy' ? '✓' : health.status === 'degraded' ? '!' : '✗';
+    let output = `  ${statusIcon} ${health.status.toUpperCase()}\n\n`;
     for (const [component, check] of Object.entries(health.checks)) {
-        const icon = check.status === 'ok' ? '✓' : check.status === 'warning' ? '⚠' : '✗';
-        output += `  ${icon} ${component}: ${check.message}\n`;
+        const icon = check.status === 'ok' ? '✓' : check.status === 'warning' ? '!' : '✗';
+        output += `  ${icon} ${component.padEnd(12)} ${check.message}\n`;
     }
     return output;
 }