trellis 2.0.13 → 2.1.2

package/src/git/git-exporter.ts

@@ -1,286 +0,0 @@
-/**
- * Git Exporter
- *
- * Serializes TrellisVCS milestones back to Git commits.
- * Each milestone becomes a Git commit with:
- *   - The milestone message as the commit message
- *   - File states reconstructed from the blob store
- *   - Author info from the milestone's createdBy identity
- *
- * The exporter creates a new Git repo (or uses an existing one)
- * and leaves the TrellisVCS repo untouched.
- */
-
-import { execSync } from 'child_process';
-import { existsSync, mkdirSync, writeFileSync, unlinkSync } from 'fs';
-import { join, dirname } from 'path';
-import { TrellisVcsEngine } from '../engine.js';
-import { BlobStore } from '../vcs/blob-store.js';
-import type { VcsOp } from '../vcs/types.js';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface ExportOptions {
-  /** Path to the TrellisVCS repository to export from. */
-  from: string;
-
-  /** Path to the target Git repository. */
-  to: string;
-
-  /** Author name for commits (default: "TrellisVCS Export"). */
-  authorName?: string;
-
-  /** Author email for commits (default: "export@trellis.dev"). */
-  authorEmail?: string;
-
-  /** Callback for progress reporting. */
-  onProgress?: (progress: ExportProgress) => void;
-}
-
-export interface ExportProgress {
-  phase: 'preparing' | 'exporting' | 'done';
-  current: number;
-  total: number;
-  message: string;
-}
-
-export interface ExportResult {
-  milestonesExported: number;
-  commitsCreated: number;
-  duration: number;
-}
-
-// ---------------------------------------------------------------------------
-// Exporter
-// ---------------------------------------------------------------------------
-
-export async function exportToGit(opts: ExportOptions): Promise<ExportResult> {
-  const startTime = Date.now();
-
-  // Open the TrellisVCS repo
-  const engine = new TrellisVcsEngine({ rootPath: opts.from });
-  engine.open();
-
-  const blobStore = engine.getBlobStore();
-  if (!blobStore) {
-    throw new Error('Blob store not available. Re-open the repo first.');
-  }
-
-  // Get all milestones and ops
-  const milestones = engine.listMilestones();
-  const allOps = engine.getOps();
-
-  opts.onProgress?.({
-    phase: 'preparing',
-    current: 0,
-    total: milestones.length,
-    message: `Found ${milestones.length} milestones to export`,
-  });
-
-  if (milestones.length === 0) {
-    return {
-      milestonesExported: 0,
-      commitsCreated: 0,
-      duration: Date.now() - startTime,
-    };
-  }
-
-  // Initialize target Git repo
-  if (!existsSync(opts.to)) {
-    mkdirSync(opts.to, { recursive: true });
-  }
-
-  const isGitRepo = existsSync(join(opts.to, '.git'));
-  if (!isGitRepo) {
-    git(opts.to, 'init');
-    git(
-      opts.to,
-      `config user.email "${opts.authorEmail ?? 'export@trellis.dev'}"`,
-    );
-    git(
-      opts.to,
-      `config user.name "${opts.authorName ?? 'TrellisVCS Export'}"`,
-    );
-  }
-
-  let commitsCreated = 0;
-
-  // Build a milestone-ordered export by walking the op stream sequentially.
-  // Each milestone op marks a commit boundary. Ops between milestones are
-  // applied to the working directory, then committed with the milestone's
-  // message. This works regardless of whether milestones have
-  // fromOpHash/toOpHash (imported milestones often don't).
-
-  // Build milestone lookup: milestoneId → milestone metadata
-  const milestoneMap = new Map(milestones.map((m) => [m.id, m]));
-
-  // Cumulative file state tracker
-  const fileStates = new Map<string, FileState>();
-  let pendingChanges = false;
-  let milestoneIdx = 0;
-
-  for (const op of allOps) {
-    // Track file changes
-    if (op.vcs?.filePath) {
-      switch (op.kind) {
-        case 'vcs:fileAdd':
-        case 'vcs:fileModify':
-          fileStates.set(op.vcs.filePath, { contentHash: op.vcs.contentHash });
-          pendingChanges = true;
-          break;
-        case 'vcs:fileDelete':
-          fileStates.set(op.vcs.filePath, { deleted: true });
-          pendingChanges = true;
-          break;
-        case 'vcs:fileRename':
-          if (op.vcs.oldFilePath) {
-            fileStates.set(op.vcs.oldFilePath, { deleted: true });
-          }
-          fileStates.set(op.vcs.filePath, { contentHash: op.vcs.contentHash });
-          pendingChanges = true;
-          break;
-      }
-    }
-
-    // Check if this op is a milestone boundary
-    if (op.kind !== 'vcs:milestoneCreate') continue;
-
-    const milestoneId = op.vcs?.milestoneId;
-    const milestone = milestoneId ? milestoneMap.get(milestoneId) : undefined;
-    milestoneIdx++;
-
-    opts.onProgress?.({
-      phase: 'exporting',
-      current: milestoneIdx,
-      total: milestones.length,
-      message: `Exporting milestone ${milestoneIdx}/${milestones.length}: ${(op.vcs?.message ?? '').slice(0, 60)}`,
-    });
-
-    // Write current file state snapshot to the git working directory
-    for (const [filePath, state] of fileStates.entries()) {
-      const absPath = join(opts.to, filePath);
-
-      if (state.deleted) {
-        if (existsSync(absPath)) {
-          unlinkSync(absPath);
-        }
-      } else if (state.contentHash && blobStore) {
-        const content = blobStore.get(state.contentHash);
-        if (content) {
-          const dir = dirname(absPath);
-          if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-          }
-          writeFileSync(absPath, content);
-        }
-      }
-    }
-
-    // Stage all changes
-    git(opts.to, 'add -A');
-
-    // Check if there are changes to commit
-    const status = git(opts.to, 'status --porcelain');
-    if (status.trim().length === 0 && commitsCreated > 0) {
-      continue;
-    }
-
-    // Extract author info
-    const authorName =
-      opts.authorName ?? extractAuthorName(milestone?.createdBy ?? op.agentId);
-    const authorEmail =
-      opts.authorEmail ??
-      extractAuthorEmail(milestone?.createdBy ?? op.agentId);
-    const message =
-      op.vcs?.message ?? milestone?.message ?? `Milestone ${milestoneId}`;
-    const date =
-      milestone?.createdAt ?? op.timestamp ?? new Date().toISOString();
-
-    try {
-      gitWithEnv(
-        opts.to,
-        `commit --allow-empty --author="${authorName} <${authorEmail}>" -m "${escapeMessage(message)}"`,
-        {
-          GIT_AUTHOR_DATE: date,
-          GIT_COMMITTER_DATE: date,
-        },
-      );
-      commitsCreated++;
-      pendingChanges = false;
-    } catch {
-      // If commit fails, skip
-    }
-  }
-
-  opts.onProgress?.({
-    phase: 'done',
-    current: milestones.length,
-    total: milestones.length,
-    message: `Exported ${commitsCreated} commits from ${milestones.length} milestones`,
-  });
-
-  return {
-    milestonesExported: milestones.length,
-    commitsCreated,
-    duration: Date.now() - startTime,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function git(repoPath: string, command: string): string {
-  try {
-    return execSync(`git -C "${repoPath}" ${command}`, {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-  } catch (err: any) {
-    if (err.stdout) return err.stdout;
-    throw err;
-  }
-}
-
-function gitWithEnv(
-  repoPath: string,
-  command: string,
-  extraEnv: Record<string, string>,
-): string {
-  return execSync(`git -C "${repoPath}" ${command}`, {
-    encoding: 'utf-8',
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env: { ...process.env, ...extraEnv },
-  });
-}
-
-function escapeMessage(msg: string): string {
-  return msg.replace(/"/g, '\\"').replace(/\n/g, '\\n');
-}
-
-function extractAuthorName(createdBy?: string): string {
-  if (!createdBy) return 'TrellisVCS Export';
-  // createdBy is typically "identity:alice@example.com" or "identity:alice"
-  const id = createdBy.replace('identity:', '');
-  // If it looks like an email, extract the name part
-  if (id.includes('@')) {
-    return id.split('@')[0];
-  }
-  return id;
-}
-
-function extractAuthorEmail(createdBy?: string): string {
-  if (!createdBy) return 'export@trellis.dev';
-  const id = createdBy.replace('identity:', '');
-  if (id.includes('@')) {
-    return id;
-  }
-  return `${id}@trellis.dev`;
-}
-
-interface FileState {
-  contentHash?: string;
-  deleted?: boolean;
-}

package/src/git/git-importer.ts

@@ -1,329 +0,0 @@
-/**
- * Git Importer
- *
- * Converts a Git repository's commit history into TrellisVCS operations.
- * Each Git commit becomes:
- *   1. A sequence of Tier 0 file-level ops (vcs:fileAdd, vcs:fileModify, etc.)
- *   2. A vcs:milestoneCreate op (commit message → milestone)
- *
- * The importer reads from the Git repo, writes into a TrellisVCS engine,
- * and leaves the original Git repo untouched.
- */
-
-import {
-  GitReader,
-  type GitCommitWithChanges,
-  type GitFileChange,
-} from './git-reader.js';
-import { TrellisVcsEngine } from '../engine.js';
-import { createVcsOp } from '../vcs/ops.js';
-import type { VcsOp, VcsOpKind } from '../vcs/types.js';
-import { existsSync, mkdirSync, readFileSync } from 'fs';
-import { join, dirname } from 'path';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface ImportOptions {
-  /** Path to the source Git repository. */
-  from: string;
-
-  /** Path to the target TrellisVCS repository (defaults to cwd). */
-  to: string;
-
-  /** Agent ID for the import. Defaults to Git author info. */
-  agentId?: string;
-
-  /** Callback for progress reporting. */
-  onProgress?: (progress: ImportProgress) => void;
-}
-
-export interface ImportProgress {
-  phase: 'reading' | 'importing' | 'done';
-  current: number;
-  total: number;
-  message: string;
-}
-
-export interface ImportResult {
-  commitsImported: number;
-  opsCreated: number;
-  filesTracked: number;
-  branches: string[];
-  duration: number;
-}
-
-// ---------------------------------------------------------------------------
-// Importer
-// ---------------------------------------------------------------------------
-
-export async function importFromGit(
-  opts: ImportOptions,
-): Promise<ImportResult> {
-  const startTime = Date.now();
-  const gitReader = new GitReader(opts.from);
-
-  if (!gitReader.isGitRepo()) {
-    throw new Error(`Not a Git repository: ${opts.from}`);
-  }
-
-  // --- Phase 1: Read Git history ---
-  opts.onProgress?.({
-    phase: 'reading',
-    current: 0,
-    total: 0,
-    message: 'Reading Git history…',
-  });
-
-  const history = gitReader.readFullHistory();
-  const branches = gitReader.branches();
-  const defaultBranch = gitReader.currentBranch();
-
-  opts.onProgress?.({
-    phase: 'reading',
-    current: history.length,
-    total: history.length,
-    message: `Read ${history.length} commits`,
-  });
-
-  // --- Phase 2: Create TrellisVCS repo and import ---
-  const engine = new TrellisVcsEngine({
-    rootPath: opts.to,
-    agentId: opts.agentId ?? `git-import:${opts.from}`,
-    defaultBranch,
-  });
-
-  // Initialize the target repo (creates .trellis/ but skip file scan)
-  const trellisDir = join(opts.to, '.trellis');
-  if (!existsSync(trellisDir)) {
-    mkdirSync(trellisDir, { recursive: true });
-  }
-
-  // We need to manually initialize since we don't want the default file scan.
-  // Create branch op + import commits.
-  const importEngine = new ImportEngine(engine, opts);
-
-  await importEngine.createBranch(defaultBranch);
-
-  let opsCreated = 1; // branch op
-  const trackedFiles = new Set<string>();
-
-  for (let i = 0; i < history.length; i++) {
-    const commit = history[i];
-
-    opts.onProgress?.({
-      phase: 'importing',
-      current: i + 1,
-      total: history.length,
-      message: `Importing commit ${i + 1}/${history.length}: ${commit.message.slice(0, 60)}`,
-    });
-
-    // Convert each file change to a VcsOp
-    for (const change of commit.changes) {
-      const op = await importEngine.convertChange(change, commit);
-      opsCreated++;
-
-      if (
-        change.status === 'A' ||
-        change.status === 'M' ||
-        change.status === 'R'
-      ) {
-        trackedFiles.add(change.path);
-      }
-      if (change.status === 'D') {
-        trackedFiles.delete(change.path);
-      }
-      if (change.status === 'R' && change.oldPath) {
-        trackedFiles.delete(change.oldPath);
-      }
-    }
-
-    // Create a milestone for this commit
-    await importEngine.createMilestone(commit);
-    opsCreated++;
-  }
-
-  opts.onProgress?.({
-    phase: 'done',
-    current: history.length,
-    total: history.length,
-    message: `Imported ${history.length} commits → ${opsCreated} ops`,
-  });
-
-  return {
-    commitsImported: history.length,
-    opsCreated,
-    filesTracked: trackedFiles.size,
-    branches,
-    duration: Date.now() - startTime,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Internal Import Engine
-// ---------------------------------------------------------------------------
-
-class ImportEngine {
-  private engine: TrellisVcsEngine;
-  private opts: ImportOptions;
-  private lastOpHash: string | undefined;
-  private ops: VcsOp[] = [];
-
-  constructor(engine: TrellisVcsEngine, opts: ImportOptions) {
-    this.engine = engine;
-    this.opts = opts;
-  }
-
-  async createBranch(name: string): Promise<void> {
-    const op = await createVcsOp('vcs:branchCreate', {
-      agentId: this.agentId(),
-      previousHash: this.lastOpHash,
-      vcs: { branchName: name },
-    });
-    this.append(op);
-  }
-
-  async convertChange(
-    change: GitFileChange,
-    commit: GitCommitWithChanges,
-  ): Promise<VcsOp> {
-    const agentId = `identity:${commit.authorEmail}`;
-    let kind: VcsOpKind;
-
-    switch (change.status) {
-      case 'A':
-        kind = 'vcs:fileAdd';
-        break;
-      case 'M':
-        kind = 'vcs:fileModify';
-        break;
-      case 'D':
-        kind = 'vcs:fileDelete';
-        break;
-      case 'R':
-        kind = 'vcs:fileRename';
-        break;
-    }
-
-    // Hash the file content at this commit for content-addressability
-    let contentHash: string | undefined;
-    if (change.status !== 'D') {
-      contentHash = await this.hashFileAtCommit(commit.hash, change.path);
-    }
-
-    let oldContentHash: string | undefined;
-    if (change.status === 'M' && commit.parentHashes[0]) {
-      oldContentHash = await this.hashFileAtCommit(
-        commit.parentHashes[0],
-        change.path,
-      );
-    }
-
-    const op = await createVcsOp(kind, {
-      agentId,
-      previousHash: this.lastOpHash,
-      vcs: {
-        filePath: change.path,
-        oldFilePath: change.oldPath,
-        contentHash,
-        oldContentHash,
-      },
-    });
-
-    // Override timestamp to match Git commit time
-    (op as any).timestamp = commit.timestamp;
-
-    this.append(op);
-    return op;
-  }
-
-  async createMilestone(commit: GitCommitWithChanges): Promise<void> {
-    const agentId = `identity:${commit.authorEmail}`;
-    const milestoneId = `milestone:git:${commit.hash.slice(0, 12)}`;
-
-    const op = await createVcsOp('vcs:milestoneCreate', {
-      agentId,
-      previousHash: this.lastOpHash,
-      vcs: {
-        milestoneId,
-        message: commit.message,
-      },
-    });
-
-    // Override timestamp to match Git commit time
-    (op as any).timestamp = commit.timestamp;
-
-    this.append(op);
-  }
-
-  private append(op: VcsOp): void {
-    this.lastOpHash = op.hash;
-    this.ops.push(op);
-
-    // Write ops to the engine's op log
-    this.flushOps();
-  }
-
-  private flushOps(): void {
-    const opsPath = join(this.opts.to, '.trellis', 'ops.json');
-    const configPath = join(this.opts.to, '.trellis', 'config.json');
-    const trellisDir = join(this.opts.to, '.trellis');
-
-    if (!existsSync(trellisDir)) {
-      mkdirSync(trellisDir, { recursive: true });
-    }
-
-    // Write config if it doesn't exist
-    if (!existsSync(configPath)) {
-      const config = {
-        rootPath: this.opts.to,
-        ignorePatterns: [
-          'node_modules',
-          '.git',
-          '.trellis',
-          'dist',
-          'build',
-          '.DS_Store',
-          '*.log',
-        ],
-        debounceMs: 300,
-        defaultBranch: 'main',
-        agentId: this.agentId(),
-        createdAt: new Date().toISOString(),
-      };
-      const { writeFileSync } = require('fs');
-      writeFileSync(configPath, JSON.stringify(config, null, 2));
-    }
-
-    // Write full ops array
-    const { writeFileSync } = require('fs');
-    writeFileSync(opsPath, JSON.stringify(this.ops, null, 2));
-  }
-
-  private async hashFileAtCommit(
-    commitHash: string,
-    filePath: string,
-  ): Promise<string | undefined> {
-    try {
-      const reader = new GitReader(this.opts.from);
-      const content = reader.readFileContent(commitHash, filePath);
-      if (!content) {
-        return undefined;
-      }
-
-      const hashBuffer = await crypto.subtle.digest(
-        'SHA-256',
-        content as unknown as ArrayBuffer,
-      );
-      const hashArray = Array.from(new Uint8Array(hashBuffer));
-      return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
-    } catch {
-      return undefined;
-    }
-  }
-
-  private agentId(): string {
-    return this.opts.agentId ?? `git-import:${this.opts.from}`;
-  }
-}