trellis 2.0.13 → 2.1.2

package/src/ui/server.ts

@@ -1,419 +0,0 @@
-/**
- * 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/vcs/blob-store.ts

@@ -1,124 +0,0 @@
-/**
- * Content-Addressable Blob Store
- *
- * Stores file content indexed by SHA-256 hash. Provides the source of truth
- * for file reconstruction at any point in history. The EAV graph stores
- * structural metadata; the blob store stores byte-exact content.
- *
- * Storage format: `.trellis/blobs/{hash}` files on disk.
- * Future: migrate to SQLite `blobs(hash TEXT PRIMARY KEY, content BLOB)`.
- */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-
-export class BlobStore {
-  private blobDir: string;
-
-  constructor(trellisDir: string) {
-    this.blobDir = join(trellisDir, 'blobs');
-    if (!existsSync(this.blobDir)) {
-      mkdirSync(this.blobDir, { recursive: true });
-    }
-  }
-
-  /**
-   * Store content and return its SHA-256 hash.
-   * Idempotent — storing the same content twice is a no-op.
-   */
-  async put(content: Buffer | Uint8Array): Promise<string> {
-    const hash = await this.hash(content);
-    const blobPath = join(this.blobDir, hash);
-    if (!existsSync(blobPath)) {
-      writeFileSync(blobPath, content);
-    }
-    return hash;
-  }
-
-  /**
-   * Synchronous put — uses Bun's sync crypto if available.
-   */
-  putSync(content: Buffer | Uint8Array): string {
-    const hash = this.hashSync(content);
-    const blobPath = join(this.blobDir, hash);
-    if (!existsSync(blobPath)) {
-      writeFileSync(blobPath, content);
-    }
-    return hash;
-  }
-
-  /**
-   * Retrieve content by hash. Returns null if not found.
-   */
-  get(hash: string): Buffer | null {
-    const blobPath = join(this.blobDir, hash);
-    if (!existsSync(blobPath)) {
-      return null;
-    }
-    return readFileSync(blobPath);
-  }
-
-  /**
-   * Check if a blob exists.
-   */
-  has(hash: string): boolean {
-    return existsSync(join(this.blobDir, hash));
-  }
-
-  /**
-   * Compute SHA-256 hash of content (async).
-   */
-  async hash(content: Buffer | Uint8Array): Promise<string> {
-    const hashBuffer = await crypto.subtle.digest(
-      'SHA-256',
-      content as unknown as ArrayBuffer,
-    );
-    return this.hexFromBuffer(hashBuffer);
-  }
-
-  /**
-   * Compute SHA-256 hash of content (sync, using Bun's CryptoHasher).
-   */
-  hashSync(content: Buffer | Uint8Array): string {
-    const hasher = new Bun.CryptoHasher('sha256');
-    hasher.update(content);
-    return hasher.digest('hex');
-  }
-
-  /**
-   * Returns the number of blobs stored.
-   */
-  count(): number {
-    try {
-      const { readdirSync } = require('fs');
-      return readdirSync(this.blobDir).length;
-    } catch {
-      return 0;
-    }
-  }
-
-  /**
-   * Returns the total size of all blobs in bytes.
-   */
-  totalSize(): number {
-    try {
-      const { readdirSync, statSync } = require('fs');
-      const files: string[] = readdirSync(this.blobDir);
-      return files.reduce((sum: number, f: string) => {
-        try {
-          return sum + statSync(join(this.blobDir, f)).size;
-        } catch {
-          return sum;
-        }
-      }, 0);
-    } catch {
-      return 0;
-    }
-  }
-
-  private hexFromBuffer(buffer: ArrayBuffer): string {
-    return Array.from(new Uint8Array(buffer))
-      .map((b) => b.toString(16).padStart(2, '0'))
-      .join('');
-  }
-}

package/src/vcs/branch.ts

@@ -1,150 +0,0 @@
-/**
- * Branch Management Module
- *
- * Extracted from engine.ts per DESIGN.md §8.1.
- * Handles create, switch, list, delete branch operations.
- */
-
-import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { createVcsOp } from './ops.js';
-import type { VcsOp } from './types.js';
-import type { EngineContext } from './engine-context.js';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface BranchInfo {
-  name: string;
-  isCurrent: boolean;
-  createdAt?: string;
-}
-
-export interface BranchState {
-  currentBranch: string;
-}
-
-// ---------------------------------------------------------------------------
-// Operations
-// ---------------------------------------------------------------------------
-
-/**
- * Create a new branch forked from the current branch.
- */
-export async function createBranch(
-  ctx: EngineContext,
-  name: string,
-  currentBranch: string,
-): Promise<VcsOp> {
-  const existing = ctx.store
-    .getFactsByAttribute('type')
-    .filter((f) => f.v === 'Branch' && f.e === `branch:${name}`);
-  if (existing.length > 0) {
-    throw new Error(`Branch '${name}' already exists`);
-  }
-
-  const op = await createVcsOp('vcs:branchCreate', {
-    agentId: ctx.agentId,
-    previousHash: ctx.getLastOp()?.hash,
-    vcs: {
-      branchName: name,
-      baseBranch: currentBranch,
-      targetOpHash: ctx.getLastOp()?.hash,
-    },
-  });
-  ctx.applyOp(op);
-  return op;
-}
-
-/**
- * Switch to an existing branch.
- */
-export function switchBranch(
-  ctx: EngineContext,
-  name: string,
-): void {
-  const branchFacts = ctx.store
-    .getFactsByEntity(`branch:${name}`)
-    .filter((f) => f.a === 'type' && f.v === 'Branch');
-  if (branchFacts.length === 0) {
-    throw new Error(`Branch '${name}' does not exist`);
-  }
-}
-
-/**
- * List all branches.
- */
-export function listBranches(
-  ctx: EngineContext,
-  currentBranch: string,
-): BranchInfo[] {
-  const branchFacts = ctx.store
-    .getFactsByAttribute('type')
-    .filter((f) => f.v === 'Branch');
-
-  return branchFacts.map((f) => {
-    const nameFact = ctx.store
-      .getFactsByEntity(f.e)
-      .find((ef) => ef.a === 'name');
-    const createdFact = ctx.store
-      .getFactsByEntity(f.e)
-      .find((ef) => ef.a === 'createdAt');
-    const name = (nameFact?.v as string) ?? f.e.replace('branch:', '');
-    return {
-      name,
-      isCurrent: name === currentBranch,
-      createdAt: createdFact?.v as string | undefined,
-    };
-  });
-}
-
-/**
- * Delete a branch (cannot delete the current branch).
- */
-export async function deleteBranch(
-  ctx: EngineContext,
-  name: string,
-  currentBranch: string,
-): Promise<VcsOp> {
-  if (name === currentBranch) {
-    throw new Error(`Cannot delete the current branch '${name}'`);
-  }
-  const branchFacts = ctx.store
-    .getFactsByEntity(`branch:${name}`)
-    .filter((f) => f.a === 'type' && f.v === 'Branch');
-  if (branchFacts.length === 0) {
-    throw new Error(`Branch '${name}' does not exist`);
-  }
-
-  const op = await createVcsOp('vcs:branchDelete', {
-    agentId: ctx.agentId,
-    previousHash: ctx.getLastOp()?.hash,
-    vcs: { branchName: name },
-  });
-  ctx.applyOp(op);
-  return op;
-}
-
-// ---------------------------------------------------------------------------
-// Persistence
-// ---------------------------------------------------------------------------
-
-export function saveBranchState(rootPath: string, state: BranchState): void {
-  const statePath = join(rootPath, '.trellis', 'state.json');
-  writeFileSync(statePath, JSON.stringify(state));
-}
-
-export function loadBranchState(rootPath: string): BranchState {
-  const statePath = join(rootPath, '.trellis', 'state.json');
-  if (existsSync(statePath)) {
-    try {
-      const raw = readFileSync(statePath, 'utf-8');
-      const state = JSON.parse(raw);
-      if (state.currentBranch) {
-        return { currentBranch: state.currentBranch };
-      }
-    } catch {}
-  }
-  return { currentBranch: 'main' };
-}