codehere 0.8.0 → 1.0.2

package/dist/infrastructure/storage/project-thread-title-backfill.js

@@ -1,214 +0,0 @@
-/**
- * Title backfill — v0.6.0 follow-up to M9.
- *
- * The M9 hidden Title agent (generate-thread-title.ts) only fires on the FIRST
- * task entry written to a project's thread.jsonl. Projects seeded by the v0.6
- * migration (project-thread-migration.ts) bypass that path — they get a
- * project-meta header but no Title agent invocation. Result: 5/7 projects on
- * a typical dogfood machine show "(untitled)" in the /threads switcher even
- * though their first task carries enough signal to title from.
- *
- * This backfill closes that gap. For every project with title=null and at
- * least one task entry, it fires the Title agent on the first task's prompt +
- * cwd and appends a `{_meta: 'project-update', title: ...}` line. Reader
- * (project-thread-reader.ts) takes the latest project-update title.
- *
- * Idempotent: skips projects that already have a title (or that have NO tasks
- * to title from). Safe to run on every daemon boot. Best-effort: any LLM
- * failure (provider missing, timeout, rate limit) skips that project silently.
- *
- * Cost budget: ~1 LLM call per untitled project on first run after this lands.
- * Subsequent boots are no-ops since titles persist.
- */
-import { existsSync, readdirSync, readFileSync, appendFileSync, statSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import { generateThreadTitle } from '../../application/use-cases/generate-thread-title.js';
-const DEFAULT_PROJECTS_DIR = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'projects');
-function scanThread(slug, file) {
-    let title = null;
-    let firstPrompt = null;
-    let firstCwd = null;
-    let firstStartedAt = Number.MAX_SAFE_INTEGER;
-    let content;
-    try {
-        content = readFileSync(file, 'utf-8');
-    }
-    catch {
-        return { slug, title, firstPrompt, firstCwd };
-    }
-    for (const line of content.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        let rec;
-        try {
-            rec = JSON.parse(trimmed);
-        }
-        catch {
-            continue;
-        }
-        if (rec._meta === 'project') {
-            if (typeof rec.title === 'string')
-                title = rec.title;
-        }
-        else if (rec._meta === 'project-update') {
-            if (typeof rec.title === 'string')
-                title = rec.title;
-        }
-        else if (rec.type === 'task') {
-            const startedAt = typeof rec.startedAt === 'number' ? rec.startedAt : Number.MAX_SAFE_INTEGER;
-            if (startedAt < firstStartedAt) {
-                firstStartedAt = startedAt;
-                if (typeof rec.prompt === 'string')
-                    firstPrompt = rec.prompt;
-                if (typeof rec.cwd === 'string')
-                    firstCwd = rec.cwd;
-            }
-        }
-    }
-    return { slug, title, firstPrompt, firstCwd };
-}
-/**
- * Backfill missing titles. Returns counts; never throws (best-effort per project).
- *
- * Disable via CODEHERE_DISABLE_TITLE_AGENT=1 (same env var that gates M9 itself —
- * keeps the toggle surface minimal).
- */
-export async function backfillThreadTitles(options) {
-    const start = Date.now();
-    const result = {
-        scanned: 0,
-        alreadyTitled: 0,
-        noTasks: 0,
-        titlesGenerated: 0,
-        titleAgentFailed: 0,
-        durationMs: 0,
-    };
-    if (process.env.CODEHERE_DISABLE_TITLE_AGENT === '1') {
-        result.durationMs = Date.now() - start;
-        return result;
-    }
-    const root = options?.projectsDir ?? DEFAULT_PROJECTS_DIR;
-    if (!existsSync(root)) {
-        result.durationMs = Date.now() - start;
-        return result;
-    }
-    let stat;
-    try {
-        stat = statSync(root);
-    }
-    catch {
-        result.durationMs = Date.now() - start;
-        return result;
-    }
-    if (!stat.isDirectory()) {
-        result.durationMs = Date.now() - start;
-        return result;
-    }
-    let slugs;
-    try {
-        slugs = readdirSync(root);
-    }
-    catch {
-        result.durationMs = Date.now() - start;
-        return result;
-    }
-    const cap = options?.maxProjects ?? Number.MAX_SAFE_INTEGER;
-    let backfilledCount = 0;
-    for (const slug of slugs) {
-        if (backfilledCount >= cap)
-            break;
-        const projectDir = join(root, slug);
-        let s;
-        try {
-            s = statSync(projectDir);
-        }
-        catch {
-            continue;
-        }
-        if (!s.isDirectory())
-            continue;
-        const file = join(projectDir, 'thread.jsonl');
-        if (!existsSync(file))
-            continue;
-        result.scanned++;
-        const scanned = scanThread(slug, file);
-        if (scanned.title) {
-            result.alreadyTitled++;
-            continue;
-        }
-        if (!scanned.firstPrompt || !scanned.firstCwd) {
-            // Nothing to title from — skip. (Migration-seeded headers without task
-            // entries fall here, as do projects where the first task lost its prompt
-            // somehow.)
-            result.noTasks++;
-            continue;
-        }
-        let title;
-        try {
-            title = await generateThreadTitle(scanned.firstPrompt, scanned.firstCwd);
-        }
-        catch {
-            // Title agent should never throw (it returns null on failure), but guard
-            // anyway so one bad call doesn't sink the whole backfill.
-            title = null;
-        }
-        if (!title) {
-            result.titleAgentFailed++;
-            continue;
-        }
-        // Race guard: backfill scanned BEFORE the LLM call, but the LLM blocks
-        // for seconds. A user rename in that window leaves a userOverride:true
-        // marker the pre-scan never saw. Re-read the same file just before the
-        // write and skip if the user got there first. (Inlined rather than calling
-        // hasManualOverride() because that helper hardcodes the production
-        // projects dir; backfill supports a custom projectsDir for tests.)
-        let userBeatUs = false;
-        try {
-            const recheck = readFileSync(file, 'utf-8');
-            for (const line of recheck.split('\n')) {
-                const t = line.trim();
-                if (!t)
-                    continue;
-                try {
-                    const rec = JSON.parse(t);
-                    if (rec._meta === 'project-update' && rec.userOverride === true) {
-                        userBeatUs = true;
-                        break;
-                    }
-                }
-                catch {
-                    /* skip malformed */
-                }
-            }
-        }
-        catch {
-            /* if we can't read, fall through and let the append fail */
-        }
-        if (userBeatUs) {
-            result.alreadyTitled++;
-            continue;
-        }
-        try {
-            const updateLine = JSON.stringify({
-                _meta: 'project-update',
-                slug,
-                title,
-                cwd: scanned.firstCwd,
-                backfilledAt: Date.now(),
-                updatedAt: Date.now(),
-            });
-            appendFileSync(file, updateLine + '\n', 'utf-8');
-            result.titlesGenerated++;
-            backfilledCount++;
-        }
-        catch {
-            // Append failure is logged via counter but doesn't sink the loop.
-            result.titleAgentFailed++;
-        }
-    }
-    result.durationMs = Date.now() - start;
-    return result;
-}
-//# sourceMappingURL=project-thread-title-backfill.js.map

package/dist/infrastructure/storage/task-repository.js

@@ -1,206 +0,0 @@
-/**
- * Infrastructure: Task Repository
- * Task storage and retrieval using JSONL format
- *
- * Phase 1: v0.5.0-alpha
- * See: .internal/ARCHITECTURE.md (internal docs)
- */
-import { appendFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { findCodebaseRoot } from '../../domain/services/codebase-detector.js';
-/**
- * JSONL-based task repository
- * Stores tasks in .codehere/tasks.jsonl at codebase root
- */
-export class JsonlTaskRepository {
-    tasksPath;
-    tasksCache = new Map();
-    cacheLoaded = false;
-    constructor(customPath) {
-        if (customPath) {
-            this.tasksPath = customPath;
-        }
-        else {
-            // Use environment variable or detect from codebase root
-            const envPath = process.env.CODEHERE_TASKS_PATH;
-            if (envPath) {
-                this.tasksPath = envPath;
-            }
-            else {
-                // Detect codebase root and use .codehere/tasks.jsonl
-                const codebaseInfo = findCodebaseRoot(process.cwd());
-                const codebaseRoot = codebaseInfo?.rootPath || process.cwd();
-                const codehereDir = join(codebaseRoot, '.codehere');
-                // Ensure .codehere directory exists
-                if (!existsSync(codehereDir)) {
-                    mkdirSync(codehereDir, { recursive: true });
-                }
-                this.tasksPath = join(codehereDir, 'tasks.jsonl');
-            }
-        }
-        // Ensure directory exists
-        const tasksDir = dirname(this.tasksPath);
-        if (!existsSync(tasksDir)) {
-            mkdirSync(tasksDir, { recursive: true });
-        }
-    }
-    /**
-     * Load tasks from JSONL file into cache
-     * For duplicate IDs, keeps the latest version (by updatedAt)
-     */
-    loadTasks() {
-        if (this.cacheLoaded) {
-            return;
-        }
-        if (!existsSync(this.tasksPath)) {
-            this.cacheLoaded = true;
-            return;
-        }
-        try {
-            const content = readFileSync(this.tasksPath, 'utf-8');
-            const lines = content
-                .trim()
-                .split('\n')
-                .filter((line) => line.trim());
-            // Load all tasks, then keep only the latest version of each ID
-            const allTasks = [];
-            for (const line of lines) {
-                try {
-                    const task = JSON.parse(line);
-                    allTasks.push(task);
-                }
-                catch {
-                    // Skip invalid lines
-                }
-            }
-            // Group by ID and keep latest version
-            const taskMap = new Map();
-            for (const task of allTasks) {
-                const existing = taskMap.get(task.id);
-                if (!existing || task.updatedAt > existing.updatedAt) {
-                    taskMap.set(task.id, task);
-                }
-            }
-            this.tasksCache = taskMap;
-            this.cacheLoaded = true;
-        }
-        catch (error) {
-            // Silent failure - don't break user workflow
-            console.error('[TaskRepository] Failed to load tasks:', error);
-            this.cacheLoaded = true;
-        }
-    }
-    /**
-     * Create a new task
-     */
-    async create(task) {
-        // Ensure cache is loaded
-        this.loadTasks();
-        // Set timestamps if not provided
-        const now = Date.now();
-        const taskToCreate = {
-            ...task,
-            createdAt: task.createdAt || now,
-            updatedAt: task.updatedAt || now,
-        };
-        // Add to cache
-        this.tasksCache.set(taskToCreate.id, taskToCreate);
-        // Append to JSONL file (append-only, immutable history)
-        try {
-            appendFileSync(this.tasksPath, JSON.stringify(taskToCreate) + '\n', 'utf-8');
-        }
-        catch (error) {
-            // Silent failure - remove from cache if write failed
-            this.tasksCache.delete(taskToCreate.id);
-            console.error('[TaskRepository] Failed to create task:', error);
-            throw error;
-        }
-    }
-    /**
-     * Get task by ID (returns latest version if multiple exist)
-     */
-    async getById(id) {
-        this.loadTasks();
-        // Load all tasks and find the latest version of this ID
-        const allTasks = Array.from(this.tasksCache.values());
-        const tasksWithId = allTasks.filter((task) => task.id === id);
-        if (tasksWithId.length === 0) {
-            return null;
-        }
-        // Return the task with the latest updatedAt timestamp
-        return tasksWithId.reduce((latest, current) => {
-            return current.updatedAt > latest.updatedAt ? current : latest;
-        });
-    }
-    /**
-     * Get tasks by status
-     */
-    async getByStatus(status) {
-        this.loadTasks();
-        const tasks = Array.from(this.tasksCache.values());
-        return tasks.filter((task) => task.status === status);
-    }
-    /**
-     * Get tasks by mode
-     */
-    async getByMode(mode) {
-        this.loadTasks();
-        const tasks = Array.from(this.tasksCache.values());
-        return tasks.filter((task) => task.mode === mode);
-    }
-    /**
-     * Get recent tasks (latest updated first)
-     */
-    async getRecent(limit = 10) {
-        this.loadTasks();
-        const tasks = Array.from(this.tasksCache.values());
-        return tasks.sort((a, b) => b.updatedAt - a.updatedAt).slice(0, limit);
-    }
-    /**
-     * Get all tasks (latest version of each)
-     */
-    async getAll() {
-        this.loadTasks();
-        return Array.from(this.tasksCache.values());
-    }
-    /**
-     * Update existing task
-     * Creates a new entry in JSONL (append-only)
-     */
-    async update(task) {
-        // Ensure cache is loaded
-        this.loadTasks();
-        // Update timestamp
-        const updatedTask = {
-            ...task,
-            updatedAt: Date.now(),
-        };
-        // Update cache
-        this.tasksCache.set(updatedTask.id, updatedTask);
-        // Append updated version to JSONL (append-only, immutable history)
-        try {
-            appendFileSync(this.tasksPath, JSON.stringify(updatedTask) + '\n', 'utf-8');
-        }
-        catch (error) {
-            // Revert cache if write failed
-            const original = await this.getById(task.id);
-            if (original) {
-                this.tasksCache.set(task.id, original);
-            }
-            console.error('[TaskRepository] Failed to update task:', error);
-            throw error;
-        }
-    }
-}
-// Singleton instance (lazy initialization with codebase detection)
-let taskRepositoryInstance = null;
-/**
- * Get task repository instance
- */
-export function getTaskRepository(customPath) {
-    if (!taskRepositoryInstance || customPath) {
-        taskRepositoryInstance = new JsonlTaskRepository(customPath);
-    }
-    return taskRepositoryInstance;
-}
-//# sourceMappingURL=task-repository.js.map

package/dist/monitoring.js

@@ -1,212 +0,0 @@
-/**
- * Enterprise Monitoring & Health Check System
- * Ensures 24/7 operation visibility
- */
-import { existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { cohereCircuitBreaker } from './error-handler.js';
-class MetricsCollector {
-    operations = {
-        total: 0,
-        successful: 0,
-        failed: 0,
-        retries: 0,
-    };
-    performance = {
-        responseTimes: [],
-        retryTimes: [],
-        apiCalls: 0,
-        cacheHits: 0,
-    };
-    errors = {
-        byType: {},
-        recent: [],
-    };
-    recordOperation(success, responseTime, retries) {
-        this.operations.total++;
-        if (success) {
-            this.operations.successful++;
-        }
-        else {
-            this.operations.failed++;
-        }
-        if (retries) {
-            this.operations.retries += retries;
-        }
-        if (responseTime) {
-            this.performance.responseTimes.push(responseTime);
-            // Keep only last 1000 measurements
-            if (this.performance.responseTimes.length > 1000) {
-                this.performance.responseTimes.shift();
-            }
-        }
-    }
-    recordApiCall() {
-        this.performance.apiCalls++;
-    }
-    recordCacheHit() {
-        this.performance.cacheHits++;
-    }
-    recordError(type, message) {
-        this.errors.byType[type] = (this.errors.byType[type] || 0) + 1;
-        this.errors.recent.push({
-            timestamp: new Date().toISOString(),
-            type,
-            message,
-        });
-        // Keep only last 100 errors
-        if (this.errors.recent.length > 100) {
-            this.errors.recent.shift();
-        }
-    }
-    getMetrics() {
-        const avgResponseTime = this.performance.responseTimes.length > 0
-            ? this.performance.responseTimes.reduce((a, b) => a + b, 0) / this.performance.responseTimes.length
-            : 0;
-        const avgRetryTime = this.performance.retryTimes.length > 0
-            ? this.performance.retryTimes.reduce((a, b) => a + b, 0) / this.performance.retryTimes.length
-            : 0;
-        return {
-            operations: { ...this.operations },
-            performance: {
-                avgResponseTime,
-                avgRetryTime,
-                apiCalls: this.performance.apiCalls,
-                cacheHits: this.performance.cacheHits,
-            },
-            errors: {
-                byType: { ...this.errors.byType },
-                recent: [...this.errors.recent],
-            },
-        };
-    }
-    reset() {
-        this.operations = { total: 0, successful: 0, failed: 0, retries: 0 };
-        this.performance = { responseTimes: [], retryTimes: [], apiCalls: 0, cacheHits: 0 };
-        this.errors = { byType: {}, recent: [] };
-    }
-}
-export const metricsCollector = new MetricsCollector();
-/**
- * Check API health
- */
-function checkApi() {
-    const circuitState = cohereCircuitBreaker.getState();
-    if (circuitState === 'OPEN') {
-        return { status: 'circuit_open', message: 'API circuit breaker is OPEN - too many failures' };
-    }
-    if (circuitState === 'HALF_OPEN') {
-        return { status: 'error', message: 'API circuit breaker is HALF_OPEN - recovering' };
-    }
-    // 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' };
-}
-/**
- * Check filesystem health
- */
-function checkFilesystem() {
-    try {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = dirname(__filename);
-        const agentDir = join(__dirname, '..');
-        const dataDir = join(agentDir, 'data');
-        // Check if data directory exists or can be created
-        if (!existsSync(dataDir)) {
-            // Try to create it
-            try {
-                mkdirSync(dataDir, { recursive: true });
-            }
-            catch {
-                return { status: 'error', message: 'Cannot create data directory' };
-            }
-        }
-        return { status: 'ok', message: 'Filesystem accessible' };
-    }
-    catch (error) {
-        return {
-            status: 'error',
-            message: `Filesystem check failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-/**
- * Check memory usage
- */
-function checkMemory() {
-    try {
-        const usage = process.memoryUsage();
-        const heapUsedMB = usage.heapUsed / 1024 / 1024;
-        const heapTotalMB = usage.heapTotal / 1024 / 1024;
-        const usagePercent = (heapUsedMB / heapTotalMB) * 100;
-        if (usagePercent > 90) {
-            return {
-                status: 'warning',
-                message: `High memory usage: ${usagePercent.toFixed(1)}%`,
-                usage: usagePercent,
-            };
-        }
-        return {
-            status: 'ok',
-            message: `Memory usage: ${usagePercent.toFixed(1)}%`,
-            usage: usagePercent,
-        };
-    }
-    catch {
-        return {
-            status: 'ok',
-            message: 'Memory check unavailable',
-        };
-    }
-}
-/**
- * Perform health check
- */
-export function performHealthCheck() {
-    const apiCheck = checkApi();
-    const fsCheck = checkFilesystem();
-    const memCheck = checkMemory();
-    const checks = {
-        api: apiCheck,
-        filesystem: fsCheck,
-        memory: memCheck,
-    };
-    let status = 'healthy';
-    if (apiCheck.status === 'circuit_open' || fsCheck.status === 'error') {
-        status = 'unhealthy';
-    }
-    else if (apiCheck.status === 'error' || memCheck.status === 'warning') {
-        status = 'degraded';
-    }
-    return {
-        status,
-        timestamp: new Date().toISOString(),
-        checks,
-    };
-}
-/**
- * Get current metrics
- */
-export function getMetrics() {
-    return metricsCollector.getMetrics();
-}
-/**
- * Format health status for display
- */
-export function formatHealthStatus(health) {
-    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.padEnd(12)} ${check.message}\n`;
-    }
-    return output;
-}
-//# sourceMappingURL=monitoring.js.map