@zoebuildsai/trace 1.5.0

package/src/sync.ts

@@ -0,0 +1,205 @@
+/**
+ * Remote Sync Layer
+ * Handles push/pull with remote repositories
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+interface Remote {
+  name: string;
+  url: string;
+}
+
+export class TraceSync {
+  private repoDir: string;
+  private remoteConfigFile: string;
+
+  constructor(repoDir: string = process.cwd()) {
+    this.repoDir = repoDir;
+    this.remoteConfigFile = join(repoDir, '.trace', 'remotes.json');
+  }
+
+  /**
+   * Initialize git repo if needed
+   */
+  initRepo(): void {
+    try {
+      execSync('git rev-parse --git-dir', { cwd: this.repoDir, stdio: 'ignore' });
+    } catch {
+      execSync('git init', { cwd: this.repoDir });
+      execSync('git config user.email "trace@zoebuildsai.com"', { cwd: this.repoDir });
+      execSync('git config user.name "Trace"', { cwd: this.repoDir });
+    }
+  }
+
+  /**
+   * Add a remote repository
+   */
+  addRemote(name: string, url: string): void {
+    try {
+      execSync(`git remote add ${name} ${url}`, { cwd: this.repoDir });
+    } catch {
+      // Remote may already exist, update it
+      execSync(`git remote set-url ${name} ${url}`, { cwd: this.repoDir });
+    }
+    this.saveRemote(name, url);
+  }
+
+  /**
+   * List all remotes
+   */
+  listRemotes(): Remote[] {
+    try {
+      const output = execSync('git remote -v', { cwd: this.repoDir, encoding: 'utf-8' });
+      const remotes: Map<string, string> = new Map();
+      
+      for (const line of output.trim().split('\n')) {
+        if (!line) continue;
+        const [name, url] = line.split(/\s+/);
+        if (!remotes.has(name)) {
+          remotes.set(name, url);
+        }
+      }
+
+      const result: Remote[] = [];
+      for (const [name, url] of remotes) {
+        result.push({ name, url });
+      }
+      return result;
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Push to remote with timeout
+   */
+  push(remote: string = 'origin', timeout: number = 5000): { success: boolean; message: string } {
+    this.initRepo();
+
+    try {
+      const cmd = `git push ${remote} --all --tags`;
+      const timeoutSec = Math.ceil(timeout / 1000);
+      
+      try {
+        execSync(cmd, {
+          cwd: this.repoDir,
+          timeout: timeout,
+          stdio: 'pipe',
+        });
+        return { success: true, message: `Pushed to ${remote}` };
+      } catch (err: any) {
+        if (err.killed) {
+          // Timeout - return partial success
+          return {
+            success: false,
+            message: `Push timeout after ${timeoutSec}s (may have partially succeeded)`,
+          };
+        }
+        throw err;
+      }
+    } catch (err) {
+      return {
+        success: false,
+        message: `Push failed: ${(err as Error).message}`,
+      };
+    }
+  }
+
+  /**
+   * Pull from remote
+   */
+  pull(remote: string = 'origin'): { success: boolean; message: string } {
+    this.initRepo();
+
+    try {
+      execSync(`git pull ${remote} --all`, {
+        cwd: this.repoDir,
+        stdio: 'pipe',
+      });
+      return { success: true, message: `Pulled from ${remote}` };
+    } catch (err) {
+      return {
+        success: false,
+        message: `Pull failed: ${(err as Error).message}`,
+      };
+    }
+  }
+
+  /**
+   * Stage and commit changes
+   */
+  stageAndCommit(message: string): { success: boolean; hash: string } {
+    this.initRepo();
+
+    try {
+      execSync('git add -A', { cwd: this.repoDir });
+      const output = execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, {
+        cwd: this.repoDir,
+        encoding: 'utf-8',
+      });
+
+      // Extract hash from output like "[main abc1234] message"
+      const match = output.match(/\[.*?\s+(\w+)\]/);
+      const hash = match ? match[1] : 'unknown';
+
+      return { success: true, hash };
+    } catch (err: any) {
+      const errStr = err.message || err.toString();
+      if (errStr.includes('nothing to commit') || errStr.includes('nothing added to commit')) {
+        return { success: true, hash: 'none' };
+      }
+      return { success: false, hash: '' };
+    }
+  }
+
+  /**
+   * Commit with optional auto-push
+   */
+  commitWithAutoPush(
+    message: string,
+    autoPush: boolean = false,
+    remote: string = 'origin'
+  ): { success: boolean; hash: string; pushed?: boolean } {
+    const commitResult = this.stageAndCommit(message);
+
+    if (!commitResult.success) {
+      return { success: false, hash: '' };
+    }
+
+    if (autoPush && commitResult.hash !== 'none') {
+      const pushResult = this.push(remote, 5000);
+      return {
+        success: true,
+        hash: commitResult.hash,
+        pushed: pushResult.success,
+      };
+    }
+
+    return { success: true, hash: commitResult.hash };
+  }
+
+  /**
+   * Save remote config locally
+   */
+  private saveRemote(name: string, url: string): void {
+    const dir = join(this.repoDir, '.trace');
+    if (!existsSync(dir)) {
+      execSync(`mkdir -p ${dir}`);
+    }
+
+    let remotes: Record<string, string> = {};
+    if (existsSync(this.remoteConfigFile)) {
+      try {
+        remotes = JSON.parse(readFileSync(this.remoteConfigFile, 'utf-8'));
+      } catch {
+        remotes = {};
+      }
+    }
+
+    remotes[name] = url;
+    writeFileSync(this.remoteConfigFile, JSON.stringify(remotes, null, 2));
+  }
+}

package/src/tags.ts

@@ -0,0 +1,244 @@
+/**
+ * Tags Feature
+ * 
+ * Create, list, delete, and checkout to semantic tags.
+ * - Store tags in refs/tags/
+ * - Tag metadata (created_at, description, creator)
+ * - Fast tag index for <50ms lookups
+ * - Unicode and special character support
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { TraceCommands } from './commands';
+
+export interface Tag {
+  name: string;
+  commit_hash: string;
+  created_at: number;
+  metadata?: Record<string, any>;
+}
+
+export interface TagListOptions {
+  sortBy?: 'created_at' | 'name';
+  pattern?: string;
+}
+
+export interface TagCreateOptions {
+  description?: string;
+  creator?: string;
+  force?: boolean;
+  [key: string]: any;
+}
+
+export interface TagCheckoutOptions {
+  force?: boolean;
+}
+
+export class TagManager {
+  private commands: TraceCommands;
+  private tagsDir: string;
+  private tagIndex: Map<string, Tag> = new Map();
+  private indexValid: boolean = false;
+
+  constructor(commands: TraceCommands, basePath?: string) {
+    this.commands = commands;
+    
+    // Derive tags directory from memory-git base path
+    const baseDir = basePath || path.join(process.env.HOME || '', '.openclaw/memory-git');
+    this.tagsDir = path.join(baseDir, 'refs', 'tags');
+
+    this.ensureTagsDir();
+    this.rebuildIndex();
+  }
+
+  /**
+   * Create a new tag at current HEAD
+   */
+  create(name: string, options: TagCreateOptions = {}): Tag {
+    this.validateTagName(name);
+
+    // Check if tag exists
+    if (this.tagIndex.has(name) && !options.force) {
+      throw new Error(`Tag '${name}' already exists. Use force: true to override.`);
+    }
+
+    // Get current HEAD commit
+    const log = this.commands.log(1);
+    if (log.length === 0) {
+      throw new Error('No commits to tag');
+    }
+
+    const commitHash = log[0].hash;
+    const now = Date.now();
+
+    // Filter options to extract metadata (skip 'force')
+    const metaEntries = Object.entries(options)
+      .filter(([k]) => k !== 'force');
+    
+    const tag: Tag = {
+      name,
+      commit_hash: commitHash,
+      created_at: now,
+      metadata: metaEntries.length > 0 ? Object.fromEntries(metaEntries) : undefined,
+    };
+
+    // Save tag
+    this.saveTag(tag);
+
+    // Update index
+    this.tagIndex.set(name, tag);
+
+    return tag;
+  }
+
+  /**
+   * Get a tag by name
+   */
+  get(name: string): Tag | undefined {
+    this.ensureIndexValid();
+    return this.tagIndex.get(name);
+  }
+
+  /**
+   * List all tags
+   */
+  list(options: TagListOptions = {}): Tag[] {
+    this.ensureIndexValid();
+
+    let tags = Array.from(this.tagIndex.values());
+
+    // Filter by pattern if provided
+    if (options.pattern) {
+      const regex = this.patternToRegex(options.pattern);
+      tags = tags.filter(t => regex.test(t.name));
+    }
+
+    // Sort
+    if (options.sortBy === 'name') {
+      tags.sort((a, b) => a.name.localeCompare(b.name));
+    } else {
+      tags.sort((a, b) => a.created_at - b.created_at);
+    }
+
+    return tags;
+  }
+
+  /**
+   * Delete a tag
+   */
+  delete(name: string): void {
+    if (!this.tagIndex.has(name)) {
+      throw new Error(`Tag '${name}' not found`);
+    }
+
+    const tagPath = this.getTagPath(name);
+    fs.unlinkSync(tagPath);
+
+    this.tagIndex.delete(name);
+  }
+
+  /**
+   * Checkout to a tagged commit
+   */
+  checkout(name: string, options: TagCheckoutOptions = {}): boolean {
+    const tag = this.get(name);
+    if (!tag) {
+      throw new Error(`Tag '${name}' not found`);
+    }
+
+    // Checkout to the commit
+    this.commands.checkout(tag.commit_hash, { force: options.force });
+
+    return true;
+  }
+
+  /**
+   * Rebuild the tag index
+   */
+  rebuildIndex(): void {
+    this.tagIndex.clear();
+
+    if (!fs.existsSync(this.tagsDir)) {
+      this.indexValid = true;
+      return;
+    }
+
+    const files = fs.readdirSync(this.tagsDir);
+    for (const file of files) {
+      try {
+        const tagPath = path.join(this.tagsDir, file);
+        const content = fs.readFileSync(tagPath, 'utf-8');
+        const tag = JSON.parse(content) as Tag;
+        this.tagIndex.set(tag.name, tag);
+      } catch (err) {
+        // Skip corrupt tag files
+        console.warn(`Failed to load tag ${file}:`, err);
+      }
+    }
+
+    this.indexValid = true;
+  }
+
+  /**
+   * Private: Ensure index is valid
+   */
+  private ensureIndexValid(): void {
+    if (!this.indexValid) {
+      this.rebuildIndex();
+    }
+  }
+
+  /**
+   * Private: Validate tag name
+   */
+  private validateTagName(name: string): void {
+    if (!name || name.trim().length === 0) {
+      throw new Error('Tag name cannot be empty');
+    }
+
+    if (name.includes(' ')) {
+      throw new Error('Tag name cannot contain spaces');
+    }
+  }
+
+  /**
+   * Private: Ensure tags directory exists
+   */
+  private ensureTagsDir(): void {
+    if (!fs.existsSync(this.tagsDir)) {
+      fs.mkdirSync(this.tagsDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Private: Get tag file path
+   */
+  private getTagPath(name: string): string {
+    // Escape special characters for filesystem
+    const escaped = name.replace(/[\/\\:?*"<>|]/g, '_');
+    return path.join(this.tagsDir, escaped);
+  }
+
+  /**
+   * Private: Save tag to disk
+   */
+  private saveTag(tag: Tag): void {
+    const tagPath = this.getTagPath(tag.name);
+    const content = JSON.stringify(tag, null, 2);
+    fs.writeFileSync(tagPath, content, 'utf-8');
+  }
+
+  /**
+   * Private: Convert glob pattern to regex
+   */
+  private patternToRegex(pattern: string): RegExp {
+    const escaped = pattern
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+      .replace(/\*/g, '.*')
+      .replace(/\?/g, '.');
+
+    return new RegExp(`^${escaped}$`);
+  }
+}

package/src/types.ts

@@ -0,0 +1,119 @@
+/**
+ * Core types for Memory Git system
+ */
+
+export interface CommitObject {
+  hash: string;
+  message: string;
+  timestamp: number;
+  author: string;
+  parent: string | null;
+  tree: TreeObject;
+  metadata?: Record<string, unknown>;
+}
+
+export interface TreeObject {
+  files: Map<string, FileEntry>;
+  hash: string;
+}
+
+export interface FileEntry {
+  path: string;
+  hash: string;
+  size: number;
+  mode: 'file' | 'deleted';
+  lastModified: number;
+}
+
+export interface DiffResult {
+  added: Map<string, string>;
+  modified: Map<string, DiffChange>;
+  deleted: Map<string, string>;
+  stats: DiffStats;
+}
+
+export interface DiffChange {
+  oldHash: string;
+  newHash: string;
+  lines?: LineDiff[];
+}
+
+export interface LineDiff {
+  type: 'add' | 'remove' | 'context';
+  content: string;
+  lineNum?: number;
+}
+
+export interface DiffStats {
+  filesChanged: number;
+  linesAdded: number;
+  linesRemoved: number;
+  totalChanges: number;
+}
+
+export interface StatusResult {
+  modified: string[];
+  added: string[];
+  deleted: string[];
+  untracked: string[];
+  clean: boolean;
+}
+
+export interface LogEntry {
+  hash: string;
+  message: string;
+  timestamp: number;
+  author: string;
+  shortHash: string;
+}
+
+export interface CommitOptions {
+  message: string;
+  author?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface CheckoutOptions {
+  force?: boolean;
+  specific?: string[];
+}
+
+export interface DiffOptions {
+  lines?: boolean;
+  context?: number;
+  maxSize?: number;
+}
+
+export interface IndexCache {
+  timestamp: number;
+  files: Map<string, CachedFile>;
+  currentCommit: string;
+}
+
+export interface CachedFile {
+  path: string;
+  hash: string;
+  lastSeen: number;
+  modified: boolean;
+}
+
+// Phase 2 Types
+export interface AutoCommitMetadata {
+  auto: boolean;
+  filesChanged: number;
+  files?: string[];
+  timestamp: number;
+}
+
+export interface TagInfo {
+  name: string;
+  commit_hash: string;
+  created_at: number;
+  description?: string;
+}
+
+export interface BranchInfo {
+  name: string;
+  head: string;
+  created_at: number;
+}

package/src/webhooks.ts

@@ -0,0 +1,119 @@
+/**
+ * Webhook Manager for Trace
+ * Safe, validated webhook delivery with retry logic
+ */
+
+export interface WebhookPayload {
+  operationId: string;
+  type: 'commit' | 'push' | 'pull';
+  status: 'completed' | 'failed';
+  timestamp: number;
+  error?: string;
+}
+
+export class WebhookManager {
+  /**
+   * Validate webhook URL for security
+   */
+  static validateUrl(url: string): { valid: boolean; reason?: string } {
+    try {
+      const parsed = new URL(url);
+
+      // Only HTTPS allowed
+      if (parsed.protocol !== 'https:') {
+        return { valid: false, reason: 'Only HTTPS URLs allowed' };
+      }
+
+      // Block localhost/private IPs
+      if (this.isPrivateIP(parsed.hostname)) {
+        return { valid: false, reason: 'Private/localhost URLs not allowed' };
+      }
+
+      // URL must be reasonable length (prevent DoS)
+      if (url.length > 2000) {
+        return { valid: false, reason: 'URL too long' };
+      }
+
+      return { valid: true };
+    } catch (err) {
+      return { valid: false, reason: 'Invalid URL format' };
+    }
+  }
+
+  /**
+   * Check if hostname is private/local
+   */
+  private static isPrivateIP(hostname: string): boolean {
+    const privatePatterns = [
+      /^localhost$/,
+      /^127\./,
+      /^192\.168\./,
+      /^10\./,
+      /^172\.(1[6-9]|2[0-9]|3[01])\./,
+      /^::1$/,
+      /^fc00:/,
+      /^fe80:/,
+    ];
+
+    return privatePatterns.some(pattern => pattern.test(hostname));
+  }
+
+  /**
+   * Sanitize payload for webhook delivery
+   */
+  static sanitizePayload(payload: Record<string, unknown>): WebhookPayload {
+    // Only include safe fields
+    return {
+      operationId: String(payload.operationId || ''),
+      type: payload.type as 'commit' | 'push' | 'pull',
+      status: payload.status as 'completed' | 'failed',
+      timestamp: Number(payload.timestamp || Date.now()),
+      error: payload.error ? String(payload.error).slice(0, 500) : undefined,
+    };
+  }
+
+  /**
+   * Send webhook with retry
+   */
+  static async send(
+    url: string,
+    payload: WebhookPayload,
+    maxRetries: number = 3
+  ): Promise<void> {
+    // Validate URL first
+    const validation = this.validateUrl(url);
+    if (!validation.valid) {
+      throw new Error(`Invalid webhook URL: ${validation.reason}`);
+    }
+
+    // Sanitize payload
+    const safePayload = this.sanitizePayload(payload);
+
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        // TODO: Replace with actual fetch in implementation
+        // await fetch(url, {
+        //   method: 'POST',
+        //   headers: { 'Content-Type': 'application/json' },
+        //   body: JSON.stringify(safePayload),
+        //   timeout: 10000,
+        // });
+        return;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+
+        // Exponential backoff
+        if (attempt < maxRetries - 1) {
+          const delay = Math.pow(2, attempt) * 1000 + Math.random() * 1000;
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+      }
+    }
+
+    throw lastError || new Error('Failed to send webhook');
+  }
+}
+
+export default WebhookManager;