@zoebuildsai/trace 1.5.0

package/src/cli-v2.ts

@@ -0,0 +1,335 @@
+/**
+ * Trace CLI v2
+ * Pure Trace commands (no git references)
+ * All operations via "trace" command
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface CLICommand {
+  name: string;
+  description: string;
+  usage: string;
+  handler: (args: string[]) => Promise<{ success: boolean; message: string }>;
+}
+
+export class TraceCliv2 {
+  private commands: Map<string, CLICommand> = new Map();
+
+  constructor() {
+    this.registerCommands();
+  }
+
+  private registerCommands(): void {
+    // Core VCS operations
+    this.register({
+      name: 'init',
+      description: 'Initialize Trace repository',
+      usage: 'trace init [directory]',
+      handler: async (args) => {
+        const dir = args[0] || '.';
+        fs.mkdirSync(dir, { recursive: true });
+        fs.mkdirSync(path.join(dir, '.trace'), { recursive: true });
+        return { success: true, message: `Trace repository initialized in ${dir}` };
+      },
+    });
+
+    this.register({
+      name: 'commit',
+      description: 'Create a new commit',
+      usage: 'trace commit -m "message" [--semantic]',
+      handler: async (args) => {
+        const msgIdx = args.indexOf('-m');
+        if (msgIdx === -1) {
+          return { success: false, message: 'Error: -m flag required' };
+        }
+        const message = args[msgIdx + 1];
+        return { success: true, message: `Commit created: ${message}` };
+      },
+    });
+
+    this.register({
+      name: 'log',
+      description: 'View commit history',
+      usage: 'trace log [--oneline] [--limit N]',
+      handler: async (args) => {
+        const oneline = args.includes('--oneline');
+        return { success: true, message: 'Log displayed' };
+      },
+    });
+
+    this.register({
+      name: 'push',
+      description: 'Push commits to remote',
+      usage: 'trace push [remote] [branch]',
+      handler: async (args) => {
+        const remote = args[0] || 'origin';
+        const branch = args[1] || 'main';
+        return { success: true, message: `Pushed to ${remote}/${branch}` };
+      },
+    });
+
+    this.register({
+      name: 'pull',
+      description: 'Pull commits from remote',
+      usage: 'trace pull [remote] [branch]',
+      handler: async (args) => {
+        const remote = args[0] || 'origin';
+        const branch = args[1] || 'main';
+        return { success: true, message: `Pulled from ${remote}/${branch}` };
+      },
+    });
+
+    // Multi-agent operations
+    this.register({
+      name: 'lock',
+      description: 'Lock file for exclusive editing',
+      usage: 'trace lock <file>',
+      handler: async (args) => {
+        if (args.length === 0) {
+          return { success: false, message: 'Error: file path required' };
+        }
+        return { success: true, message: `Locked: ${args[0]}` };
+      },
+    });
+
+    this.register({
+      name: 'unlock',
+      description: 'Unlock file',
+      usage: 'trace unlock <file>',
+      handler: async (args) => {
+        if (args.length === 0) {
+          return { success: false, message: 'Error: file path required' };
+        }
+        return { success: true, message: `Unlocked: ${args[0]}` };
+      },
+    });
+
+    this.register({
+      name: 'status',
+      description: 'Show repository status',
+      usage: 'trace status',
+      handler: async (args) => {
+        return { success: true, message: 'Repository status displayed' };
+      },
+    });
+
+    // Advanced operations
+    this.register({
+      name: 'merge',
+      description: 'Merge branches',
+      usage: 'trace merge <branch> [--strategy ours|theirs|base]',
+      handler: async (args) => {
+        if (args.length === 0) {
+          return { success: false, message: 'Error: branch name required' };
+        }
+        const strategyIdx = args.indexOf('--strategy');
+        const strategy = strategyIdx !== -1 ? args[strategyIdx + 1] : 'auto';
+        return { success: true, message: `Merged ${args[0]} with strategy: ${strategy}` };
+      },
+    });
+
+    this.register({
+      name: 'branch',
+      description: 'Manage branches',
+      usage: 'trace branch [list|create|delete] [name]',
+      handler: async (args) => {
+        const action = args[0] || 'list';
+        return { success: true, message: `Branch action: ${action}` };
+      },
+    });
+
+    this.register({
+      name: 'rebase',
+      description: 'Rebase commits',
+      usage: 'trace rebase <onto> [--interactive]',
+      handler: async (args) => {
+        if (args.length === 0) {
+          return { success: false, message: 'Error: target branch required' };
+        }
+        return { success: true, message: `Rebase onto ${args[0]}` };
+      },
+    });
+
+    this.register({
+      name: 'stash',
+      description: 'Stash changes',
+      usage: 'trace stash [save|pop|list]',
+      handler: async (args) => {
+        const action = args[0] || 'save';
+        return { success: true, message: `Stash action: ${action}` };
+      },
+    });
+
+    this.register({
+      name: 'cherry-pick',
+      description: 'Cherry-pick commits',
+      usage: 'trace cherry-pick <commit>...',
+      handler: async (args) => {
+        if (args.length === 0) {
+          return { success: false, message: 'Error: commit hashes required' };
+        }
+        return { success: true, message: `Cherry-picked ${args.length} commit(s)` };
+      },
+    });
+
+    // Coordination operations
+    this.register({
+      name: 'task',
+      description: 'Manage agent tasks',
+      usage: 'trace task [register|status|complete] [--agent <id>] [--files <list>]',
+      handler: async (args) => {
+        const action = args[0] || 'list';
+        return { success: true, message: `Task action: ${action}` };
+      },
+    });
+
+    this.register({
+      name: 'collision-detect',
+      description: 'Detect file conflicts between agents',
+      usage: 'trace collision-detect [--file <name>]',
+      handler: async (args) => {
+        return { success: true, message: 'Collision detection complete' };
+      },
+    });
+
+    this.register({
+      name: 'audit',
+      description: 'View security audit trail',
+      usage: 'trace audit [--agent <id>] [--file <name>] [--limit N]',
+      handler: async (args) => {
+        return { success: true, message: 'Audit trail displayed' };
+      },
+    });
+
+    this.register({
+      name: 'validate',
+      description: 'Validate files before commit',
+      usage: 'trace validate [--secure] [--all]',
+      handler: async (args) => {
+        const secure = args.includes('--secure');
+        return { success: true, message: `Validation complete (secure: ${secure})` };
+      },
+    });
+
+    // Conflict resolution
+    this.register({
+      name: 'resolve',
+      description: 'Interactive conflict resolution',
+      usage: 'trace resolve <file> [--strategy ours|theirs|manual]',
+      handler: async (args) => {
+        if (args.length === 0) {
+          return { success: false, message: 'Error: file path required' };
+        }
+        return { success: true, message: `Resolving conflicts in ${args[0]}` };
+      },
+    });
+
+    // Help command
+    this.register({
+      name: 'help',
+      description: 'Show help',
+      usage: 'trace help [command]',
+      handler: async (args) => {
+        if (args.length === 0) {
+          return this.showAllHelp();
+        }
+        return this.showCommandHelp(args[0]);
+      },
+    });
+  }
+
+  private register(cmd: CLICommand): void {
+    this.commands.set(cmd.name, cmd);
+  }
+
+  async execute(input: string): Promise<{ success: boolean; message: string }> {
+    const parts = input.trim().split(/\s+/);
+
+    if (parts[0] !== 'trace') {
+      return { success: false, message: 'Error: commands must start with "trace"' };
+    }
+
+    const commandName = parts[1];
+    const args = parts.slice(2);
+
+    if (!commandName) {
+      return { success: false, message: 'Error: command required. Use "trace help"' };
+    }
+
+    const cmd = this.commands.get(commandName);
+    if (!cmd) {
+      return { success: false, message: `Error: unknown command "${commandName}". Use "trace help"` };
+    }
+
+    try {
+      return await cmd.handler(args);
+    } catch (err) {
+      return { success: false, message: `Error: ${err}` };
+    }
+  }
+
+  private async showAllHelp(): Promise<{ success: boolean; message: string }> {
+    let help = '\n📖 TRACE CLI - Available Commands\n\n';
+
+    // Group by category
+    const groups: Record<string, CLICommand[]> = {
+      'Core VCS': [],
+      'Multi-Agent': [],
+      'Advanced': [],
+      'Coordination': [],
+      'Conflict Resolution': [],
+      'System': [],
+    };
+
+    const categorize = (cmd: CLICommand): string => {
+      if (['commit', 'log', 'push', 'pull'].includes(cmd.name)) return 'Core VCS';
+      if (['lock', 'unlock', 'status'].includes(cmd.name)) return 'Multi-Agent';
+      if (['merge', 'branch', 'rebase', 'stash', 'cherry-pick'].includes(cmd.name))
+        return 'Advanced';
+      if (['task', 'collision-detect', 'audit', 'validate'].includes(cmd.name))
+        return 'Coordination';
+      if (['resolve'].includes(cmd.name)) return 'Conflict Resolution';
+      return 'System';
+    };
+
+    for (const cmd of this.commands.values()) {
+      const cat = categorize(cmd);
+      if (!groups[cat]) groups[cat] = [];
+      groups[cat].push(cmd);
+    }
+
+    for (const [category, cmds] of Object.entries(groups)) {
+      help += `\n${category}:\n`;
+      for (const cmd of cmds) {
+        help += `  ${cmd.name.padEnd(15)} - ${cmd.description}\n`;
+        help += `    Usage: ${cmd.usage}\n`;
+      }
+    }
+
+    help += '\nUse "trace help <command>" for more details.\n';
+
+    return { success: true, message: help };
+  }
+
+  private async showCommandHelp(commandName: string): Promise<{ success: boolean; message: string }> {
+    const cmd = this.commands.get(commandName);
+    if (!cmd) {
+      return { success: false, message: `Unknown command: ${commandName}` };
+    }
+
+    const help = `\n📖 trace ${cmd.name}\n\n${cmd.description}\n\nUsage:\n  ${cmd.usage}\n`;
+    return { success: true, message: help };
+  }
+
+  getCommands(): string[] {
+    return Array.from(this.commands.keys());
+  }
+
+  getCommand(name: string): CLICommand | undefined {
+    return this.commands.get(name);
+  }
+}
+
+export default TraceCliv2;

package/src/cli.ts

@@ -0,0 +1,318 @@
+/**
+ * Trace CLI
+ * Command-line interface for agent version control
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface CommandContext {
+  workingDir: string;
+  agent: string;
+  branch: string;
+  verbose: boolean;
+}
+
+export class TraceCLI {
+  private context: CommandContext;
+
+  constructor(agent: string = 'agent-default') {
+    this.context = {
+      workingDir: process.cwd(),
+      agent,
+      branch: 'main',
+      verbose: false,
+    };
+  }
+
+  /**
+   * Initialize Trace in directory
+   */
+  init(dir: string): { success: boolean; message: string } {
+    try {
+      const traceDir = path.join(dir, '.trace');
+      if (!fs.existsSync(traceDir)) {
+        fs.mkdirSync(traceDir, { recursive: true });
+      }
+
+      const config = {
+        version: '1.3.0',
+        agent: this.context.agent,
+        created: new Date().toISOString(),
+      };
+
+      fs.writeFileSync(
+        path.join(traceDir, 'config.json'),
+        JSON.stringify(config, null, 2)
+      );
+
+      return { success: true, message: `Initialized Trace in ${dir}` };
+    } catch (err) {
+      return { success: false, message: `Failed to initialize: ${err}` };
+    }
+  }
+
+  /**
+   * Commit changes
+   */
+  commit(message: string, type: string = 'chore'): { success: boolean; hash?: string; message: string } {
+    if (!message) {
+      return { success: false, message: 'Commit message required' };
+    }
+
+    // Generate commit hash (simulation)
+    const hash = this.generateHash(message);
+
+    return {
+      success: true,
+      hash,
+      message: `[${this.context.branch}] ${hash.substring(0, 7)} ${message}`,
+    };
+  }
+
+  /**
+   * Show log
+   */
+  log(limit: number = 10): string {
+    return `\n📜 COMMIT LOG (${limit} recent)\n\n[Simulation] Latest commits would appear here\n`;
+  }
+
+  /**
+   * Show status
+   */
+  status(): string {
+    return `\n📊 STATUS\n\nBranch: ${this.context.branch}\nAgent: ${this.context.agent}\nWorking directory: ${this.context.workingDir}\n`;
+  }
+
+  /**
+   * Create branch
+   */
+  branch(branchName: string): { success: boolean; message: string } {
+    if (!branchName) {
+      return { success: false, message: 'Branch name required' };
+    }
+
+    this.context.branch = branchName;
+    return { success: true, message: `Created and switched to branch ${branchName}` };
+  }
+
+  /**
+   * Switch branch
+   */
+  checkout(branchName: string): { success: boolean; message: string } {
+    this.context.branch = branchName;
+    return { success: true, message: `Switched to branch ${branchName}` };
+  }
+
+  /**
+   * Merge branch
+   */
+  merge(branchName: string, strategy: string = 'auto'): { success: boolean; message: string } {
+    return {
+      success: true,
+      message: `Merged ${branchName} into ${this.context.branch} (strategy: ${strategy})`,
+    };
+  }
+
+  /**
+   * Stash changes
+   */
+  stash(description?: string): { success: boolean; message: string; stashId?: string } {
+    const stashId = `stash-${Date.now()}`;
+    return {
+      success: true,
+      stashId,
+      message: `Stashed: ${description || 'WIP'}`,
+    };
+  }
+
+  /**
+   * Pop stash
+   */
+  stashPop(): { success: boolean; message: string } {
+    return { success: true, message: 'Applied and removed latest stash' };
+  }
+
+  /**
+   * Rebase branch
+   */
+  rebase(onto: string): { success: boolean; message: string } {
+    return { success: true, message: `Rebased ${this.context.branch} onto ${onto}` };
+  }
+
+  /**
+   * Cherry-pick commit
+   */
+  cherryPick(commitHash: string): { success: boolean; message: string } {
+    return {
+      success: true,
+      message: `Cherry-picked ${commitHash.substring(0, 7)} onto ${this.context.branch}`,
+    };
+  }
+
+  /**
+   * Push to remote
+   */
+  push(remote: string = 'origin'): { success: boolean; message: string } {
+    return { success: true, message: `Pushed ${this.context.branch} to ${remote}` };
+  }
+
+  /**
+   * Pull from remote
+   */
+  pull(remote: string = 'origin'): { success: boolean; message: string } {
+    return { success: true, message: `Pulled ${this.context.branch} from ${remote}` };
+  }
+
+  /**
+   * Search commits
+   */
+  search(query: string): string {
+    return `\n🔍 SEARCH RESULTS for "${query}"\n\n[Simulation] Matching commits would appear here\n`;
+  }
+
+  /**
+   * Show version
+   */
+  version(): string {
+    return 'Trace v1.3.0';
+  }
+
+  /**
+   * Show help
+   */
+  help(): string {
+    return `
+Trace v1.3.0 - Agent Version Control System
+
+USAGE:
+  trace <command> [options]
+
+COMMANDS:
+  init                  Initialize Trace in directory
+  commit <msg>          Create commit
+  log [limit]           Show commit history
+  status                Show working directory status
+  branch <name>         Create and switch to branch
+  checkout <branch>     Switch to branch
+  merge <branch>        Merge branch
+  stash [desc]          Stash changes
+  stash pop             Apply and remove latest stash
+  rebase <onto>         Rebase onto branch
+  cherry-pick <hash>    Cherry-pick commit
+  push [remote]         Push to remote
+  pull [remote]         Pull from remote
+  search <query>        Search commits
+  version               Show version
+  help                  Show this help
+
+OPTIONS:
+  --agent <name>        Set agent name
+  --branch <name>       Set current branch
+  --verbose             Enable verbose output
+`;
+  }
+
+  /**
+   * Parse and execute command
+   */
+  execute(args: string[]): string {
+    if (args.length === 0) {
+      return this.help();
+    }
+
+    const command = args[0];
+    const params = args.slice(1);
+
+    switch (command) {
+      case 'init':
+        const initResult = this.init(params[0] || this.context.workingDir);
+        return initResult.message;
+
+      case 'commit':
+        const commitResult = this.commit(params.join(' '), params[params.length - 1]);
+        return commitResult.message;
+
+      case 'log':
+        return this.log(parseInt(params[0]) || 10);
+
+      case 'status':
+        return this.status();
+
+      case 'branch':
+        const branchResult = this.branch(params[0]);
+        return branchResult.message;
+
+      case 'checkout':
+        const checkoutResult = this.checkout(params[0]);
+        return checkoutResult.message;
+
+      case 'merge':
+        const mergeResult = this.merge(params[0], params[1]);
+        return mergeResult.message;
+
+      case 'stash':
+        if (params[0] === 'pop') {
+          return this.stashPop().message;
+        }
+        const stashResult = this.stash(params.join(' '));
+        return stashResult.message;
+
+      case 'rebase':
+        const rebaseResult = this.rebase(params[0]);
+        return rebaseResult.message;
+
+      case 'cherry-pick':
+        const pickResult = this.cherryPick(params[0]);
+        return pickResult.message;
+
+      case 'push':
+        const pushResult = this.push(params[0]);
+        return pushResult.message;
+
+      case 'pull':
+        const pullResult = this.pull(params[0]);
+        return pullResult.message;
+
+      case 'search':
+        return this.search(params.join(' '));
+
+      case 'version':
+        return this.version();
+
+      case 'help':
+        return this.help();
+
+      default:
+        return `Unknown command: ${command}. Use 'help' for available commands.`;
+    }
+  }
+
+  /**
+   * Generate commit hash
+   */
+  private generateHash(message: string): string {
+    const crypto = require('crypto');
+    return crypto
+      .createHash('sha256')
+      .update(message + Date.now())
+      .digest('hex')
+      .substring(0, 16);
+  }
+
+  /**
+   * Set context
+   */
+  setContext(partial: Partial<CommandContext>): void {
+    this.context = { ...this.context, ...partial };
+  }
+
+  /**
+   * Get context
+   */
+  getContext(): CommandContext {
+    return { ...this.context };
+  }
+}
+
+export default TraceCLI;