codehere 0.5.0-alpha.3 → 0.5.0-alpha.5

package/dist/infrastructure/storage/project-thread-reader.js

@@ -0,0 +1,140 @@
+/**
+ * Project thread reader — v0.6.0 M1 (UI-prep slice).
+ *
+ * Reads ~/.codehere/projects/<slug>/thread.jsonl files and reconstructs
+ * the per-project thread state for API consumers (the new UI rendering
+ * the persistent project thread shape).
+ *
+ * Reconstruction rules:
+ *   - One file per project, identified by slug (sha1(cwd)[:12])
+ *   - First line is `{_meta: 'project', ...}` — project header
+ *   - Subsequent lines are `{_meta: 'project-update', ...}` (latest wins per
+ *     field — Title agent uses this to set the title) OR `{type: 'task', ...}`
+ *     (per-session entries; later entries with same sessionId override
+ *     earlier — covers spawn entry → completion entry update)
+ *
+ * NOT in scope of this module:
+ *   - Writing (handled by project-thread-mirror + project-thread-migration)
+ *   - UI rendering (the new thread view will consume this reader's output)
+ *   - Live SSE updates (polling is fine for the alpha; SSE in v0.6.x patch)
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const DEFAULT_PROJECTS_DIR = join(homedir(), '.codehere', 'projects');
+/** List all known projects with summary stats. Cheap; no full task content. */
+export function listProjects(options) {
+    const root = options?.projectsDir ?? DEFAULT_PROJECTS_DIR;
+    if (!existsSync(root))
+        return [];
+    let stat;
+    try {
+        stat = statSync(root);
+    }
+    catch {
+        return [];
+    }
+    if (!stat.isDirectory())
+        return [];
+    const slugs = readdirSync(root).filter((entry) => {
+        const p = join(root, entry);
+        try {
+            return statSync(p).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    const summaries = [];
+    for (const slug of slugs) {
+        const thread = readProjectThread(slug, { projectsDir: root, taskLimit: 0 });
+        if (thread) {
+            summaries.push({
+                slug: thread.slug,
+                cwd: thread.cwd,
+                title: thread.title,
+                taskCount: thread.taskCount,
+                lastActivityAt: thread.lastActivityAt,
+            });
+        }
+    }
+    // Sort by recency (most recent first)
+    summaries.sort((a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0));
+    return summaries;
+}
+/** Read a single project thread by slug. Returns null if not found. */
+export function readProjectThread(slug, options) {
+    const root = options?.projectsDir ?? DEFAULT_PROJECTS_DIR;
+    const file = join(root, slug, 'thread.jsonl');
+    if (!existsSync(file))
+        return null;
+    let content;
+    try {
+        content = readFileSync(file, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    let cwd = null;
+    let title = null;
+    const tasksById = new Map();
+    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.cwd === 'string')
+                cwd = rec.cwd;
+            if (typeof rec.title === 'string')
+                title = rec.title;
+        }
+        else if (rec._meta === 'project-update') {
+            if (typeof rec.title === 'string')
+                title = rec.title;
+            if (typeof rec.cwd === 'string' && cwd === null)
+                cwd = rec.cwd;
+        }
+        else if (rec.type === 'task' && typeof rec.sessionId === 'string') {
+            const existing = tasksById.get(rec.sessionId) ?? {
+                sessionId: rec.sessionId,
+                agent: '',
+                prompt: '',
+                cwd: '',
+                startedAt: 0,
+            };
+            // Merge fields — later entries override earlier (covers
+            // spawn → completion update pattern from forward-mirror)
+            for (const k of ['agent', 'prompt', 'cwd', 'startedAt', 'status', 'durationMs', 'completedAt', 'steps', 'artifacts']) {
+                if (rec[k] !== undefined) {
+                    existing[k] = rec[k];
+                }
+            }
+            tasksById.set(rec.sessionId, existing);
+        }
+    }
+    const tasks = [...tasksById.values()].sort((a, b) => a.startedAt - b.startedAt);
+    const lastActivityAt = tasks.reduce((acc, t) => {
+        const ts = t.completedAt ?? t.startedAt;
+        if (ts && (acc === null || ts > acc))
+            return ts;
+        return acc;
+    }, null);
+    const limit = options?.taskLimit;
+    const cappedTasks = limit === undefined ? tasks : limit === 0 ? [] : tasks.slice(-limit);
+    return {
+        slug,
+        cwd,
+        title,
+        taskCount: tasks.length,
+        tasks: cappedTasks,
+        lastActivityAt,
+    };
+}
+//# sourceMappingURL=project-thread-reader.js.map

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

@@ -0,0 +1,182 @@
+/**
+ * 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(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 = null;
+        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;
+        }
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehere",
-  "version": "0.5.0-alpha.3",
+  "version": "0.5.0-alpha.5",
   "description": "A PM for your AI coding agents. Delegate, orchestrate, and audit Claude Code, Codex, Aider, OpenCode, Gemini, and any user-configured CLI agent from one local web UI — every AI action traced, every file scored, every spawn warmed with project memory.",
   "main": "dist/index.js",
   "type": "module",
@@ -65,7 +65,9 @@
     "cli-table3": "^0.6.5",
     "commander": "^11.1.0",
     "dotenv": "^16.3.1",
-    "ora": "^7.0.1"
+    "gray-matter": "^4.0.3",
+    "ora": "^7.0.1",
+    "yaml": "^2.8.4"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",