trellis 2.0.13 → 2.1.2

package/src/semantic/types.ts

@@ -1,175 +0,0 @@
-/**
- * Semantic Patching — Type Definitions
- *
- * DESIGN.md §4.1–4.4 — Pillar 2: Semantic Patching.
- * Types for parser adapters, AST entities, parse results,
- * semantic patches, and structured merge conflicts.
- */
-
-// ---------------------------------------------------------------------------
-// AST Entities
-// ---------------------------------------------------------------------------
-
-export interface ASTEntity {
-  /** Stable ID derived from structural signature (name + kind + scope path). */
-  id: string;
-  /** Entity type. */
-  kind: ASTEntityKind;
-  /** Human-readable name. */
-  name: string;
-  /** Scope path for disambiguation (e.g. 'MyClass.myMethod'). */
-  scopePath: string;
-  /** Byte range in source for roundtrip (start, end). */
-  span: [number, number];
-  /** Raw source text of this declaration. */
-  rawText: string;
-  /** Structural signature for identity matching (excludes whitespace/comments). */
-  signature: string;
-  /** Child entities (nested functions, inner classes, etc.). */
-  children: ASTEntity[];
-}
-
-export type ASTEntityKind =
-  | 'FunctionDef'
-  | 'ClassDef'
-  | 'InterfaceDef'
-  | 'TypeAlias'
-  | 'EnumDef'
-  | 'VariableDecl'
-  | 'MethodDef'
-  | 'PropertyDef'
-  | 'Constructor'
-  | 'Unknown';
-
-// ---------------------------------------------------------------------------
-// Import / Export Relations
-// ---------------------------------------------------------------------------
-
-export interface ImportRelation {
-  source: string;
-  specifiers: string[];
-  isDefault: boolean;
-  isNamespace: boolean;
-  rawText: string;
-  span: [number, number];
-}
-
-export interface ExportRelation {
-  name: string;
-  isDefault: boolean;
-  source?: string;
-  rawText: string;
-  span: [number, number];
-}
-
-// ---------------------------------------------------------------------------
-// Parse Result
-// ---------------------------------------------------------------------------
-
-export interface ParseResult {
-  /** The file entity this parse belongs to. */
-  fileEntityId: string;
-  /** File path. */
-  filePath: string;
-  /** Language identifier. */
-  language: string;
-  /** Top-level declarations found in the file. */
-  declarations: ASTEntity[];
-  /** Import relationships. */
-  imports: ImportRelation[];
-  /** Export relationships. */
-  exports: ExportRelation[];
-}
-
-// ---------------------------------------------------------------------------
-// Parser Adapter Interface
-// ---------------------------------------------------------------------------
-
-export interface ParserAdapter {
-  /** Languages this adapter supports. */
-  languages: string[];
-  /** Parse a source file into AST-level entities. */
-  parse(content: string, filePath: string): ParseResult;
-  /** Compute semantic patches between two parse results. */
-  diff(oldResult: ParseResult, newResult: ParseResult): SemanticPatch[];
-}
-
-// ---------------------------------------------------------------------------
-// Semantic Patch Types
-// ---------------------------------------------------------------------------
-
-export type SemanticPatch =
-  | { kind: 'symbolAdd'; entity: ASTEntity }
-  | { kind: 'symbolRemove'; entityId: string; entityName: string }
-  | {
-      kind: 'symbolModify';
-      entityId: string;
-      entityName: string;
-      oldSignature: string;
-      newSignature: string;
-      oldRawText: string;
-      newRawText: string;
-    }
-  | {
-      kind: 'symbolRename';
-      entityId: string;
-      oldName: string;
-      newName: string;
-    }
-  | {
-      kind: 'symbolMove';
-      entityId: string;
-      entityName: string;
-      oldFile: string;
-      newFile: string;
-    }
-  | {
-      kind: 'importAdd';
-      fileId: string;
-      source: string;
-      specifiers: string[];
-      rawText: string;
-    }
-  | {
-      kind: 'importRemove';
-      fileId: string;
-      source: string;
-    }
-  | {
-      kind: 'importModify';
-      fileId: string;
-      source: string;
-      oldSpecifiers: string[];
-      newSpecifiers: string[];
-    }
-  | {
-      kind: 'exportAdd';
-      fileId: string;
-      name: string;
-      rawText: string;
-    }
-  | {
-      kind: 'exportRemove';
-      fileId: string;
-      name: string;
-    };
-
-// ---------------------------------------------------------------------------
-// Semantic Merge Conflict
-// ---------------------------------------------------------------------------
-
-export interface SemanticMergeConflict {
-  entityId: string;
-  entityName: string;
-  entityKind: string;
-  filePath: string;
-  ours: SemanticPatch;
-  theirs: SemanticPatch;
-  suggestion?: 'accept-ours' | 'accept-theirs' | 'combine';
-}
-
-export interface SemanticMergeResult {
-  clean: boolean;
-  patches: SemanticPatch[];
-  conflicts: SemanticMergeConflict[];
-}

package/src/sync/http-transport.ts

@@ -1,144 +0,0 @@
-/**
- * HTTP Sync Transport
- *
- * Implements SyncTransport over HTTP for network-based peer sync.
- * Uses a simple JSON REST protocol:
- *   POST /sync/message — send a sync message
- *   GET  /sync/peers   — list connected peers
- *
- * The server side is a lightweight Bun HTTP server.
- * The client side uses fetch() for outbound messages.
- *
- * @module trellis/sync
- */
-
-import type { SyncTransport, SyncMessage, PeerId } from './types.js';
-
-// ---------------------------------------------------------------------------
-// HTTP Transport (Client)
-// ---------------------------------------------------------------------------
-
-export class HttpSyncTransport implements SyncTransport {
-  private localPeerId: string;
-  private peerUrls: Map<string, string> = new Map();
-  private messageHandler: ((msg: SyncMessage) => void) | null = null;
-  private knownPeers: Map<string, PeerId> = new Map();
-
-  constructor(localPeerId: string) {
-    this.localPeerId = localPeerId;
-  }
-
-  /**
-   * Add a remote peer by URL (e.g. "http://192.168.1.10:4200").
-   */
-  addPeer(peerId: string, url: string, name?: string): void {
-    this.peerUrls.set(peerId, url);
-    this.knownPeers.set(peerId, {
-      id: peerId,
-      name: name ?? peerId,
-      lastSeen: new Date().toISOString(),
-    });
-  }
-
-  /**
-   * Remove a remote peer.
-   */
-  removePeer(peerId: string): void {
-    this.peerUrls.delete(peerId);
-    this.knownPeers.delete(peerId);
-  }
-
-  async send(peerId: string, message: SyncMessage): Promise<void> {
-    const url = this.peerUrls.get(peerId);
-    if (!url) throw new Error(`Unknown peer "${peerId}". Add it with addPeer() first.`);
-
-    const resp = await fetch(`${url}/sync/message`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(message),
-    });
-
-    if (!resp.ok) {
-      throw new Error(`Sync message to ${peerId} failed: ${resp.status} ${resp.statusText}`);
-    }
-
-    // Check if the response contains a reply message
-    const contentType = resp.headers.get('content-type');
-    if (contentType?.includes('application/json')) {
-      const reply = await resp.json();
-      if (reply && reply.type && this.messageHandler) {
-        this.messageHandler(reply as SyncMessage);
-      }
-    }
-  }
-
-  onMessage(handler: (message: SyncMessage) => void): void {
-    this.messageHandler = handler;
-  }
-
-  /**
-   * Receive a message (called by the HTTP server handler).
-   */
-  receiveMessage(message: SyncMessage): void {
-    // Track peer
-    this.knownPeers.set(message.peerId, {
-      id: message.peerId,
-      name: message.peerId,
-      lastSeen: new Date().toISOString(),
-    });
-
-    if (this.messageHandler) {
-      this.messageHandler(message);
-    }
-  }
-
-  peers(): PeerId[] {
-    return [...this.knownPeers.values()];
-  }
-
-  getLocalPeerId(): string {
-    return this.localPeerId;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// HTTP Sync Server (creates Bun.serve handler)
-// ---------------------------------------------------------------------------
-
-export interface HttpSyncServerConfig {
-  port: number;
-  transport: HttpSyncTransport;
-}
-
-/**
- * Create a Bun-compatible HTTP request handler for sync messages.
- * Can be used with Bun.serve() or as middleware.
- */
-export function createSyncHandler(transport: HttpSyncTransport): (req: Request) => Response | null {
-  return (req: Request): Response | null => {
-    const url = new URL(req.url);
-
-    if (url.pathname === '/sync/message' && req.method === 'POST') {
-      // Handle async parsing synchronously for Bun
-      return new Response(
-        req.json().then((body: any) => {
-          transport.receiveMessage(body as SyncMessage);
-          return JSON.stringify({ ok: true });
-        }) as any,
-        { headers: { 'Content-Type': 'application/json' } },
-      );
-    }
-
-    if (url.pathname === '/sync/peers' && req.method === 'GET') {
-      return new Response(
-        JSON.stringify({
-          localPeerId: transport.getLocalPeerId(),
-          peers: transport.peers(),
-        }),
-        { headers: { 'Content-Type': 'application/json' } },
-      );
-    }
-
-    return null; // Not a sync route
-  };
-}

package/src/sync/index.ts

@@ -1,43 +0,0 @@
-/**
- * Sync Module — Public Surface
- *
- * @module sync
- *
- * Re-exports the CRDT {@link reconcile|reconciler}, {@link SyncEngine} for
- * the have→want→ops→ack protocol, and {@link MemoryTransport} for testing.
- * Branch policies control whether sync uses linear (fast-forward) or
- * CRDT (concurrent append) mode.
- *
- * @see DESIGN.md §3.5 for the branch concurrency model.
- */
-
-export type {
-  PeerId,
-  SyncMessage,
-  SyncHaveMessage,
-  SyncWantMessage,
-  SyncOpsMessage,
-  SyncAckMessage,
-  SyncState,
-  BranchPolicy,
-  SyncTransport,
-} from './types.js';
-
-export { reconcile, findForkPoint } from './reconciler.js';
-
-export type { ReconcileResult, ReconcileConflict } from './reconciler.js';
-
-export { SyncEngine } from './sync-engine.js';
-
-export { MemoryTransport } from './memory-transport.js';
-
-export { HttpSyncTransport, createSyncHandler } from './http-transport.js';
-
-export { WebSocketSyncTransport } from './ws-transport.js';
-
-export {
-  MultiRepoManager,
-  parseCrossRepoRef,
-  formatCrossRepoRef,
-} from './multi-repo.js';
-export type { LinkedRepo, CrossRepoRef } from './multi-repo.js';

package/src/sync/memory-transport.ts

@@ -1,66 +0,0 @@
-/**
- * In-Memory Sync Transport
- *
- * A simple in-memory transport for testing and local multi-engine sync.
- * Messages are delivered synchronously between connected peers.
- */
-
-import type { SyncTransport, SyncMessage, PeerId } from './types.js';
-
-// ---------------------------------------------------------------------------
-// In-memory transport
-// ---------------------------------------------------------------------------
-
-export class MemoryTransport implements SyncTransport {
-  private peerId: string;
-  private peerName: string;
-  private handlers: ((message: SyncMessage) => void)[] = [];
-  private connectedPeers: Map<string, MemoryTransport> = new Map();
-
-  constructor(peerId: string, peerName: string = peerId) {
-    this.peerId = peerId;
-    this.peerName = peerName;
-  }
-
-  /**
-   * Connect two transports so they can exchange messages.
-   */
-  static connect(a: MemoryTransport, b: MemoryTransport): void {
-    a.connectedPeers.set(b.peerId, b);
-    b.connectedPeers.set(a.peerId, a);
-  }
-
-  /**
-   * Disconnect two transports.
-   */
-  static disconnect(a: MemoryTransport, b: MemoryTransport): void {
-    a.connectedPeers.delete(b.peerId);
-    b.connectedPeers.delete(a.peerId);
-  }
-
-  async send(peerId: string, message: SyncMessage): Promise<void> {
-    const peer = this.connectedPeers.get(peerId);
-    if (!peer) {
-      throw new Error(`Peer not connected: ${peerId}`);
-    }
-    // Deliver to peer's handlers
-    for (const handler of peer.handlers) {
-      handler(message);
-    }
-  }
-
-  onMessage(handler: (message: SyncMessage) => void): void {
-    this.handlers.push(handler);
-  }
-
-  peers(): PeerId[] {
-    return [...this.connectedPeers.entries()].map(([id, transport]) => ({
-      id,
-      name: transport.peerName,
-    }));
-  }
-
-  getPeerId(): string {
-    return this.peerId;
-  }
-}

package/src/sync/multi-repo.ts

@@ -1,200 +0,0 @@
-/**
- * Multi-Repo Linking — Cross-repo entity references.
- *
- * Enables entities in one Trellis repo to reference entities in another.
- * Linked repos are registered with a local alias and remote path/URL.
- * Cross-repo references use the format: `@alias:entityId`
- *
- * @module trellis/sync
- */
-
-import type { TrellisKernel } from '../core/kernel/trellis-kernel.js';
-import type { Fact, Link } from '../core/store/eav-store.js';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface LinkedRepo {
-  /** Local alias for the remote repo (e.g. "backend", "shared-lib"). */
-  alias: string;
-  /** Path or URL to the remote repo. */
-  location: string;
-  /** Optional human-readable description. */
-  description?: string;
-  /** When this link was established. */
-  linkedAt: string;
-  /** Last sync timestamp. */
-  lastSyncedAt?: string;
-}
-
-export interface CrossRepoRef {
-  /** The repo alias. */
-  repoAlias: string;
-  /** The entity ID in the remote repo. */
-  entityId: string;
-}
-
-// ---------------------------------------------------------------------------
-// Multi-Repo Manager
-// ---------------------------------------------------------------------------
-
-export class MultiRepoManager {
-  private kernel: TrellisKernel;
-
-  constructor(kernel: TrellisKernel) {
-    this.kernel = kernel;
-  }
-
-  /**
-   * Link a remote repository.
-   */
-  async linkRepo(alias: string, location: string, description?: string): Promise<void> {
-    const id = `repo:${alias}`;
-    const existing = this.kernel.getEntity(id);
-    if (existing) {
-      throw new Error(`Repo alias "${alias}" is already linked to "${existing.facts.find(f => f.a === 'location')?.v}".`);
-    }
-
-    await this.kernel.createEntity(id, 'LinkedRepo', {
-      alias,
-      location,
-      ...(description ? { description } : {}),
-      linkedAt: new Date().toISOString(),
-    });
-  }
-
-  /**
-   * Unlink a remote repository.
-   */
-  async unlinkRepo(alias: string): Promise<void> {
-    const id = `repo:${alias}`;
-    await this.kernel.deleteEntity(id);
-  }
-
-  /**
-   * List all linked repos.
-   */
-  listLinkedRepos(): LinkedRepo[] {
-    const entities = this.kernel.listEntities('LinkedRepo');
-    return entities.map((e) => {
-      const get = (a: string) => e.facts.find((f) => f.a === a)?.v;
-      return {
-        alias: String(get('alias') ?? ''),
-        location: String(get('location') ?? ''),
-        description: get('description') as string | undefined,
-        linkedAt: String(get('linkedAt') ?? ''),
-        lastSyncedAt: get('lastSyncedAt') as string | undefined,
-      };
-    });
-  }
-
-  /**
-   * Get a linked repo by alias.
-   */
-  getLinkedRepo(alias: string): LinkedRepo | null {
-    const entity = this.kernel.getEntity(`repo:${alias}`);
-    if (!entity) return null;
-    const get = (a: string) => entity.facts.find((f) => f.a === a)?.v;
-    return {
-      alias: String(get('alias') ?? ''),
-      location: String(get('location') ?? ''),
-      description: get('description') as string | undefined,
-      linkedAt: String(get('linkedAt') ?? ''),
-      lastSyncedAt: get('lastSyncedAt') as string | undefined,
-    };
-  }
-
-  /**
-   * Create a cross-repo link: entity in this repo → entity in remote repo.
-   */
-  async addCrossRepoLink(
-    sourceEntityId: string,
-    attribute: string,
-    targetRepoAlias: string,
-    targetEntityId: string,
-  ): Promise<void> {
-    const repo = this.getLinkedRepo(targetRepoAlias);
-    if (!repo) {
-      throw new Error(`Repo alias "${targetRepoAlias}" is not linked. Use linkRepo() first.`);
-    }
-
-    const crossRef = `@${targetRepoAlias}:${targetEntityId}`;
-    await this.kernel.addLink(sourceEntityId, attribute, crossRef);
-  }
-
-  /**
-   * Remove a cross-repo link.
-   */
-  async removeCrossRepoLink(
-    sourceEntityId: string,
-    attribute: string,
-    targetRepoAlias: string,
-    targetEntityId: string,
-  ): Promise<void> {
-    const crossRef = `@${targetRepoAlias}:${targetEntityId}`;
-    await this.kernel.removeLink(sourceEntityId, attribute, crossRef);
-  }
-
-  /**
-   * Find all cross-repo references from a given entity.
-   */
-  getCrossRepoLinks(entityId: string): Array<{ attribute: string; ref: CrossRepoRef }> {
-    const store = this.kernel.getStore();
-    const links = store.getLinksByEntity(entityId);
-    const results: Array<{ attribute: string; ref: CrossRepoRef }> = [];
-
-    for (const link of links) {
-      if (link.e1 !== entityId) continue;
-      const parsed = parseCrossRepoRef(link.e2);
-      if (parsed) {
-        results.push({ attribute: link.a, ref: parsed });
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Find all cross-repo references pointing to a specific remote entity.
-   */
-  findReferencesTo(repoAlias: string, entityId: string): Link[] {
-    const crossRef = `@${repoAlias}:${entityId}`;
-    const store = this.kernel.getStore();
-    return store.getAllLinks().filter((l) => l.e2 === crossRef);
-  }
-
-  /**
-   * Update the lastSyncedAt timestamp for a linked repo.
-   */
-  async markSynced(alias: string): Promise<void> {
-    await this.kernel.updateEntity(`repo:${alias}`, {
-      lastSyncedAt: new Date().toISOString(),
-    });
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Parse a cross-repo reference string.
- * Format: `@alias:entityId`
- */
-export function parseCrossRepoRef(ref: string): CrossRepoRef | null {
-  if (!ref.startsWith('@')) return null;
-  const colonIdx = ref.indexOf(':', 1);
-  if (colonIdx === -1) return null;
-  return {
-    repoAlias: ref.slice(1, colonIdx),
-    entityId: ref.slice(colonIdx + 1),
-  };
-}
-
-/**
- * Format a cross-repo reference string.
- */
-export function formatCrossRepoRef(repoAlias: string, entityId: string): string {
-  return `@${repoAlias}:${entityId}`;
-}