trellis 2.0.7 → 2.0.8

package/src/ui/server.ts

@@ -0,0 +1,419 @@
+/**
+ * Trellis UI Server
+ *
+ * Lightweight Bun HTTP server that exposes the TrellisVCS engine
+ * as a JSON API and serves a single-file force-graph visualization.
+ *
+ * Endpoints:
+ *   GET /              → client.html
+ *   GET /api/graph     → full graph (nodes + edges)
+ *   GET /api/search    → semantic search (?q=...&limit=10&type=...)
+ *   GET /api/node/:id  → node detail
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { TrellisVcsEngine } from '../engine.js';
+import {
+  buildRefIndex,
+  createResolverContext,
+  getOutgoingRefs,
+  getReferencedEntities,
+  getBacklinks,
+} from '../links/index.js';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface GraphNode {
+  id: string;
+  label: string;
+  type: 'file' | 'milestone' | 'issue' | 'branch';
+  meta: Record<string, unknown>;
+}
+
+export interface GraphEdge {
+  source: string;
+  target: string;
+  type: 'milestone_file' | 'issue_branch' | 'wikilink' | 'causal';
+  label?: string;
+}
+
+export interface GraphData {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+}
+
+// ---------------------------------------------------------------------------
+// Graph builder
+// ---------------------------------------------------------------------------
+
+function buildGraph(engine: TrellisVcsEngine): GraphData {
+  const nodes: GraphNode[] = [];
+  const edges: GraphEdge[] = [];
+  const nodeIds = new Set<string>();
+
+  // --- Files ---
+  const files = engine.trackedFiles();
+  for (const f of files) {
+    const id = `file:${f.path}`;
+    nodes.push({
+      id,
+      label: f.path,
+      type: 'file',
+      meta: { contentHash: f.contentHash },
+    });
+    nodeIds.add(id);
+  }
+
+  // --- Milestones ---
+  const milestones = engine.listMilestones();
+  for (const m of milestones) {
+    const id = `milestone:${m.id}`;
+    nodes.push({
+      id,
+      label: m.message ?? m.id,
+      type: 'milestone',
+      meta: {
+        createdAt: m.createdAt,
+        affectedFiles: m.affectedFiles,
+        fromOpHash: m.fromOpHash,
+        toOpHash: m.toOpHash,
+      },
+    });
+    nodeIds.add(id);
+
+    // Edges: milestone → affected files
+    for (const fp of m.affectedFiles ?? []) {
+      const fileId = `file:${fp}`;
+      if (nodeIds.has(fileId)) {
+        edges.push({
+          source: id,
+          target: fileId,
+          type: 'milestone_file',
+        });
+      }
+    }
+  }
+
+  // --- Issues ---
+  const issues = engine.listIssues();
+  for (const iss of issues) {
+    const id = `issue:${iss.id}`;
+    nodes.push({
+      id,
+      label: iss.title ?? iss.id,
+      type: 'issue',
+      meta: {
+        status: iss.status,
+        priority: iss.priority,
+        labels: iss.labels,
+        assignee: iss.assignee,
+        createdAt: iss.createdAt,
+        description: iss.description,
+        criteria: iss.criteria,
+      },
+    });
+    nodeIds.add(id);
+
+    // Edge: issue → its branch
+    if (iss.branchName) {
+      const branchId = `branch:${iss.branchName}`;
+      if (nodeIds.has(branchId)) {
+        edges.push({
+          source: id,
+          target: branchId,
+          type: 'issue_branch',
+        });
+      }
+    }
+  }
+
+  // --- Branches ---
+  const branches = engine.listBranches();
+  for (const b of branches) {
+    const id = `branch:${b.name}`;
+    if (!nodeIds.has(id)) {
+      nodes.push({
+        id,
+        label: b.name,
+        type: 'branch',
+        meta: {
+          isCurrent: b.isCurrent,
+          createdAt: b.createdAt,
+        },
+      });
+      nodeIds.add(id);
+    }
+
+    // Link issues that reference this branch
+    for (const iss of issues) {
+      if (iss.branchName === b.name) {
+        edges.push({
+          source: `issue:${iss.id}`,
+          target: id,
+          type: 'issue_branch',
+        });
+      }
+    }
+  }
+
+  // --- Wiki-links (if markdown files exist) ---
+  try {
+    const mdFiles: Array<{ path: string; content: string }> = [];
+    for (const f of files) {
+      if (f.path.endsWith('.md')) {
+        const absPath = join(engine.getRootPath(), f.path);
+        if (existsSync(absPath)) {
+          mdFiles.push({
+            path: f.path,
+            content: readFileSync(absPath, 'utf-8'),
+          });
+        }
+      }
+    }
+
+    if (mdFiles.length > 0) {
+      const ctx = createResolverContext({
+        trackedFiles: () => files,
+        listIssues: () => issues as any,
+        listMilestones: () => milestones as any,
+      } as any);
+
+      const refIndex = buildRefIndex(mdFiles, ctx);
+
+      for (const [filePath, refs] of refIndex.outgoing) {
+        const sourceId = `file:${filePath}`;
+        if (!nodeIds.has(sourceId)) continue;
+        for (const ref of refs) {
+          const targetId = `${ref.namespace}:${ref.target}`;
+          // Normalize to our node IDs
+          const candidateIds = [
+            targetId,
+            `file:${ref.target}`,
+            `issue:${ref.target}`,
+            `milestone:${ref.target}`,
+          ];
+          for (const cid of candidateIds) {
+            if (nodeIds.has(cid) && cid !== sourceId) {
+              edges.push({
+                source: sourceId,
+                target: cid,
+                type: 'wikilink',
+                label: ref.target,
+              });
+              break;
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    // Wiki-link indexing is best-effort
+  }
+
+  return { nodes, edges };
+}
+
+// ---------------------------------------------------------------------------
+// Node detail
+// ---------------------------------------------------------------------------
+
+function getNodeDetail(
+  engine: TrellisVcsEngine,
+  nodeId: string,
+): Record<string, unknown> | null {
+  const [type, ...rest] = nodeId.split(':');
+  const id = rest.join(':');
+
+  switch (type) {
+    case 'file': {
+      const files = engine.trackedFiles();
+      const file = files.find((f) => f.path === id);
+      if (!file) return null;
+      // Get recent ops for this file
+      const ops = engine.log({ filePath: id, limit: 10 });
+      return {
+        type: 'file',
+        path: id,
+        contentHash: file.contentHash,
+        recentOps: ops.map((o) => ({
+          kind: o.kind,
+          timestamp: o.timestamp,
+          hash: o.hash.slice(0, 24),
+        })),
+      };
+    }
+    case 'milestone': {
+      const milestones = engine.listMilestones();
+      const m = milestones.find((ms) => ms.id === id);
+      if (!m) return null;
+      return { type: 'milestone', ...m };
+    }
+    case 'issue': {
+      const issue = engine.getIssue(id);
+      if (!issue) return null;
+      return { type: 'issue', ...issue };
+    }
+    case 'branch': {
+      const branches = engine.listBranches();
+      const b = branches.find((br) => br.name === id);
+      if (!b) return null;
+      return { type: 'branch', ...b };
+    }
+    default:
+      return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Server
+// ---------------------------------------------------------------------------
+
+export interface UIServerOptions {
+  rootPath: string;
+  port?: number;
+  open?: boolean;
+}
+
+export async function startUIServer(opts: UIServerOptions): Promise<{
+  port: number;
+  stop: () => void;
+}> {
+  const engine = new TrellisVcsEngine({ rootPath: opts.rootPath });
+  engine.open();
+
+  const clientHtml = readFileSync(
+    join(dirname(new URL(import.meta.url).pathname), 'client.html'),
+    'utf-8',
+  );
+
+  // Lazy-load embedding manager for search
+  let embeddingManager: any = null;
+  function getEmbeddingManager() {
+    if (!embeddingManager) {
+      try {
+        const { EmbeddingManager } = require('../embeddings/index.js');
+        const dbPath = join(opts.rootPath, '.trellis', 'embeddings.db');
+        if (existsSync(dbPath)) {
+          embeddingManager = new EmbeddingManager(dbPath);
+        }
+      } catch {
+        // Embeddings not available
+      }
+    }
+    return embeddingManager;
+  }
+
+  const requestedPort = opts.port ?? 3333;
+
+  const server = Bun.serve({
+    port: requestedPort,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const path = url.pathname;
+
+      // CORS headers
+      const headers = {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+      };
+
+      if (req.method === 'OPTIONS') {
+        return new Response(null, { status: 204, headers });
+      }
+
+      // --- API Routes ---
+
+      if (path === '/api/graph') {
+        const graph = buildGraph(engine);
+        return Response.json(graph, { headers });
+      }
+
+      if (path === '/api/search') {
+        const query = url.searchParams.get('q');
+        if (!query) {
+          return Response.json(
+            { error: 'Missing ?q= parameter' },
+            { status: 400, headers },
+          );
+        }
+        const limit = parseInt(url.searchParams.get('limit') ?? '10', 10);
+        const typeFilter = url.searchParams.get('type');
+
+        const mgr = getEmbeddingManager();
+        if (!mgr) {
+          return Response.json(
+            {
+              results: [],
+              message: 'No embedding index. Run `trellis reindex` first.',
+            },
+            { headers },
+          );
+        }
+
+        try {
+          const searchOpts: any = { limit };
+          if (typeFilter) {
+            searchOpts.types = typeFilter
+              .split(',')
+              .map((t: string) => t.trim());
+          }
+          const results = await mgr.search(query, searchOpts);
+          return Response.json(
+            {
+              results: results.map((r: any) => ({
+                score: r.score,
+                chunkType: r.chunk.chunkType,
+                filePath: r.chunk.filePath,
+                entityId: r.chunk.entityId,
+                content: r.chunk.content,
+              })),
+            },
+            { headers },
+          );
+        } catch (err: any) {
+          return Response.json(
+            { error: err.message },
+            { status: 500, headers },
+          );
+        }
+      }
+
+      if (path.startsWith('/api/node/')) {
+        const nodeId = decodeURIComponent(path.slice('/api/node/'.length));
+        const detail = getNodeDetail(engine, nodeId);
+        if (!detail) {
+          return Response.json(
+            { error: 'Node not found' },
+            { status: 404, headers },
+          );
+        }
+        return Response.json(detail, { headers });
+      }
+
+      // --- Static ---
+      if (path === '/' || path === '/index.html') {
+        return new Response(clientHtml, {
+          headers: { ...headers, 'Content-Type': 'text/html; charset=utf-8' },
+        });
+      }
+
+      return new Response('Not Found', { status: 404, headers });
+    },
+  });
+
+  return {
+    port: server.port as number,
+    stop: () => {
+      server.stop();
+      if (embeddingManager) {
+        try {
+          embeddingManager.close();
+        } catch {}
+      }
+    },
+  };
+}

package/src/watcher/fs-watcher.ts

@@ -18,6 +18,13 @@ export interface FileWatcherConfig {
   onEvent: (event: FileChangeEvent) => void | Promise<void>;
 }
 
+export interface ScanProgress {
+  phase: 'discovering' | 'hashing' | 'done';
+  current: number;
+  total: number;
+  message: string;
+}
+
 /**
  * Computes SHA-256 content hash for a file.
  */
@@ -59,11 +66,26 @@ export class FileWatcher {
    * Scans the directory tree and builds an initial map of all tracked files.
    * Returns the list of FileChangeEvents for the initial state (all adds).
    */
-  async scan(): Promise<FileChangeEvent[]> {
+  async scan(opts?: {
+    onProgress?: (progress: ScanProgress) => void;
+  }): Promise<FileChangeEvent[]> {
     const events: FileChangeEvent[] = [];
+    opts?.onProgress?.({
+      phase: 'discovering',
+      current: 0,
+      total: 0,
+      message: 'Discovering existing files…',
+    });
     const entries = await this.walkDir(this.config.rootPath);
-
-    for (const absPath of entries) {
+    opts?.onProgress?.({
+      phase: 'hashing',
+      current: 0,
+      total: entries.length,
+      message: `Hashing ${entries.length} existing files…`,
+    });
+
+    for (let i = 0; i < entries.length; i++) {
+      const absPath = entries[i];
       const relPath = relative(this.config.rootPath, absPath);
       if (shouldIgnore(relPath, this.config.ignorePatterns)) continue;
 
@@ -81,8 +103,24 @@ export class FileWatcher {
       } catch {
         // File may have been deleted between scan and hash
       }
+
+      if ((i + 1) % 25 === 0 || i === entries.length - 1) {
+        opts?.onProgress?.({
+          phase: 'hashing',
+          current: i + 1,
+          total: entries.length,
+          message: `Hashed ${i + 1}/${entries.length} files`,
+        });
+      }
     }
 
+    opts?.onProgress?.({
+      phase: 'done',
+      current: events.length,
+      total: events.length,
+      message: `Discovered ${events.length} trackable files`,
+    });
+
     return events;
   }