@selvakumaresra/specship 0.1.3 → 0.3.0

package/dist/server/ingest/types.js

@@ -0,0 +1,9 @@
+/**
+ * Type definitions for Claude Code JSONL transcript ingest.
+ *
+ * These mirror the fields we actually use — Claude Code's JSONL format has
+ * many more fields than these (parentUuid, isSidechain, version, gitBranch,
+ * userType, …); we capture only what drives analytics + cost. Unknown fields
+ * pass through silently.
+ */
+export {};

package/dist/server/ingest/watcher.js

@@ -0,0 +1,77 @@
+/**
+ * Filesystem watcher that re-runs the ingestor on JSONL changes.
+ *
+ * Strategy:
+ *   - One initial full pass on start (catches everything written while the
+ *     watcher wasn't running — same offset state, no duplicates).
+ *   - fs.watch on the ~/.claude/projects/ tree, debounced 300ms — Claude
+ *     Code writes one line at a time during a session, so we don't want to
+ *     re-ingest on every keystroke.
+ *   - On change, re-run ingestAll. The state table makes this cheap: only
+ *     new bytes are read + parsed.
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ingestAll } from './ingestor.js';
+export function startWatcher(db, options = {}) {
+    const claudeRoot = options.claudeRoot ?? path.join(os.homedir(), '.claude', 'projects');
+    const debounceMs = options.debounceMs ?? 300;
+    const verbose = options.verbose ?? false;
+    let pending = null;
+    const triggerSoon = () => {
+        if (pending)
+            clearTimeout(pending);
+        pending = setTimeout(() => {
+            pending = null;
+            try {
+                ingestAll(db, { ...options, claudeRoot });
+            }
+            catch (err) {
+                if (verbose) {
+                    // eslint-disable-next-line no-console
+                    console.error('[ingest watcher] pass failed:', err instanceof Error ? err.message : String(err));
+                }
+            }
+        }, debounceMs);
+    };
+    // Initial pass.
+    if (options.initialIngest !== false) {
+        triggerSoon();
+    }
+    // fs.watch on the root, recursive. On macOS + Linux this gives us per-file
+    // events; on Windows the recursive flag is supported as of recent Node.
+    let watcher = null;
+    try {
+        watcher = fs.watch(claudeRoot, { recursive: true, persistent: true }, (eventType, filename) => {
+            if (!filename)
+                return;
+            const f = filename.toString();
+            if (!f.toLowerCase().endsWith('.jsonl'))
+                return;
+            triggerSoon();
+        });
+    }
+    catch (err) {
+        // Directory doesn't exist (user hasn't run Claude Code) — just no-op.
+        if (verbose) {
+            // eslint-disable-next-line no-console
+            console.error('[ingest watcher] could not watch', claudeRoot, ':', err instanceof Error ? err.message : String(err));
+        }
+    }
+    return {
+        stop: () => {
+            if (pending) {
+                clearTimeout(pending);
+                pending = null;
+            }
+            if (watcher) {
+                try {
+                    watcher.close();
+                }
+                catch { /* ignore */ }
+            }
+        },
+        ingestNow: () => ingestAll(db, { ...options, claudeRoot }),
+    };
+}

package/dist/server/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/server/project-registry.js

@@ -0,0 +1,101 @@
+/**
+ * ProjectRegistry — lazy-opens and caches SpecShip instances per project
+ * path, keyed by absolute path. LRU evicts when the cache exceeds maxOpen
+ * so a long-running server doesn't hold every project's SQLite handle
+ * forever.
+ *
+ * Used by the Fastify routes (via `app.activeCg(req)`) to back the desktop
+ * app's project picker: when the user switches projects in the UI, the
+ * specship-scoped surfaces (graph, specs, drift, workflows, status) start
+ * reading from the matching instance — opened on demand if it isn't
+ * already cached.
+ *
+ * Analytics endpoints (`/api/claude/*`, `/api/memory`) read from a single
+ * "primary" instance instead, since their data (JSONL ingest, CLAUDE.md
+ * hierarchy) is global to the user, not scoped to one project.
+ */
+import { decodeProjectSlug } from './ingest/ingestor.js';
+export class ProjectRegistry {
+    cache = new Map();
+    maxOpen;
+    verbose;
+    openImpl;
+    constructor(opts, defaultOpenImpl) {
+        this.maxOpen = opts.maxOpen ?? 5;
+        this.verbose = opts.verbose ?? false;
+        this.openImpl = opts.openImpl ?? defaultOpenImpl;
+    }
+    /**
+     * Return the cached SpecShip for `projectPath`, opening it on demand.
+     * Returns null when the path isn't initialized (no `.specship/`) or
+     * the open throws — callers surface a friendly UI error.
+     */
+    async get(projectPath) {
+        const existing = this.cache.get(projectPath);
+        if (existing) {
+            existing.lastAccess = Date.now();
+            return existing.cg;
+        }
+        try {
+            const cg = await this.openImpl(projectPath);
+            this.cache.set(projectPath, { cg, lastAccess: Date.now() });
+            this.evictIfNeeded();
+            if (this.verbose)
+                console.error(`[registry] opened ${projectPath} (cache size ${this.cache.size})`);
+            return cg;
+        }
+        catch (err) {
+            if (this.verbose)
+                console.error(`[registry] open failed for ${projectPath}: ${err instanceof Error ? err.message : String(err)}`);
+            return null;
+        }
+    }
+    /**
+     * Look up by Claude Code's slug-encoded project name
+     * (`-Users-alice-foo` → `/Users/alice/foo`).
+     */
+    async getBySlug(slug) {
+        return this.get(decodeProjectSlug(slug));
+    }
+    /** Currently-cached project paths (most-recent-access first). */
+    openPaths() {
+        return [...this.cache.entries()]
+            .sort((a, b) => b[1].lastAccess - a[1].lastAccess)
+            .map(([k]) => k);
+    }
+    has(projectPath) { return this.cache.has(projectPath); }
+    /** Close + drop every cached instance. Called on server shutdown. */
+    closeAll() {
+        for (const [, v] of this.cache) {
+            try {
+                v.cg.close();
+            }
+            catch { /* ignore */ }
+        }
+        this.cache.clear();
+    }
+    evictIfNeeded() {
+        if (this.cache.size <= this.maxOpen)
+            return;
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [k, v] of this.cache) {
+            if (v.lastAccess < oldestTime) {
+                oldestTime = v.lastAccess;
+                oldestKey = k;
+            }
+        }
+        if (oldestKey) {
+            const entry = this.cache.get(oldestKey);
+            if (entry) {
+                try {
+                    entry.cg.close();
+                }
+                catch { /* ignore */ }
+            }
+            this.cache.delete(oldestKey);
+            if (this.verbose)
+                console.error(`[registry] evicted ${oldestKey}`);
+        }
+    }
+}