@stackmemoryai/stackmemory 0.2.9 → 0.3.1

package/dist/cli/codex-sm.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+import { spawn, execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { program } from "commander";
+import { v4 as uuidv4 } from "uuid";
+import chalk from "chalk";
+import { initializeTracing, trace } from "../core/trace/index.js";
+class CodexSM {
+  config;
+  stackmemoryPath;
+  constructor() {
+    this.config = {
+      instanceId: this.generateInstanceId(),
+      useWorktree: false,
+      contextEnabled: true,
+      tracingEnabled: true,
+      verboseTracing: false
+    };
+    this.stackmemoryPath = this.findStackMemory();
+  }
+  generateInstanceId() {
+    return uuidv4().substring(0, 8);
+  }
+  findStackMemory() {
+    const possiblePaths = [
+      path.join(os.homedir(), ".stackmemory", "bin", "stackmemory"),
+      "/usr/local/bin/stackmemory",
+      "/opt/homebrew/bin/stackmemory",
+      "stackmemory"
+    ];
+    for (const smPath of possiblePaths) {
+      try {
+        execSync(`which ${smPath}`, { stdio: "ignore" });
+        return smPath;
+      } catch {
+      }
+    }
+    return "stackmemory";
+  }
+  isGitRepo() {
+    try {
+      execSync("git rev-parse --git-dir", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getCurrentBranch() {
+    try {
+      return execSync("git rev-parse --abbrev-ref HEAD", {
+        encoding: "utf8"
+      }).trim();
+    } catch {
+      return "main";
+    }
+  }
+  hasUncommittedChanges() {
+    try {
+      const status = execSync("git status --porcelain", { encoding: "utf8" });
+      return status.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  setupWorktree() {
+    if (!this.config.useWorktree || !this.isGitRepo()) return null;
+    console.log(chalk.blue("\u{1F333} Setting up isolated worktree..."));
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
+    const branch = this.config.branch || `codex-${this.config.task || "work"}-${timestamp}-${this.config.instanceId}`;
+    const repoName = path.basename(process.cwd());
+    const worktreePath = path.join(
+      path.dirname(process.cwd()),
+      `${repoName}--${branch}`
+    );
+    try {
+      const cmd = `git worktree add -b "${branch}" "${worktreePath}"`;
+      execSync(cmd, { stdio: "inherit" });
+      console.log(chalk.green(`\u2705 Worktree created: ${worktreePath}`));
+      console.log(chalk.gray(`   Branch: ${branch}`));
+      const configPath = path.join(worktreePath, ".codex-instance.json");
+      const configData = {
+        instanceId: this.config.instanceId,
+        worktreePath,
+        branch,
+        task: this.config.task,
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        parentRepo: process.cwd()
+      };
+      fs.writeFileSync(configPath, JSON.stringify(configData, null, 2));
+      const envFiles = [".env", ".env.local", ".mise.toml", ".tool-versions"];
+      for (const file of envFiles) {
+        const srcPath = path.join(process.cwd(), file);
+        if (fs.existsSync(srcPath))
+          fs.copyFileSync(srcPath, path.join(worktreePath, file));
+      }
+      return worktreePath;
+    } catch (err) {
+      console.error(chalk.red("\u274C Failed to create worktree:"), err);
+      return null;
+    }
+  }
+  saveContext(message, metadata = {}) {
+    if (!this.config.contextEnabled) return;
+    try {
+      const contextData = {
+        message,
+        metadata: {
+          ...metadata,
+          instanceId: this.config.instanceId,
+          worktree: this.config.worktreePath,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+      const cmd = `${this.stackmemoryPath} context save --json '${JSON.stringify(contextData)}'`;
+      execSync(cmd, { stdio: "ignore" });
+    } catch {
+    }
+  }
+  loadContext() {
+    if (!this.config.contextEnabled) return;
+    try {
+      console.log(chalk.blue("\u{1F4DA} Loading previous context..."));
+      const cmd = `${this.stackmemoryPath} context list --limit 5 --format json`;
+      const output = execSync(cmd, { encoding: "utf8" });
+      const contexts = JSON.parse(output);
+      if (Array.isArray(contexts) && contexts.length > 0) {
+        console.log(chalk.gray("Recent context loaded:"));
+        contexts.forEach(
+          (ctx) => {
+            console.log(
+              chalk.gray(`  - ${ctx.message} (${ctx.metadata?.timestamp})`)
+            );
+          }
+        );
+      }
+    } catch {
+    }
+  }
+  suggestWorktreeMode() {
+    if (this.hasUncommittedChanges()) {
+      console.log(chalk.yellow("\u26A0\uFE0F  Uncommitted changes detected"));
+      console.log(
+        chalk.gray("   Consider using --worktree to work in isolation")
+      );
+    }
+  }
+  async run(args) {
+    const codexArgs = [];
+    let i = 0;
+    while (i < args.length) {
+      const arg = args[i];
+      switch (arg) {
+        case "--worktree":
+        case "-w":
+          this.config.useWorktree = true;
+          break;
+        case "--no-context":
+          this.config.contextEnabled = false;
+          break;
+        case "--no-trace":
+          this.config.tracingEnabled = false;
+          break;
+        case "--verbose-trace":
+          this.config.verboseTracing = true;
+          break;
+        case "--branch":
+        case "-b":
+          i++;
+          this.config.branch = args[i];
+          break;
+        case "--task":
+        case "-t":
+          i++;
+          this.config.task = args[i];
+          break;
+        case "--auto":
+        case "-a":
+          if (this.isGitRepo()) {
+            this.config.useWorktree = this.hasUncommittedChanges();
+          }
+          break;
+        default:
+          codexArgs.push(arg);
+      }
+      i++;
+    }
+    if (this.config.tracingEnabled) {
+      process.env.DEBUG_TRACE = "true";
+      process.env.STACKMEMORY_DEBUG = "true";
+      process.env.TRACE_OUTPUT = "file";
+      process.env.TRACE_MASK_SENSITIVE = "true";
+      if (this.config.verboseTracing) {
+        process.env.TRACE_VERBOSITY = "full";
+        process.env.TRACE_PARAMS = "true";
+        process.env.TRACE_RESULTS = "true";
+        process.env.TRACE_MEMORY = "true";
+      } else {
+        process.env.TRACE_VERBOSITY = "summary";
+        process.env.TRACE_PARAMS = "true";
+        process.env.TRACE_RESULTS = "false";
+      }
+      initializeTracing();
+      trace.command(
+        "codex-sm",
+        {
+          instanceId: this.config.instanceId,
+          worktree: this.config.useWorktree,
+          task: this.config.task
+        },
+        async () => {
+        }
+      );
+    }
+    console.log(chalk.blue("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+    console.log(chalk.blue("\u2551     Codex + StackMemory + Worktree    \u2551"));
+    console.log(chalk.blue("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+    console.log();
+    if (this.isGitRepo()) {
+      const branch = this.getCurrentBranch();
+      console.log(chalk.gray(`\u{1F4CD} Current branch: ${branch}`));
+      if (!this.config.useWorktree) this.suggestWorktreeMode();
+    }
+    if (this.config.useWorktree) {
+      const worktreePath = this.setupWorktree();
+      if (worktreePath) {
+        this.config.worktreePath = worktreePath;
+        process.chdir(worktreePath);
+        this.saveContext("Created worktree for Codex instance", {
+          action: "worktree_created",
+          path: worktreePath,
+          branch: this.config.branch
+        });
+      }
+    }
+    this.loadContext();
+    process.env.CODEX_INSTANCE_ID = this.config.instanceId;
+    if (this.config.worktreePath)
+      process.env.CODEX_WORKTREE_PATH = this.config.worktreePath;
+    console.log(chalk.gray(`\u{1F916} Instance ID: ${this.config.instanceId}`));
+    console.log(chalk.gray(`\u{1F4C1} Working in: ${process.cwd()}`));
+    console.log();
+    console.log(chalk.gray("Starting Codex..."));
+    console.log(chalk.gray("\u2500".repeat(42)));
+    const codexBin = (() => {
+      try {
+        execSync("which codex", { stdio: "ignore" });
+        return "codex";
+      } catch {
+      }
+      try {
+        execSync("which codex-cli", { stdio: "ignore" });
+        return "codex-cli";
+      } catch {
+      }
+      return null;
+    })();
+    if (!codexBin) {
+      console.error(
+        chalk.red("\u274C Codex CLI not found in PATH (codex or codex-cli).")
+      );
+      process.exit(1);
+      return;
+    }
+    const child = spawn(codexBin, codexArgs, {
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("exit", (code) => {
+      this.saveContext("Codex session ended", {
+        action: "session_end",
+        exitCode: code
+      });
+      if (this.config.tracingEnabled) {
+        const summary = trace.getExecutionSummary();
+        console.log();
+        console.log(chalk.gray("\u2500".repeat(42)));
+        console.log(chalk.blue("Debug Trace Summary:"));
+        console.log(chalk.gray(summary));
+      }
+      if (this.config.worktreePath) {
+        console.log();
+        console.log(chalk.gray("\u2500".repeat(42)));
+        console.log(chalk.blue("Session ended in worktree:"));
+        console.log(chalk.gray(`  ${this.config.worktreePath}`));
+      }
+      process.exit(code || 0);
+    });
+    process.on("SIGINT", () => {
+      this.saveContext("Codex session interrupted", {
+        action: "session_interrupt"
+      });
+      child.kill("SIGINT");
+    });
+    process.on("SIGTERM", () => {
+      this.saveContext("Codex session terminated", {
+        action: "session_terminate"
+      });
+      child.kill("SIGTERM");
+    });
+  }
+}
+program.name("codex-sm").description("Codex with StackMemory context and optional worktree isolation").version("1.0.0").option("-w, --worktree", "Create isolated worktree for this instance").option("-a, --auto", "Automatically detect and apply best settings").option("-b, --branch <name>", "Specify branch name for worktree").option("-t, --task <desc>", "Task description for context").option("--no-context", "Disable StackMemory context integration").option("--no-trace", "Disable debug tracing (enabled by default)").option("--verbose-trace", "Enable verbose debug tracing with full details").helpOption("-h, --help", "Display help").allowUnknownOption(true).action(async (_options) => {
+  const codexSM = new CodexSM();
+  const args = process.argv.slice(2);
+  await codexSM.run(args);
+});
+if (require.main === module) {
+  program.parse(process.argv);
+}
+//# sourceMappingURL=codex-sm.js.map

package/dist/cli/codex-sm.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cli/codex-sm.ts"],
+  "sourcesContent": ["#!/usr/bin/env node\n\n/**\n * codex-sm: Codex wrapper with StackMemory and worktree integration\n * Automatically manages context persistence, optional worktree isolation, and tracing\n */\n\nimport { spawn, execSync } from 'child_process';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as os from 'os';\nimport { program } from 'commander';\nimport { v4 as uuidv4 } from 'uuid';\nimport chalk from 'chalk';\nimport { initializeTracing, trace } from '../core/trace/index.js';\n\ninterface CodexConfig {\n  instanceId: string;\n  worktreePath?: string;\n  useWorktree: boolean;\n  contextEnabled: boolean;\n  branch?: string;\n  task?: string;\n  tracingEnabled: boolean;\n  verboseTracing: boolean;\n}\n\nclass CodexSM {\n  private config: CodexConfig;\n  private stackmemoryPath: string;\n\n  constructor() {\n    this.config = {\n      instanceId: this.generateInstanceId(),\n      useWorktree: false,\n      contextEnabled: true,\n      tracingEnabled: true,\n      verboseTracing: false,\n    };\n\n    this.stackmemoryPath = this.findStackMemory();\n  }\n\n  private generateInstanceId(): string {\n    return uuidv4().substring(0, 8);\n  }\n\n  private findStackMemory(): string {\n    const possiblePaths = [\n      path.join(os.homedir(), '.stackmemory', 'bin', 'stackmemory'),\n      '/usr/local/bin/stackmemory',\n      '/opt/homebrew/bin/stackmemory',\n      'stackmemory',\n    ];\n    for (const smPath of possiblePaths) {\n      try {\n        execSync(`which ${smPath}`, { stdio: 'ignore' });\n        return smPath;\n      } catch {\n        // continue\n      }\n    }\n    return 'stackmemory';\n  }\n\n  private isGitRepo(): boolean {\n    try {\n      execSync('git rev-parse --git-dir', { stdio: 'ignore' });\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  private getCurrentBranch(): string {\n    try {\n      return execSync('git rev-parse --abbrev-ref HEAD', {\n        encoding: 'utf8',\n      }).trim();\n    } catch {\n      return 'main';\n    }\n  }\n\n  private hasUncommittedChanges(): boolean {\n    try {\n      const status = execSync('git status --porcelain', { encoding: 'utf8' });\n      return status.length > 0;\n    } catch {\n      return false;\n    }\n  }\n\n  private setupWorktree(): string | null {\n    if (!this.config.useWorktree || !this.isGitRepo()) return null;\n\n    console.log(chalk.blue('\uD83C\uDF33 Setting up isolated worktree...'));\n\n    const timestamp = new Date()\n      .toISOString()\n      .replace(/[:.]/g, '-')\n      .substring(0, 19);\n    const branch =\n      this.config.branch ||\n      `codex-${this.config.task || 'work'}-${timestamp}-${this.config.instanceId}`;\n    const repoName = path.basename(process.cwd());\n    const worktreePath = path.join(\n      path.dirname(process.cwd()),\n      `${repoName}--${branch}`\n    );\n\n    try {\n      const cmd = `git worktree add -b \"${branch}\" \"${worktreePath}\"`;\n      execSync(cmd, { stdio: 'inherit' });\n\n      console.log(chalk.green(`\u2705 Worktree created: ${worktreePath}`));\n      console.log(chalk.gray(`   Branch: ${branch}`));\n\n      const configPath = path.join(worktreePath, '.codex-instance.json');\n      const configData = {\n        instanceId: this.config.instanceId,\n        worktreePath,\n        branch,\n        task: this.config.task,\n        created: new Date().toISOString(),\n        parentRepo: process.cwd(),\n      };\n      fs.writeFileSync(configPath, JSON.stringify(configData, null, 2));\n\n      const envFiles = ['.env', '.env.local', '.mise.toml', '.tool-versions'];\n      for (const file of envFiles) {\n        const srcPath = path.join(process.cwd(), file);\n        if (fs.existsSync(srcPath))\n          fs.copyFileSync(srcPath, path.join(worktreePath, file));\n      }\n\n      return worktreePath;\n    } catch (err) {\n      console.error(chalk.red('\u274C Failed to create worktree:'), err);\n      return null;\n    }\n  }\n\n  private saveContext(\n    message: string,\n    metadata: Record<string, unknown> = {}\n  ): void {\n    if (!this.config.contextEnabled) return;\n    try {\n      const contextData = {\n        message,\n        metadata: {\n          ...metadata,\n          instanceId: this.config.instanceId,\n          worktree: this.config.worktreePath,\n          timestamp: new Date().toISOString(),\n        },\n      };\n      const cmd = `${this.stackmemoryPath} context save --json '${JSON.stringify(contextData)}'`;\n      execSync(cmd, { stdio: 'ignore' });\n    } catch {\n      // ignore\n    }\n  }\n\n  private loadContext(): void {\n    if (!this.config.contextEnabled) return;\n    try {\n      console.log(chalk.blue('\uD83D\uDCDA Loading previous context...'));\n      const cmd = `${this.stackmemoryPath} context list --limit 5 --format json`;\n      const output = execSync(cmd, { encoding: 'utf8' });\n      const contexts = JSON.parse(output);\n      if (Array.isArray(contexts) && contexts.length > 0) {\n        console.log(chalk.gray('Recent context loaded:'));\n        contexts.forEach(\n          (ctx: { message: string; metadata?: { timestamp?: string } }) => {\n            console.log(\n              chalk.gray(`  - ${ctx.message} (${ctx.metadata?.timestamp})`)\n            );\n          }\n        );\n      }\n    } catch {\n      // ignore\n    }\n  }\n\n  private suggestWorktreeMode(): void {\n    if (this.hasUncommittedChanges()) {\n      console.log(chalk.yellow('\u26A0\uFE0F  Uncommitted changes detected'));\n      console.log(\n        chalk.gray('   Consider using --worktree to work in isolation')\n      );\n    }\n  }\n\n  public async run(args: string[]): Promise<void> {\n    const codexArgs: string[] = [];\n    let i = 0;\n    while (i < args.length) {\n      const arg = args[i];\n      switch (arg) {\n        case '--worktree':\n        case '-w':\n          this.config.useWorktree = true;\n          break;\n        case '--no-context':\n          this.config.contextEnabled = false;\n          break;\n        case '--no-trace':\n          this.config.tracingEnabled = false;\n          break;\n        case '--verbose-trace':\n          this.config.verboseTracing = true;\n          break;\n        case '--branch':\n        case '-b':\n          i++;\n          this.config.branch = args[i];\n          break;\n        case '--task':\n        case '-t':\n          i++;\n          this.config.task = args[i];\n          break;\n        case '--auto':\n        case '-a':\n          if (this.isGitRepo()) {\n            this.config.useWorktree = this.hasUncommittedChanges();\n          }\n          break;\n        default:\n          codexArgs.push(arg);\n      }\n      i++;\n    }\n\n    if (this.config.tracingEnabled) {\n      process.env.DEBUG_TRACE = 'true';\n      process.env.STACKMEMORY_DEBUG = 'true';\n      process.env.TRACE_OUTPUT = 'file';\n      process.env.TRACE_MASK_SENSITIVE = 'true';\n      if (this.config.verboseTracing) {\n        process.env.TRACE_VERBOSITY = 'full';\n        process.env.TRACE_PARAMS = 'true';\n        process.env.TRACE_RESULTS = 'true';\n        process.env.TRACE_MEMORY = 'true';\n      } else {\n        process.env.TRACE_VERBOSITY = 'summary';\n        process.env.TRACE_PARAMS = 'true';\n        process.env.TRACE_RESULTS = 'false';\n      }\n      initializeTracing();\n      trace.command(\n        'codex-sm',\n        {\n          instanceId: this.config.instanceId,\n          worktree: this.config.useWorktree,\n          task: this.config.task,\n        },\n        async () => {}\n      );\n    }\n\n    console.log(chalk.blue('\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557'));\n    console.log(chalk.blue('\u2551     Codex + StackMemory + Worktree    \u2551'));\n    console.log(chalk.blue('\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D'));\n    console.log();\n\n    if (this.isGitRepo()) {\n      const branch = this.getCurrentBranch();\n      console.log(chalk.gray(`\uD83D\uDCCD Current branch: ${branch}`));\n      if (!this.config.useWorktree) this.suggestWorktreeMode();\n    }\n\n    if (this.config.useWorktree) {\n      const worktreePath = this.setupWorktree();\n      if (worktreePath) {\n        this.config.worktreePath = worktreePath;\n        process.chdir(worktreePath);\n        this.saveContext('Created worktree for Codex instance', {\n          action: 'worktree_created',\n          path: worktreePath,\n          branch: this.config.branch,\n        });\n      }\n    }\n\n    this.loadContext();\n\n    process.env.CODEX_INSTANCE_ID = this.config.instanceId;\n    if (this.config.worktreePath)\n      process.env.CODEX_WORKTREE_PATH = this.config.worktreePath;\n\n    console.log(chalk.gray(`\uD83E\uDD16 Instance ID: ${this.config.instanceId}`));\n    console.log(chalk.gray(`\uD83D\uDCC1 Working in: ${process.cwd()}`));\n\n    console.log();\n    console.log(chalk.gray('Starting Codex...'));\n    console.log(chalk.gray('\u2500'.repeat(42)));\n\n    const codexBin = (() => {\n      try {\n        execSync('which codex', { stdio: 'ignore' });\n        return 'codex';\n      } catch {}\n      try {\n        execSync('which codex-cli', { stdio: 'ignore' });\n        return 'codex-cli';\n      } catch {}\n      return null;\n    })();\n\n    if (!codexBin) {\n      console.error(\n        chalk.red('\u274C Codex CLI not found in PATH (codex or codex-cli).')\n      );\n      process.exit(1);\n      return;\n    }\n\n    const child = spawn(codexBin, codexArgs, {\n      stdio: 'inherit',\n      env: process.env,\n    });\n\n    child.on('exit', (code) => {\n      this.saveContext('Codex session ended', {\n        action: 'session_end',\n        exitCode: code,\n      });\n      if (this.config.tracingEnabled) {\n        const summary = trace.getExecutionSummary();\n        console.log();\n        console.log(chalk.gray('\u2500'.repeat(42)));\n        console.log(chalk.blue('Debug Trace Summary:'));\n        console.log(chalk.gray(summary));\n      }\n      if (this.config.worktreePath) {\n        console.log();\n        console.log(chalk.gray('\u2500'.repeat(42)));\n        console.log(chalk.blue('Session ended in worktree:'));\n        console.log(chalk.gray(`  ${this.config.worktreePath}`));\n      }\n      process.exit(code || 0);\n    });\n\n    process.on('SIGINT', () => {\n      this.saveContext('Codex session interrupted', {\n        action: 'session_interrupt',\n      });\n      child.kill('SIGINT');\n    });\n\n    process.on('SIGTERM', () => {\n      this.saveContext('Codex session terminated', {\n        action: 'session_terminate',\n      });\n      child.kill('SIGTERM');\n    });\n  }\n}\n\nprogram\n  .name('codex-sm')\n  .description('Codex with StackMemory context and optional worktree isolation')\n  .version('1.0.0')\n  .option('-w, --worktree', 'Create isolated worktree for this instance')\n  .option('-a, --auto', 'Automatically detect and apply best settings')\n  .option('-b, --branch <name>', 'Specify branch name for worktree')\n  .option('-t, --task <desc>', 'Task description for context')\n  .option('--no-context', 'Disable StackMemory context integration')\n  .option('--no-trace', 'Disable debug tracing (enabled by default)')\n  .option('--verbose-trace', 'Enable verbose debug tracing with full details')\n  .helpOption('-h, --help', 'Display help')\n  .allowUnknownOption(true)\n  .action(async (_options) => {\n    const codexSM = new CodexSM();\n    const args = process.argv.slice(2);\n    await codexSM.run(args);\n  });\n\nif (require.main === module) {\n  program.parse(process.argv);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cli/commands/agent.js

@@ -0,0 +1,286 @@
+import { Command } from "commander";
+import Database from "better-sqlite3";
+import { join } from "path";
+import { existsSync } from "fs";
+import chalk from "chalk";
+import ora from "ora";
+import { PebblesTaskStore } from "../../features/tasks/pebbles-task-store.js";
+import { FrameManager } from "../../core/context/frame-manager.js";
+import {
+  AgentTaskManager
+} from "../../agents/core/agent-task-manager.js";
+function createAgentCommand() {
+  const agent = new Command("agent").description("AI agent task execution with Spotify-inspired strategies").option("-p, --project <path>", "Project root directory", process.cwd());
+  agent.command("execute <taskId>").description("Execute a task with agent assistance").option("-f, --frame <frameId>", "Frame ID to use").option("--max-turns <number>", "Maximum turns per session", "10").option("--no-verify", "Skip verification loops").action(async (taskId, options) => {
+    const spinner = ora("Initializing agent...").start();
+    try {
+      const { taskManager, session } = await initializeAgent(
+        options.project,
+        taskId,
+        options.frame,
+        parseInt(options.maxTurns)
+      );
+      spinner.succeed("Agent initialized");
+      console.log(chalk.cyan("\n\u{1F4CB} Task Session Started"));
+      console.log(chalk.gray("  Session ID:"), session.id);
+      console.log(chalk.gray("  Task ID:"), session.taskId);
+      console.log(chalk.gray("  Max Turns:"), session.maxTurns);
+      console.log(
+        chalk.gray("  Verification:"),
+        options.verify ? "Enabled" : "Disabled"
+      );
+      await executeTaskWithFeedback(taskManager, session, options.verify);
+    } catch (error) {
+      spinner.fail("Agent execution failed");
+      console.error(
+        chalk.red("Error:"),
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+  agent.command("status").description("Show active agent sessions").action(async (options) => {
+    const spinner = ora("Loading sessions...").start();
+    try {
+      const projectRoot = options.parent?.project || process.cwd();
+      const { taskManager } = await initializeAgentManager(projectRoot);
+      const sessions = taskManager.getActiveSessions();
+      spinner.stop();
+      if (sessions.length === 0) {
+        console.log(chalk.yellow("No active agent sessions"));
+        return;
+      }
+      console.log(chalk.cyan("\n\u{1F916} Active Agent Sessions\n"));
+      for (const session of sessions) {
+        console.log(chalk.bold(`Session: ${session.sessionId}`));
+        console.log(chalk.gray("  Task:"), session.taskId);
+        console.log(
+          chalk.gray("  Status:"),
+          getStatusColor(session.status)(session.status)
+        );
+        console.log(chalk.gray("  Turn:"), `${session.turnCount}/10`);
+        console.log(
+          chalk.gray("  Started:"),
+          session.startedAt.toLocaleString()
+        );
+        console.log("");
+      }
+    } catch (error) {
+      spinner.fail("Failed to load sessions");
+      console.error(
+        chalk.red("Error:"),
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+  agent.command("retry <sessionId>").description("Retry a failed session with learned context").action(async (sessionId, options) => {
+    const spinner = ora("Retrying session...").start();
+    try {
+      const projectRoot = options.parent?.project || process.cwd();
+      const { taskManager } = await initializeAgentManager(projectRoot);
+      const newSession = await taskManager.retrySession(sessionId);
+      if (!newSession) {
+        spinner.fail(
+          "Cannot retry session (max retries reached or session active)"
+        );
+        return;
+      }
+      spinner.succeed("Session retry started");
+      console.log(chalk.cyan("\n\u267B\uFE0F Retry Session Started"));
+      console.log(chalk.gray("  New Session ID:"), newSession.id);
+      console.log(chalk.gray("  Task ID:"), newSession.taskId);
+      await executeTaskWithFeedback(taskManager, newSession, true);
+    } catch (error) {
+      spinner.fail("Retry failed");
+      console.error(
+        chalk.red("Error:"),
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+  agent.command("breakdown <taskId>").description("Break down a complex task into subtasks").action(async (taskId, options) => {
+    const spinner = ora("Analyzing task complexity...").start();
+    try {
+      const projectRoot = options.parent?.project || process.cwd();
+      const db = await openDatabase(projectRoot);
+      const taskStore = new PebblesTaskStore(projectRoot, db);
+      const task = taskStore.getTask(taskId);
+      if (!task) {
+        spinner.fail(`Task ${taskId} not found`);
+        return;
+      }
+      spinner.text = "Breaking down task...";
+      const subtasks = generateTaskBreakdown(
+        task.title,
+        task.description || ""
+      );
+      spinner.succeed("Task breakdown complete");
+      console.log(chalk.cyan(`
+\u{1F4CA} Task Breakdown: ${task.title}
+`));
+      subtasks.forEach((subtask, index) => {
+        console.log(chalk.bold(`${index + 1}. ${subtask.title}`));
+        console.log(chalk.gray("   Description:"), subtask.description);
+        console.log(
+          chalk.gray("   Estimated turns:"),
+          subtask.estimatedTurns
+        );
+        console.log(
+          chalk.gray("   Verifiers:"),
+          subtask.verifiers.join(", ")
+        );
+        console.log("");
+      });
+      console.log(
+        chalk.yellow("Total estimated turns:"),
+        subtasks.reduce((sum, st) => sum + st.estimatedTurns, 0)
+      );
+    } catch (error) {
+      spinner.fail("Breakdown failed");
+      console.error(
+        chalk.red("Error:"),
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+  return agent;
+}
+async function initializeAgent(projectRoot, taskId, frameId, maxTurns = 10) {
+  const { taskManager, frameManager, taskStore } = await initializeAgentManager(projectRoot);
+  const finalFrameId = frameId || frameManager.createFrame({
+    type: "task",
+    name: `Agent task execution for ${taskId}`,
+    inputs: { taskId, agentSession: true }
+  });
+  const session = await taskManager.startTaskSession(taskId, finalFrameId);
+  if (maxTurns !== 10) {
+    session.maxTurns = maxTurns;
+  }
+  return { taskManager, session };
+}
+async function initializeAgentManager(projectRoot) {
+  const db = await openDatabase(projectRoot);
+  const taskStore = new PebblesTaskStore(projectRoot, db);
+  const frameManager = new FrameManager(db, projectRoot, void 0);
+  const taskManager = new AgentTaskManager(taskStore, frameManager);
+  return { taskManager, frameManager, taskStore };
+}
+async function executeTaskWithFeedback(taskManager, session, enableVerification) {
+  console.log(chalk.cyan("\n\u{1F504} Starting execution loop...\n"));
+  let turnCount = 0;
+  let shouldContinue = true;
+  let lastFeedback = "";
+  while (shouldContinue && turnCount < session.maxTurns) {
+    turnCount++;
+    console.log(chalk.bold(`
+\u2550\u2550\u2550 Turn ${turnCount}/${session.maxTurns} \u2550\u2550\u2550`));
+    const action = generateMockAction(turnCount, lastFeedback);
+    console.log(chalk.gray("Action:"), action.substring(0, 100) + "...");
+    const spinner = ora("Executing...").start();
+    const result = await taskManager.executeTurn(session.id, action, {
+      codeChange: turnCount > 1,
+      testsPresent: turnCount > 2,
+      enableVerification
+    });
+    if (result.success) {
+      spinner.succeed("Turn completed successfully");
+    } else {
+      spinner.warn("Turn completed with issues");
+    }
+    console.log(chalk.yellow("\n\u{1F4DD} Feedback:"));
+    console.log(result.feedback);
+    if (result.verificationResults.length > 0) {
+      console.log(chalk.cyan("\n\u2713 Verification Results:"));
+      for (const vr of result.verificationResults) {
+        const icon = vr.passed ? "\u2713" : "\u2717";
+        const color = vr.passed ? chalk.green : chalk.red;
+        console.log(color(`  ${icon} ${vr.verifierId}: ${vr.message}`));
+      }
+    }
+    shouldContinue = result.shouldContinue;
+    lastFeedback = result.feedback;
+    await delay(1e3);
+  }
+  console.log(chalk.cyan("\n\u2550\u2550\u2550 Session Complete \u2550\u2550\u2550\n"));
+  console.log(chalk.gray("Total turns:"), turnCount);
+  console.log(chalk.gray("Final status:"), session.status);
+}
+function generateMockAction(turn, previousFeedback) {
+  const actions = [
+    "Analyzing task requirements and constraints",
+    "Setting up project structure and dependencies",
+    "Implementing core functionality",
+    "Adding error handling and validation",
+    "Writing unit tests",
+    "Refactoring for better code organization",
+    "Adding documentation and comments",
+    "Running final verification checks",
+    "Optimizing performance",
+    "Completing final cleanup"
+  ];
+  if (previousFeedback.includes("error")) {
+    return `Fixing issues: ${previousFeedback.substring(0, 50)}...`;
+  }
+  return actions[Math.min(turn - 1, actions.length - 1)];
+}
+function generateTaskBreakdown(title, description) {
+  return [
+    {
+      title: `Analyze and plan: ${title}`,
+      description: "Understand requirements and create implementation plan",
+      estimatedTurns: 2,
+      verifiers: ["semantic-validator"]
+    },
+    {
+      title: `Implement core: ${title}`,
+      description: "Build main functionality",
+      estimatedTurns: 4,
+      verifiers: ["formatter", "linter", "semantic-validator"]
+    },
+    {
+      title: `Test and validate: ${title}`,
+      description: "Add tests and validate implementation",
+      estimatedTurns: 3,
+      verifiers: ["test-runner", "semantic-validator"]
+    },
+    {
+      title: `Polish and document: ${title}`,
+      description: "Final improvements and documentation",
+      estimatedTurns: 1,
+      verifiers: ["formatter", "linter"]
+    }
+  ];
+}
+async function openDatabase(projectRoot) {
+  const dbPath = join(projectRoot, ".stackmemory", "cache.db");
+  if (!existsSync(join(projectRoot, ".stackmemory"))) {
+    throw new Error(
+      'StackMemory not initialized. Run "stackmemory init" first.'
+    );
+  }
+  return new Database(dbPath);
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "active":
+      return chalk.green;
+    case "completed":
+      return chalk.blue;
+    case "failed":
+      return chalk.red;
+    case "timeout":
+      return chalk.yellow;
+    default:
+      return chalk.gray;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  createAgentCommand
+};
+//# sourceMappingURL=agent.js.map