trellis 1.0.8 → 2.0.6

package/src/git/git-exporter.ts

@@ -0,0 +1,286 @@
+/**
+ * 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

@@ -0,0 +1,329 @@
+/**
+ * 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}`;
+  }
+}