archbyte 0.6.0 → 0.7.0

package/dist/server/src/index.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import { watch } from "chokidar";
 import { readFile, writeFile, mkdir } from "fs/promises";
-import { existsSync, readFileSync, statSync } from "fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
+import { homedir } from "os";
 import { createServer } from "http";
 import { execSync, spawn, spawnSync } from "child_process";
 // Get UI assets path
@@ -1223,18 +1224,6 @@ function createHttpServer() {
             res.end(JSON.stringify({ running: runningWorkflows.has("__generate__") }));
             return;
         }
-        // API: Reload — re-read architecture, reconcile pending changes
-        if (url === "/api/reload" && req.method === "POST") {
-            currentArchitecture = await loadArchitecture();
-            reconcilePendingWithGit();
-            broadcastUpdate();
-            if (pendingSourceChanges.size > 0) {
-                broadcastPendingChanges();
-            }
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ ok: true }));
-            return;
-        }
         // API: Run analyze (static or LLM) + generate
         if (url === "/api/analyze" && req.method === "POST") {
             if (isAnalyzing) {
@@ -1696,6 +1685,38 @@ function createHttpServer() {
             });
             return;
         }
+        // API: Sessions — list all sessions
+        if (url === "/api/sessions" && req.method === "GET") {
+            try {
+                const sessionIndex = await getSessionsIndex();
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(sessionIndex));
+            }
+            catch (error) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: String(error) }));
+            }
+            return;
+        }
+        // API: Sessions — get single session by ID
+        if (url.startsWith("/api/sessions/") && req.method === "GET") {
+            const sessionId = decodeURIComponent(url.replace("/api/sessions/", "").split("?")[0]);
+            try {
+                const session = await loadSingleSession(sessionId);
+                if (!session) {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Session not found" }));
+                    return;
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(session));
+            }
+            catch (error) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: String(error) }));
+            }
+            return;
+        }
         // Serve static UI files
         const MIME_TYPES = {
             ".html": "text/html",
@@ -2138,6 +2159,272 @@ function loadLicenseInfo() {
         return defaults;
     }
 }
+// Session helpers — load sessions from archbyte + claude-transcripts
+let sessionWatcher = null;
+// Cached session index + route map for fast single-session lookups
+let _cachedSessionIndex = null;
+const _sessionRouteMap = new Map();
+async function getSessionsIndex() {
+    if (_cachedSessionIndex)
+        return _cachedSessionIndex;
+    _cachedSessionIndex = await loadSessionsIndex();
+    return _cachedSessionIndex;
+}
+// Ignored directories when scanning for session dirs
+const SCAN_IGNORE = new Set(["node_modules", ".git", ".hg", "dist", "build", ".next", "__pycache__", "vendor", ".venv", "venv"]);
+const SESSION_SCAN_MAX_DEPTH = 4;
+/** Recursively find named hidden directories (e.g. ".archbyte") */
+function findSessionDirs(root, targetNames, depth = 0) {
+    if (depth > SESSION_SCAN_MAX_DEPTH)
+        return [];
+    const results = [];
+    try {
+        const entries = readdirSync(root, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (targetNames.includes(entry.name)) {
+                results.push(path.join(root, entry.name));
+            }
+            else if (!SCAN_IGNORE.has(entry.name) && !entry.name.startsWith(".")) {
+                results.push(...findSessionDirs(path.join(root, entry.name), targetNames, depth + 1));
+            }
+        }
+    }
+    catch {
+        // Permission error or unreadable dir — skip
+    }
+    return results;
+}
+// Cache discovered dirs (refreshed on watcher events)
+let _archbyteDirs = null;
+let _claudeTranscriptDir = undefined; // undefined = not checked yet
+/** Load sessionsPaths from archbyte global config (~/.archbyte/config.json) */
+function getConfigSessionsPaths() {
+    try {
+        const configPath = path.join(homedir(), ".archbyte", "config.json");
+        if (!existsSync(configPath))
+            return [];
+        const raw = readFileSync(configPath, "utf-8");
+        const cfg = JSON.parse(raw);
+        return Array.isArray(cfg.sessionsPaths) ? cfg.sessionsPaths : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Discover all archbyte session dirs from workspace + external paths */
+function discoverArchbyteDirs() {
+    if (_archbyteDirs)
+        return _archbyteDirs;
+    const allArchbyte = [];
+    // Scan within project tree
+    const found = findSessionDirs(config.workspaceRoot, [".archbyte"]);
+    for (const dir of found) {
+        if (path.basename(dir) === ".archbyte")
+            allArchbyte.push(dir);
+    }
+    // Also scan configured external paths
+    for (const extPath of getConfigSessionsPaths()) {
+        const resolved = path.resolve(extPath);
+        if (!existsSync(resolved))
+            continue;
+        if (path.basename(resolved) === ".archbyte") {
+            allArchbyte.push(resolved);
+        }
+        else {
+            const extFound = findSessionDirs(resolved, [".archbyte"]);
+            for (const dir of extFound) {
+                if (path.basename(dir) === ".archbyte")
+                    allArchbyte.push(dir);
+            }
+        }
+    }
+    _archbyteDirs = [...new Set(allArchbyte)];
+    return _archbyteDirs;
+}
+function getArchbyteDirs() {
+    return discoverArchbyteDirs();
+}
+function getClaudeTranscriptDir() {
+    if (_claudeTranscriptDir !== undefined)
+        return _claudeTranscriptDir;
+    const encoded = config.workspaceRoot.replace(/^\//, "").replace(/\//g, "-");
+    const dir = path.join(homedir(), ".claude", "projects", `-${encoded}`);
+    _claudeTranscriptDir = existsSync(dir) ? dir : null;
+    return _claudeTranscriptDir;
+}
+async function loadSessionsIndex() {
+    const index = { sessions: [] };
+    // Clear route map — will be repopulated below
+    _sessionRouteMap.clear();
+    const archbyteDirs = discoverArchbyteDirs();
+    // Import archbyte sessions
+    if (archbyteDirs.length > 0) {
+        try {
+            const { importArchbyte } = await import("../../agents/observability/adapters/archbyte.js");
+            for (const abDir of archbyteDirs) {
+                const abSessions = await importArchbyte(abDir);
+                const relativePath = path.relative(config.workspaceRoot, abDir);
+                const sourceLabel = relativePath === ".archbyte" ? "archbyte" : `archbyte (${path.dirname(relativePath)})`;
+                for (const abs of abSessions) {
+                    index.sessions.push({
+                        sessionId: abs.sessionId,
+                        startedAt: abs.startedAt,
+                        completedAt: abs.completedAt,
+                        status: abs.status,
+                        runCount: abs.summary.totalRuns,
+                        phases: abs.summary.phases,
+                        source: sourceLabel,
+                    });
+                    _sessionRouteMap.set(abs.sessionId, { source: "archbyte", dir: abDir });
+                }
+            }
+        }
+        catch (err) {
+            console.error("[sessions] archbyte import error:", err);
+        }
+    }
+    // Import Claude transcript sessions
+    const ctDir = getClaudeTranscriptDir();
+    if (ctDir) {
+        try {
+            const { scanTranscriptIndex } = await import("../../agents/observability/adapters/claude-transcripts.js");
+            const ctEntries = await scanTranscriptIndex(ctDir);
+            for (const e of ctEntries) {
+                index.sessions.push({
+                    sessionId: e.sessionId,
+                    startedAt: e.startedAt,
+                    completedAt: e.completedAt,
+                    status: e.status,
+                    runCount: e.runCount,
+                    phases: e.phases,
+                    source: "claude-transcript",
+                    category: e.category,
+                    label: e.label,
+                    touchedDirs: e.touchedDirs,
+                    eventCount: e.eventCount,
+                    dirMetrics: e.dirMetrics,
+                    estimatedCost: e.estimatedCost,
+                });
+                _sessionRouteMap.set(e.sessionId, { source: "claude-transcript", dir: ctDir });
+            }
+        }
+        catch (err) {
+            console.error("[sessions] claude-transcripts index error:", err);
+        }
+    }
+    // Sort newest first
+    index.sessions.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+    return index;
+}
+async function loadSingleSession(sessionId) {
+    // Fast path: use route map if available (populated after first index build)
+    const route = _sessionRouteMap.get(sessionId);
+    if (route) {
+        try {
+            if (route.source === "claude-transcript") {
+                const { importClaudeTranscript } = await import("../../agents/observability/adapters/claude-transcripts.js");
+                return await importClaudeTranscript(route.dir, sessionId);
+            }
+            else if (route.source === "archbyte") {
+                const { importArchbyte } = await import("../../agents/observability/adapters/archbyte.js");
+                const sessions = await importArchbyte(route.dir);
+                const found = sessions.find((s) => s.sessionId === sessionId);
+                if (found)
+                    return found;
+            }
+        }
+        catch (err) {
+            console.error(`[sessions] routed lookup failed for ${sessionId}:`, err);
+        }
+    }
+    // Fallback: full scan (cold start or route miss)
+    const archbyteDirs = discoverArchbyteDirs();
+    if (archbyteDirs.length > 0) {
+        try {
+            const { importArchbyte } = await import("../../agents/observability/adapters/archbyte.js");
+            for (const abDir of archbyteDirs) {
+                const sessions = await importArchbyte(abDir);
+                const found = sessions.find((s) => s.sessionId === sessionId);
+                if (found)
+                    return found;
+            }
+        }
+        catch (err) {
+            console.error("[sessions] archbyte single session error:", err);
+        }
+    }
+    const ctDir2 = getClaudeTranscriptDir();
+    if (ctDir2) {
+        try {
+            const { importClaudeTranscript } = await import("../../agents/observability/adapters/claude-transcripts.js");
+            return await importClaudeTranscript(ctDir2, sessionId);
+        }
+        catch (err) {
+            console.error("[sessions] claude-transcripts session error:", err);
+        }
+    }
+    return null;
+}
+/** Build a fingerprint of the session index for diffing */
+function sessionIndexFingerprint(index) {
+    // Fast fingerprint: sorted sessionId + status + runCount + completedAt
+    return index.sessions
+        .map(s => `${s.sessionId}:${s.status}:${s.runCount}:${s.completedAt || ""}`)
+        .sort()
+        .join("|");
+}
+function setupSessionWatcher() {
+    const watchPaths = [];
+    // Watch all discovered session directories
+    for (const abDir of getArchbyteDirs()) {
+        watchPaths.push(abDir);
+    }
+    const ctDir3 = getClaudeTranscriptDir();
+    if (ctDir3)
+        watchPaths.push(ctDir3);
+    if (watchPaths.length === 0)
+        return;
+    let debounce = null;
+    sessionWatcher = watch(watchPaths, {
+        ignoreInitial: true,
+        depth: 4,
+        ignored: /(^|[\/\\])\../,
+    });
+    sessionWatcher.on("all", (_event, changedPath) => {
+        // Targeted cache invalidation for .jsonl transcript files
+        if (changedPath && changedPath.endsWith(".jsonl")) {
+            import("../../agents/observability/adapters/claude-transcripts.js")
+                .then(mod => mod.invalidateIndexCache(changedPath))
+                .catch(() => { });
+        }
+        if (debounce)
+            clearTimeout(debounce);
+        debounce = setTimeout(async () => {
+            try {
+                // Snapshot old fingerprint before rebuild
+                const oldFingerprint = _cachedSessionIndex
+                    ? sessionIndexFingerprint(_cachedSessionIndex)
+                    : "";
+                // Invalidate caches so new dirs are discovered
+                _archbyteDirs = null;
+                _claudeTranscriptDir = undefined;
+                _cachedSessionIndex = null;
+                const index = await loadSessionsIndex();
+                _cachedSessionIndex = index;
+                // Only broadcast if index actually changed
+                const newFingerprint = sessionIndexFingerprint(index);
+                if (newFingerprint !== oldFingerprint) {
+                    broadcastOpsEvent({ type: "session:update", sessions: index });
+                }
+            }
+            catch {
+                // Non-fatal
+            }
+        }, 1000);
+    });
+}
 // Export start function
 export async function startServer(cfg) {
     config = cfg;
@@ -2156,6 +2443,7 @@ export async function startServer(cfg) {
     reconcilePendingWithGit();
     setupSourceWatcher();
     setupGitWatcher();
+    setupSessionWatcher();
     console.error(`[archbyte] Serving ${config.name}`);
     console.error(`[archbyte] Diagram: ${config.diagramPath}`);
     // Listen for 'q' keypress to quit gracefully

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archbyte",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "ArchByte - See what agents build. As they build it.",
   "type": "module",
   "bin": {