@stackmemoryai/stackmemory 1.6.0 → 1.6.2

package/dist/src/cli/commands/orchestrator.js

@@ -38,6 +38,124 @@ function logAgentOutcome(entry) {
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   appendFileSync(getOutcomesLogPath(), JSON.stringify(entry) + "\n");
 }
+function createPullRequest(opts) {
+  try {
+    execSync(`git push -u origin "${opts.branch}"`, {
+      cwd: opts.workspacePath,
+      stdio: "pipe",
+      timeout: 6e4
+    });
+    const prTitle = `feat(conductor): ${opts.issueId} \u2014 ${opts.title}`;
+    const prBody = [
+      "## Summary",
+      "",
+      `Automated PR from conductor agent for **${opts.issueId}**.`,
+      "",
+      `- **Files modified:** ${opts.filesModified}`,
+      `- **Tool calls:** ${opts.toolCalls}`,
+      "",
+      "_This PR was auto-created by StackMemory Conductor._"
+    ].join("\n");
+    const result = execSync(
+      `gh pr create --base "${opts.baseBranch}" --head "${opts.branch}" --title "${prTitle.replace(/"/g, '\\"')}" --body "${prBody.replace(/"/g, '\\"')}"`,
+      {
+        cwd: opts.workspacePath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 3e4
+      }
+    );
+    const prUrl = result.trim();
+    logger.info("Created PR", { issueId: opts.issueId, prUrl });
+    return prUrl;
+  } catch (err) {
+    logger.warn("Failed to create PR (best-effort)", {
+      issueId: opts.issueId,
+      error: err.message
+    });
+    return null;
+  }
+}
+function getRetryStrategy(issue, outcomes) {
+  if (!outcomes) {
+    const logPath = getOutcomesLogPath();
+    if (!existsSync(logPath)) {
+      return { shouldRetry: true, adjustments: [] };
+    }
+    try {
+      const lines = readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean);
+      outcomes = lines.map((l) => JSON.parse(l));
+    } catch {
+      return { shouldRetry: true, adjustments: [] };
+    }
+  }
+  const issueOutcomes = outcomes.filter((o) => o.issue === issue);
+  const relevant = issueOutcomes.length > 0 ? issueOutcomes : outcomes;
+  const failures = relevant.filter(
+    (o) => o.outcome === "failure" || o.outcome === "partial"
+  );
+  if (failures.length === 0) {
+    return { shouldRetry: true, adjustments: [] };
+  }
+  const lastFailure = failures[failures.length - 1];
+  if (lastFailure.errorTail && /429|rate.?limit|too many requests|usage.?limit|overloaded/i.test(
+    lastFailure.errorTail
+  )) {
+    return {
+      shouldRetry: false,
+      reason: "Last failure was a rate limit (429) \u2014 retrying immediately will not help",
+      adjustments: []
+    };
+  }
+  if (issueOutcomes.length > 0) {
+    const issueFailures = issueOutcomes.filter(
+      (o) => o.outcome === "failure" || o.outcome === "partial"
+    );
+    const phaseFailCounts = /* @__PURE__ */ new Map();
+    for (const f of issueFailures) {
+      phaseFailCounts.set(f.phase, (phaseFailCounts.get(f.phase) || 0) + 1);
+    }
+    for (const [phase, count] of phaseFailCounts) {
+      if (count >= 2) {
+        return {
+          shouldRetry: false,
+          reason: `Issue has failed ${count} times in '${phase}' phase \u2014 likely a structural problem`,
+          adjustments: []
+        };
+      }
+    }
+  }
+  const adjustments = [];
+  if (lastFailure.errorTail) {
+    const tail = lastFailure.errorTail;
+    if (/timeout|timed?.?out|ETIMEDOUT|ESOCKETTIMEDOUT/i.test(tail)) {
+      adjustments.push(
+        "Previous attempt timed out. Work in smaller increments and commit partial progress early."
+      );
+    }
+    if (/lint|eslint|prettier|formatting|style.?error/i.test(tail)) {
+      adjustments.push(
+        "Previous attempt failed on linting. Run `npm run lint:fix` after each file change and fix all lint errors before committing."
+      );
+    }
+    if (/test.?fail|assertion|expect|vitest|jest|FAIL/i.test(tail)) {
+      adjustments.push(
+        "Previous attempt failed tests. Run tests incrementally after each change. Check existing test expectations before modifying code."
+      );
+    }
+    if (/build.?fail|tsc|type.?error|TS\d{4}|compile/i.test(tail)) {
+      adjustments.push(
+        "Previous attempt had build/type errors. Run `npm run build` after changes and fix type errors before committing."
+      );
+    }
+    if (/cannot find module|ERR_MODULE_NOT_FOUND|import/i.test(tail)) {
+      adjustments.push(
+        "Previous attempt had module resolution errors. Ensure all imports use .js extensions for relative paths (ESM)."
+      );
+    }
+  }
+  return { shouldRetry: true, adjustments };
+}
 function findPackageRoot() {
   const currentFile = fileURLToPath(import.meta.url);
   let dir = dirname(currentFile);
@@ -136,6 +254,52 @@ function inferPhase(msg) {
   }
   return null;
 }
+const SIMPLE_LABELS = ["bug", "fix", "typo", "chore", "docs", "hotfix"];
+const COMPLEX_LABELS = [
+  "feature",
+  "refactor",
+  "architecture",
+  "migration",
+  "security",
+  "performance"
+];
+function estimateIssueComplexity(issue, attempt) {
+  let score = 0;
+  const descLen = (issue.description || "").length;
+  if (descLen > 800) score += 2;
+  else if (descLen > 400) score += 1;
+  else if (descLen < 200) score -= 1;
+  const labelNames = (issue.labels || []).map((l) => l.name.toLowerCase());
+  for (const label of labelNames) {
+    if (SIMPLE_LABELS.some((s) => label.includes(s))) score -= 1;
+    if (COMPLEX_LABELS.some((c) => label.includes(c))) score += 2;
+  }
+  const titleLower = issue.title.toLowerCase();
+  if (SIMPLE_LABELS.some((s) => titleLower.includes(s))) score -= 1;
+  if (COMPLEX_LABELS.some((c) => titleLower.includes(c))) score += 1;
+  if (issue.priority === 1) score += 2;
+  else if (issue.priority === 2) score += 1;
+  if (issue.estimate) {
+    if (issue.estimate >= 5) score += 2;
+    else if (issue.estimate >= 3) score += 1;
+    else if (issue.estimate <= 1) score -= 1;
+  }
+  if (attempt && attempt > 1) score += 2;
+  if (score >= 3) return "complex";
+  if (score >= 1) return "moderate";
+  return "simple";
+}
+function selectModelForIssue(complexity, config) {
+  const modelSetting = config.model || "auto";
+  if (modelSetting !== "auto") return modelSetting;
+  switch (complexity) {
+    case "simple":
+    case "moderate":
+      return "claude-sonnet-4-20250514";
+    case "complex":
+      return "claude-opus-4-20250514";
+  }
+}
 const DEFAULT_CONFIG = {
   activeStates: ["Todo"],
   terminalStates: ["Done", "Cancelled", "Canceled", "Closed"],
@@ -645,6 +809,24 @@ class Conductor {
         await this.runAgent(issue, run);
         run.status = "completed";
         this.completeCount++;
+        let prUrl;
+        if (this.config.autoPR !== false) {
+          const wsKey = this.sanitizeIdentifier(issue.identifier);
+          const branchName = `conductor/${wsKey}`;
+          const url = createPullRequest({
+            branch: branchName,
+            baseBranch: this.config.baseBranch,
+            issueId: issue.identifier,
+            title: issue.title,
+            filesModified: run.filesModified,
+            toolCalls: run.toolCalls,
+            workspacePath: run.workspacePath
+          });
+          if (url) {
+            prUrl = url;
+            console.log(`[${issue.identifier}] PR created: ${url}`);
+          }
+        }
         logAgentOutcome({
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           issue: issue.identifier,
@@ -655,7 +837,9 @@ class Conductor {
           filesModified: run.filesModified,
           tokensUsed: run.tokensUsed,
           durationMs: Date.now() - run.startedAt,
-          hasCommits: true
+          hasCommits: true,
+          labels: issue.labels.map((l) => l.name),
+          prUrl
         });
         await this.runHook(
           "after-run",
@@ -678,6 +862,20 @@ class Conductor {
           error: run.error,
           attempt: run.attempt
         });
+        logAgentOutcome({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          issue: issue.identifier,
+          attempt: run.attempt,
+          outcome: "failure",
+          phase: run.phase,
+          toolCalls: run.toolCalls,
+          filesModified: run.filesModified,
+          tokensUsed: run.tokensUsed,
+          durationMs: Date.now() - run.startedAt,
+          hasCommits: false,
+          labels: issue.labels.map((l) => l.name),
+          errorTail: run.error?.slice(-500)
+        });
         if (this.handleRateLimitError(run.error, issue.identifier)) {
           throw err;
         }
@@ -691,6 +889,23 @@ class Conductor {
           });
         }
         if (run.attempt < maxAttempts && !this.stopping) {
+          const strategy = getRetryStrategy(issue.identifier);
+          if (!strategy.shouldRetry) {
+            console.log(
+              `[${issue.identifier}] Skipping retry: ${strategy.reason}`
+            );
+            logger.info("Retry skipped by intelligence", {
+              identifier: issue.identifier,
+              reason: strategy.reason
+            });
+            throw err;
+          }
+          if (strategy.adjustments.length > 0) {
+            run.retryAdjustments = strategy.adjustments;
+            console.log(
+              `[${issue.identifier}] Retry with adjustments: ${strategy.adjustments.length} hint(s)`
+            );
+          }
           console.log(
             `[${issue.identifier}] Failed (attempt ${run.attempt}), retrying...`
           );
@@ -1024,25 +1239,33 @@ class Conductor {
    */
   runAgentCLI(issue, run) {
     return new Promise((resolve, reject) => {
-      const prompt = this.buildPrompt(issue, run.attempt);
+      const prompt = this.buildPrompt(issue, run.attempt, run.retryAdjustments);
+      const complexity = estimateIssueComplexity(issue, run.attempt);
+      const selectedModel = selectModelForIssue(complexity, this.config);
+      logger.info("Agent model selected", {
+        identifier: issue.identifier,
+        complexity,
+        model: selectedModel || "(default)",
+        reason: this.config.model && this.config.model !== "auto" ? "config override" : `auto: ${complexity} issue`
+      });
       const claudeBin = this.findClaudeBinary();
-      const proc = spawn(
-        claudeBin,
-        [
-          "-p",
-          "--output-format",
-          "stream-json",
-          "--dangerously-skip-permissions",
-          "--settings",
-          '{"hooks":{}}',
-          prompt
-        ],
-        {
-          cwd: run.workspacePath,
-          env: this.buildAgentEnv(issue, run),
-          stdio: ["pipe", "pipe", "pipe"]
-        }
-      );
+      const args = [
+        "-p",
+        "--output-format",
+        "stream-json",
+        "--dangerously-skip-permissions",
+        "--settings",
+        '{"hooks":{}}'
+      ];
+      if (selectedModel) {
+        args.push("--model", selectedModel);
+      }
+      args.push(prompt);
+      const proc = spawn(claudeBin, args, {
+        cwd: run.workspacePath,
+        env: this.buildAgentEnv(issue, run),
+        stdio: ["pipe", "pipe", "pipe"]
+      });
       run.process = proc;
       proc.stdin.end();
       const logStream = this.openAgentLogStream(issue.identifier);
@@ -1146,7 +1369,7 @@ class Conductor {
    */
   runAgentAdapter(issue, run) {
     return new Promise((resolve, reject) => {
-      const prompt = this.buildPrompt(issue, run.attempt);
+      const prompt = this.buildPrompt(issue, run.attempt, run.retryAdjustments);
       const proc = spawn("node", [this.config.appServerPath], {
         cwd: run.workspacePath,
         env: this.buildAgentEnv(issue, run),
@@ -1301,7 +1524,7 @@ class Conductor {
    * Template variables: {{ISSUE_ID}}, {{TITLE}}, {{DESCRIPTION}},
    * {{LABELS}}, {{PRIORITY}}, {{ATTEMPT}}, {{PRIOR_CONTEXT}}
    */
-  buildPrompt(issue, attempt) {
+  buildPrompt(issue, attempt, retryAdjustments) {
     const templatePath = join(
       homedir(),
       ".stackmemory",
@@ -1310,7 +1533,20 @@ class Conductor {
     );
     const priority = ["None", "Urgent", "High", "Medium", "Low"][issue.priority] || "None";
     const labels = issue.labels.length > 0 ? issue.labels.map((l) => l.name).join(", ") : "";
-    const priorContext = attempt > 1 ? `This is attempt ${attempt}. Check .stackmemory/conductor-context.md for context from prior attempts.` : "";
+    const contextParts = [];
+    if (attempt > 1) {
+      contextParts.push(
+        `This is attempt ${attempt}. Check .stackmemory/conductor-context.md for context from prior attempts.`
+      );
+    }
+    if (retryAdjustments && retryAdjustments.length > 0) {
+      contextParts.push(
+        "## Retry Adjustments (from prior failure analysis)",
+        "",
+        ...retryAdjustments.map((a) => `- ${a}`)
+      );
+    }
+    const priorContext = contextParts.join("\n");
     if (existsSync(templatePath)) {
       try {
         let template = readFileSync(templatePath, "utf-8");
@@ -1535,6 +1771,24 @@ class Conductor {
       } catch {
       }
     }
+    let prUrl;
+    if (hasCommits && this.config.autoPR !== false) {
+      const wsKey = this.sanitizeIdentifier(run.issue.identifier);
+      const branchName = `conductor/${wsKey}`;
+      const url = createPullRequest({
+        branch: branchName,
+        baseBranch: this.config.baseBranch,
+        issueId: run.issue.identifier,
+        title: run.issue.title,
+        filesModified: run.filesModified,
+        toolCalls: run.toolCalls,
+        workspacePath: wsPath
+      });
+      if (url) {
+        prUrl = url;
+        console.log(`[${run.issue.identifier}] PR created: ${url}`);
+      }
+    }
     const durationMs = Date.now() - run.startedAt;
     logAgentOutcome({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1547,7 +1801,9 @@ class Conductor {
       tokensUsed: run.tokensUsed,
       durationMs,
       hasCommits,
-      errorTail
+      labels: run.issue.labels.map((l) => l.name),
+      errorTail,
+      prUrl
     });
     if (hasCommits) {
       logger.info("Stale agent had commits, transitioning to In Review", {
@@ -1631,6 +1887,9 @@ class Conductor {
 }
 export {
   Conductor,
+  estimateIssueComplexity,
   getAgentStatusDir,
-  getOutcomesLogPath
+  getOutcomesLogPath,
+  getRetryStrategy,
+  selectModelForIssue
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Lossless, project-scoped memory for AI coding tools. Durable context across sessions with 56 MCP tools, FTS5 search, conductor orchestrator, loop/watch monitoring, snapshot capture, pre-flight overlap checks, Claude/Codex/OpenCode wrappers, Linear sync, and automatic hooks.",
   "engines": {
     "node": ">=20.0.0",
@@ -20,7 +20,6 @@
   "files": [
     "bin",
     "dist/src",
-    "scripts/gepa",
     "scripts/git-hooks",
     "scripts/hooks",
     "scripts/setup",

package/scripts/gepa/.before-optimize.md

@@ -1,112 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-Sol is the monorepo for **Rize**, an automatic time tracking application. The stack consists of:
-- **api/** - Rails 7.1 GraphQL backend (Ruby 3.3.5)
-- **web/** - Next.js 14 React web app (Node 22)
-- **electron/** - Electron desktop app (Node 22)
-- **services/** - Bun-based TypeScript event consumers/workers
-- **vanity/** - Webflow marketing site scripts (deprecated)
-- **voyager/** - Marketing website for home and landing pageas (Next.js)
-- **puppet/** - Puppeteer server for images/PDFs
-- **chrome/** - Chrome browser extension
-- **docs/** - Docusaurus documentation site
-- **zapier/** - Zapier integration
-
-## Development Commands
-
-### Starting Development Environment
-```bash
-# Start all services (requires iTerm2 on macOS)
-./scripts/run-dev.sh
-
-# Or start individually:
-cd api && hivemind Procfile.dev     # Rails + AnyCable + Sidekiq + Clockwork
-cd web && npm run dev               # Next.js dev server
-cd electron && npm run dev          # Electron with hot reload
-cd services && hivemind Procfile.dev # Bun services
-```
-
-### Docker Dependencies (api/docker-compose.yml)
-```bash
-cd api && docker-compose up -d
-# TimescaleDB: localhost:15432
-# Redis: localhost:16379
-# Kafka: localhost:9092
-# MySQL: localhost:13306
-```
-
-### Testing
-```bash
-# API (RSpec)
-cd api && bundle exec rspec
-cd api && bundle exec rspec spec/path/to/file_spec.rb      # Single file
-cd api && bundle exec rspec spec/path/to/file_spec.rb:42   # Single test at line
-
-# Electron (Jest)
-cd electron && npm test
-cd electron && npm run test:watch
-cd electron && npm run test:coverage
-
-# Web - no active tests (exits 0)
-```
-
-### Building
-```bash
-cd api && bundle install && rake db:migrate
-cd web && npm run build       # Runs gql-gen, tailwind, next build
-cd electron && npm run build  # Electron Forge make
-cd services && bun install
-```
-
-### GraphQL Code Generation
-```bash
-cd web && npm run build       # Includes gql codegen
-cd electron && npm run dev    # Runs gql codegen as part of dev
-```
-
-## Architecture
-
-### GraphQL API Structure
-The API exposes two GraphQL endpoints:
-- **api/v1** - Public API (OAuth consumers, Zapier)
-- **private/v1** - Private API (web, electron apps)
-
-Located at `api/app/graphql/{api,private}/v1/`
-
-### Real-time Communication
-- **AnyCable** WebSocket server for subscriptions
-- ActionCable channels in `api/app/channels/`
-- WebSocket config: `api/config/cable.yml` and `api/config/anycable.yml`
-
-### Background Jobs
-- **Sidekiq** for async job processing (`api/config/sidekiq.yml`)
-- **Clockwork** for scheduled jobs (`api/config/clock.rb`)
-
-### Event Streaming
-- **Kafka** for event publishing/consumption
-- Services consume events via `services/consumers/`
-- Kafka config: `api/config/initializers/kafka.rb`
-
-### Databases
-- **Primary PostgreSQL** - Main application data
-- **TimescaleDB** - Time-series data (separate connection in `database.yml`)
-- **MySQL** - Legacy/external integrations
-- **Redis** - Caching, ActionCable, Sidekiq
-
-## Style Guidelines
-
-### JavaScript/TypeScript
-- Use `test()` instead of `it()` in tests
-- Use `toBeCalled()` instead of `toHaveBeenCalledWith()` in jest assertions
-
-## Key Configuration Files
-
-- `api/config/database.yml` - Database connections (primary + timescale)
-- `api/config/cable.yml` - AnyCable WebSocket config
-- `api/Procfile.dev` - Development processes (rails, anycable, sidekiq, clockwork)
-- `sol.code-workspace` - VS Code multi-folder workspace
-- Each project requires its own `.env` file (not in repo)