codehere 0.5.0-alpha.4 → 0.5.0-alpha.6

package/dist/infrastructure/storage/cross-tool-agents.js

@@ -0,0 +1,251 @@
+/**
+ * Cross-tool agent definition reader — v0.6.0 M8.
+ *
+ * Reads agent definitions written for OTHER tools (OpenCode, Claude Code) and
+ * normalizes them into codehere's internal shape so they appear in the agents
+ * pane alongside codehere's built-in adapters.
+ *
+ * Built from Spike-4 prototype (agent/spike/v0.6.0-cross-tool-parser.mjs);
+ * production version uses the `yaml` lib for proper 2-level nesting + multi-
+ * line scalars + quoted-string handling, recurses subdirectories per the
+ * AGENTS.md hierarchical convention, skips files without frontmatter, and
+ * surfaces unknown frontmatter keys as warnings (not silent drops).
+ *
+ * Sources read in precedence order (later overrides earlier on name conflict):
+ *   1. ~/.claude/agents/                  (global Claude Code subagents)
+ *   2. ~/.opencode/agents/                (global OpenCode agents)
+ *   3. ~/.codehere/agents/                (global codehere agents)
+ *   4. <cwd>/.claude/agents/              (project Claude Code)
+ *   5. <cwd>/.opencode/agents/            (project OpenCode)
+ *   6. <cwd>/.codehere/agents/            (project codehere)
+ *
+ * Format normalization handles divergences:
+ *   - Claude `name` field vs OpenCode (filename = name)
+ *   - Claude `tools: "A, B, C"` (string) vs OpenCode `tools: {a: true, b: false}` (object)
+ *   - Claude no `mode` (subagent implicit) vs OpenCode `mode: primary|subagent|all`
+ *   - OpenCode `permission` block vs Claude (no permission block)
+ *
+ * NOT in scope of this module:
+ *   - Permission ENFORCEMENT (this just READS them for display + future M5)
+ *   - Template variable substitution ({{PROJECT_NAME}} stays as raw text)
+ *   - Authoring (`codehere agent create` is C6, deferred)
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import YAML from 'yaml';
+/**
+ * Pre-process Claude Code-style frontmatter that contains unquoted colons in
+ * description/prompt values (e.g. "description: ... Examples:\n<example>\nContext: ...").
+ * Strict YAML parsers reject these; Claude Code itself uses a more permissive
+ * reader. We force-quote affected values before parsing.
+ *
+ * Heuristic: any top-level `description:` or `prompt:` line whose value
+ * contains a `: ` (colon-space) AND isn't already quoted/block-scalar gets
+ * single-quoted with internal single quotes doubled (YAML escape).
+ */
+function preprocessFrontmatter(fmText) {
+    return fmText
+        .split('\n')
+        .map((line) => {
+        const m = line.match(/^(description|prompt):\s*(.+)$/);
+        if (!m)
+            return line;
+        const [, key, value] = m;
+        const trimmed = value.trim();
+        if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+            (trimmed.startsWith("'") && trimmed.endsWith("'")) ||
+            trimmed.startsWith('|') ||
+            trimmed.startsWith('>')) {
+            return line; // already a safe scalar form
+        }
+        if (!/:\s/.test(trimmed))
+            return line; // no problematic embedded colons
+        const escaped = trimmed.replace(/'/g, "''");
+        return `${key}: '${escaped}'`;
+    })
+        .join('\n');
+}
+/** Recursively walk a dir, return all .md files (sorted for determinism). */
+function listMdFilesRecursive(dir) {
+    if (!existsSync(dir))
+        return [];
+    let stat;
+    try {
+        stat = statSync(dir);
+    }
+    catch {
+        return [];
+    }
+    if (!stat.isDirectory())
+        return [];
+    const out = [];
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries.sort()) {
+        if (entry.startsWith('.'))
+            continue;
+        const p = join(dir, entry);
+        let s;
+        try {
+            s = statSync(p);
+        }
+        catch {
+            continue;
+        }
+        if (s.isDirectory()) {
+            out.push(...listMdFilesRecursive(p));
+        }
+        else if (s.isFile() && entry.endsWith('.md') && entry !== 'README.md') {
+            out.push(p);
+        }
+    }
+    return out;
+}
+/** Parse a single agent file. Returns null if no frontmatter or parse fails. */
+export function parseAgentFile(filePath, defaultFormat = 'unknown') {
+    let text;
+    try {
+        text = readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    if (!text.startsWith('---'))
+        return null; // no frontmatter, not an agent file
+    const closeIdx = text.indexOf('\n---', 4);
+    if (closeIdx === -1)
+        return null;
+    const fmText = text.slice(4, closeIdx).trim();
+    const body = text.slice(closeIdx + 4).trim();
+    let fm;
+    try {
+        fm = YAML.parse(preprocessFrontmatter(fmText));
+        if (!fm || typeof fm !== 'object')
+            return null;
+    }
+    catch {
+        return null;
+    }
+    // Source format inference: presence of mode/permission/object-tools = OpenCode;
+    // presence of name + string-tools = Claude. Fall back to default by location.
+    const hasObjectTools = typeof fm.tools === 'object' && fm.tools !== null && !Array.isArray(fm.tools);
+    const sourceFormat = fm.mode || fm.permission || hasObjectTools
+        ? 'opencode'
+        : fm.name || typeof fm.tools === 'string'
+            ? 'claude'
+            : defaultFormat;
+    // Tools normalization
+    let tools = null;
+    if (typeof fm.tools === 'string') {
+        tools = fm.tools.split(',').map((t) => t.trim().toLowerCase()).filter(Boolean);
+    }
+    else if (hasObjectTools) {
+        tools = [];
+        for (const [k, v] of Object.entries(fm.tools)) {
+            if (v === true)
+                tools.push(k.toLowerCase());
+        }
+    }
+    // Filename without .md = fallback name
+    const filenameName = filePath.split('/').pop()?.replace(/\.md$/, '') ?? 'unnamed';
+    // Mode normalization
+    const modeRaw = typeof fm.mode === 'string' ? fm.mode : null;
+    const mode = modeRaw === 'primary' || modeRaw === 'subagent' || modeRaw === 'all'
+        ? modeRaw
+        : sourceFormat === 'claude'
+            ? 'subagent'
+            : 'all';
+    // Track unknown frontmatter keys (everything outside our normalized set)
+    const knownKeys = new Set(['name', 'description', 'mode', 'model', 'temperature', 'tools', 'permission', 'color', 'hidden', 'top_p', 'steps', 'prompt', 'disable']);
+    const unknownKeys = Object.keys(fm).filter((k) => !knownKeys.has(k));
+    return {
+        name: typeof fm.name === 'string' ? fm.name : filenameName,
+        description: typeof fm.description === 'string' ? fm.description : '(no description)',
+        sourceFormat,
+        sourcePath: filePath,
+        mode,
+        model: typeof fm.model === 'string' ? fm.model : null,
+        temperature: typeof fm.temperature === 'number' ? fm.temperature : null,
+        tools,
+        permission: typeof fm.permission === 'object' && fm.permission !== null ? fm.permission : null,
+        color: typeof fm.color === 'string' ? fm.color : null,
+        hidden: fm.hidden === true,
+        body,
+        unknownKeys,
+    };
+}
+/** All locations to scan, in precedence order (later overrides earlier on name conflict).
+ *  Dedupes the dir list — when cwd == homeDir, project + global paths collapse and we
+ *  shouldn't double-count files. Test isolation also relies on this (homeDir override
+ *  to a project root). */
+function agentDirsToScan(cwd, homeOverride) {
+    const home = homeOverride ?? homedir();
+    const dirs = [
+        { dir: join(home, '.claude/agents'), defaultFormat: 'claude' },
+        { dir: join(home, '.opencode/agents'), defaultFormat: 'opencode' },
+        { dir: join(home, '.codehere/agents'), defaultFormat: 'codehere' },
+    ];
+    if (cwd) {
+        dirs.push({ dir: join(cwd, '.claude/agents'), defaultFormat: 'claude' });
+        dirs.push({ dir: join(cwd, '.opencode/agents'), defaultFormat: 'opencode' });
+        dirs.push({ dir: join(cwd, '.codehere/agents'), defaultFormat: 'codehere' });
+    }
+    // Dedupe by dir path (preserves order — first occurrence wins)
+    const seen = new Set();
+    return dirs.filter((d) => {
+        if (seen.has(d.dir))
+            return false;
+        seen.add(d.dir);
+        return true;
+    });
+}
+/** Read all cross-tool agent definitions from global + project dirs.  Idempotent + cheap (~10ms for ~20 files); safe to call on every readiness query.
+ *
+ * @param cwd Project working directory whose .claude/.opencode/.codehere agents subdirs to scan
+ * @param options.homeDir Override home directory (testing only — production uses homedir())
+ */
+export function readCrossToolAgents(cwd, options) {
+    const byName = new Map();
+    let filesParsed = 0;
+    let filesSkippedNoFrontmatter = 0;
+    let filesSkippedParseError = 0;
+    let nameCollisions = 0;
+    const dirs = agentDirsToScan(cwd, options?.homeDir);
+    for (const { dir, defaultFormat } of dirs) {
+        for (const filePath of listMdFilesRecursive(dir)) {
+            let agent = null;
+            try {
+                agent = parseAgentFile(filePath, defaultFormat);
+            }
+            catch {
+                filesSkippedParseError++;
+                continue;
+            }
+            if (!agent) {
+                filesSkippedNoFrontmatter++;
+                continue;
+            }
+            filesParsed++;
+            if (byName.has(agent.name))
+                nameCollisions++;
+            byName.set(agent.name, agent); // later wins
+        }
+    }
+    return {
+        agents: [...byName.values()].sort((a, b) => a.name.localeCompare(b.name)),
+        diagnostics: {
+            sourcesScanned: dirs.length,
+            filesParsed,
+            filesSkippedNoFrontmatter,
+            filesSkippedParseError,
+            nameCollisions,
+        },
+    };
+}
+//# sourceMappingURL=cross-tool-agents.js.map

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

@@ -0,0 +1,192 @@
+/**
+ * Project thread forward-mirror — writes new sessions to per-project
+ * thread.jsonl alongside sessions.jsonl during normal daemon operation.
+ *
+ * v0.6.0 M1+M7 — companion to project-thread-migration.ts:
+ *   - Migration handles HISTORICAL data (sessions.jsonl → projects/<slug>/thread.jsonl)
+ *   - This handles NEW data (every spawn + completion writes to BOTH)
+ *
+ * Without this, the project threads created by migration are a one-time
+ * snapshot. With this, every new session lands in both formats and the
+ * project thread stays current as users work. UI restructure (next milestone)
+ * then renders thread.jsonl as the primary view.
+ *
+ * Write pattern matches session-persistence.ts:
+ *   - Append-only (no rewrites; lock-free single writer)
+ *   - Best-effort (failures don't break the spawn path)
+ *   - Each session writes TWO entries over its lifetime:
+ *     1. On spawn:    { type: 'task', sessionId, agent, prompt, cwd, startedAt, status: 'running' }
+ *     2. On complete: { type: 'task', sessionId, status, durationMs, completedAt, steps, artifacts }
+ *   - Reader reconstructs by sessionId (later entry overrides earlier) — same
+ *     shape as project-thread-migration.ts output.
+ *
+ * Filtering matches migration defaults:
+ *   - Temp dirs (/tmp, /var/folders, /private/var/folders, /private/tmp) skipped
+ *   - NULL cwd → 'unknown' bucket
+ *
+ * Iter 13 — built after v0.5.0-alpha.4 ship. Previously the only way new
+ * sessions reached thread.jsonl was to re-run migration; this closes the gap.
+ */
+import { existsSync, mkdirSync, appendFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { createHash } from 'crypto';
+const PROJECTS_DIR = join(homedir(), '.codehere', 'projects');
+/** Match migration module's defaults. Same regex set kept in sync. */
+const TEMP_DIR_PATTERNS = [
+    /^\/tmp\//,
+    /^\/var\/folders\//,
+    /^\/private\/var\/folders\//,
+    /^\/private\/tmp\//,
+];
+function isTempDir(cwd) {
+    if (!cwd)
+        return false;
+    return TEMP_DIR_PATTERNS.some((re) => re.test(cwd));
+}
+function slugForCwd(cwd) {
+    if (!cwd)
+        return 'unknown';
+    return createHash('sha1').update(cwd).digest('hex').slice(0, 12);
+}
+function ensureProjectDir(slug) {
+    const dir = join(PROJECTS_DIR, slug);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function appendThreadEntry(slug, entry) {
+    // Returns true if this write SEEDED the file (first time creation), false otherwise.
+    // Caller (mirrorSpawnedToThread) uses this signal to fire the hidden Title agent.
+    try {
+        const dir = ensureProjectDir(slug);
+        const file = join(dir, 'thread.jsonl');
+        let seeded = false;
+        if (!existsSync(file)) {
+            const meta = JSON.stringify({
+                _meta: 'project',
+                slug,
+                cwd: null, // populated by migration; forward-mirror writes the cwd in each task entry
+                sessionCount: 0,
+                title: null, // populated by hidden Title agent (v0.6.0 M9) on first task entry
+                migratedFrom: 'forward-mirror',
+                migratedAt: Date.now(),
+            });
+            appendFileSync(file, meta + '\n', 'utf-8');
+            seeded = true;
+        }
+        appendFileSync(file, JSON.stringify(entry) + '\n', 'utf-8');
+        return seeded;
+    }
+    catch {
+        // Best-effort. Mirror failures must never break the spawn or completion
+        // path — sessions.jsonl is the canonical store; thread.jsonl is derived.
+        return false;
+    }
+}
+/** Append a project-meta update line (used by Title agent to set the title). */
+function appendMetaUpdate(slug, partial) {
+    try {
+        const dir = ensureProjectDir(slug);
+        const file = join(dir, 'thread.jsonl');
+        if (!existsSync(file))
+            return; // can't update what doesn't exist
+        appendFileSync(file, JSON.stringify({ _meta: 'project-update', slug, ...partial, updatedAt: Date.now() }) + '\n', 'utf-8');
+    }
+    catch {
+        // best-effort
+    }
+}
+/**
+ * Mirror a spawn event to the project thread. Skips temp-dir cwds (matches
+ * migration defaults) so test-artifact dirs don't pollute the project list.
+ *
+ * If this spawn is the FIRST task in a brand-new project (i.e., thread.jsonl
+ * just got seeded), fire the hidden Title agent (v0.6.0 M9) in the background
+ * to generate a 4-6 word title from the first user prompt. The title appears
+ * in the project-meta as a 'project-update' record; readers take the latest
+ * value. Title generation is best-effort and silent on failure.
+ */
+export function mirrorSpawnedToThread(rec) {
+    if (isTempDir(rec.cwd))
+        return;
+    const slug = slugForCwd(rec.cwd);
+    const seeded = appendThreadEntry(slug, {
+        type: 'task',
+        sessionId: rec.sessionId,
+        agent: rec.agent,
+        prompt: rec.prompt,
+        cwd: rec.cwd,
+        startedAt: rec.startedAt,
+        status: 'running',
+    });
+    if (seeded && process.env.CODEHERE_DISABLE_TITLE_AGENT !== '1') {
+        // Fire Title agent in background; do not block the spawn path. Lazy-import
+        // to avoid loading the LLM module on every spawn when not needed.
+        void (async () => {
+            try {
+                const { generateThreadTitle } = await import('../../application/use-cases/generate-thread-title.js');
+                const title = await generateThreadTitle(rec.prompt, rec.cwd);
+                if (title) {
+                    appendMetaUpdate(slug, { title, cwd: rec.cwd });
+                }
+            }
+            catch {
+                // best-effort
+            }
+        })();
+    }
+}
+/**
+ * Mirror a completion event to the project thread. Same skip rules as spawn.
+ * Reader reconstructs by sessionId — this entry's fields override the spawn
+ * entry's where they overlap (status flips from 'running' to actual final).
+ */
+export function mirrorCompletedToThread(rec) {
+    if (isTempDir(rec.cwd))
+        return;
+    const slug = slugForCwd(rec.cwd);
+    appendThreadEntry(slug, {
+        type: 'task',
+        sessionId: rec.sessionId,
+        status: rec.status,
+        durationMs: rec.durationMs,
+        completedAt: rec.completedAt,
+        steps: rec.steps,
+        artifacts: rec.artifacts,
+    });
+}
+/**
+ * v0.6.x — mirror a successful appendMessage() reply to the project thread.
+ *
+ * Pre-fix: only initial spawn + completion wrote to thread.jsonl. Reply turns
+ * (the `/api/task/:id/message` endpoint, the dashboard reply box, and the new
+ * /threads reply bar) updated only the in-memory session. Result: /threads
+ * showed the original spawn but every follow-up turn was invisible. Founder
+ * flagged it 2026-05-03 as a v0.6.x cleanup item.
+ *
+ * Schema choice: write a single complete `{type: 'task', sessionId: <new>,
+ * parentSessionId: <orig>, ...}` entry rather than splitting spawn+complete.
+ * appendMessage is synchronous-from-caller's-POV (no streaming), so the whole
+ * turn is known when this fires. The reader's sessionId merge logic surfaces
+ * each reply as its own chronological row on /threads.
+ */
+export function mirrorReplyToThread(rec) {
+    if (isTempDir(rec.cwd))
+        return;
+    const slug = slugForCwd(rec.cwd);
+    appendThreadEntry(slug, {
+        type: 'task',
+        sessionId: rec.replySessionId,
+        parentSessionId: rec.parentSessionId,
+        agent: rec.agent,
+        prompt: rec.prompt,
+        cwd: rec.cwd,
+        startedAt: rec.startedAt,
+        completedAt: rec.completedAt,
+        durationMs: rec.durationMs,
+        status: 'completed',
+        ...(rec.result ? { result: rec.result } : {}),
+    });
+}
+//# sourceMappingURL=project-thread-mirror.js.map

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