@stackmemoryai/stackmemory 1.6.2 → 1.8.0

package/dist/src/agents/core/agent-task-manager.js

@@ -161,7 +161,7 @@ class AgentTaskManager {
   /**
    * Run a single verifier
    */
-  async runVerifier(verifierId, action, context) {
+  async runVerifier(verifierId, _action, _context) {
     const mockResults = {
       formatter: () => ({
         verifierId: "formatter",
@@ -317,7 +317,7 @@ class AgentTaskManager {
    * Generate feedback from verification results
    */
   generateFeedback(results) {
-    const failed = results.filter((r) => !r.passed);
+    const _failed = results.filter((r) => !r.passed);
     const warnings = results.filter(
       (r) => !r.passed && r.severity === "warning"
     );
@@ -363,7 +363,7 @@ ${warningMessages}`;
       taskId: session.taskId,
       turnCount: session.turnCount
     });
-    const task = this.taskStore.getTask(session.taskId);
+    const _task = this.taskStore.getTask(session.taskId);
     const isComplete = this.assessTaskCompletion(session);
     if (isComplete) {
       await this.completeSession(session);

package/dist/src/agents/verifiers/formatter-verifier.js

@@ -95,7 +95,7 @@ class FormatterVerifier extends BaseVerifier {
   async runFormatter(formatter, context) {
     const command = `${formatter.checkCommand} "${context.filePath}"`;
     try {
-      const { stdout, stderr } = await execAsync(command, {
+      const { _stdout, _stderr } = await execAsync(command, {
         cwd: process.cwd(),
         timeout: this.config.timeout
       });

package/dist/src/agents/verifiers/llm-judge.js

@@ -28,7 +28,7 @@ class LLMJudge extends BaseVerifier {
       ...config
     });
   }
-  shouldActivate(context) {
+  shouldActivate(_context) {
     return true;
   }
   async verify(input, context) {
@@ -185,7 +185,7 @@ class LLMJudge extends BaseVerifier {
       }
     );
   }
-  generateJudgementFeedback(criteria, overallScore, context) {
+  generateJudgementFeedback(criteria, overallScore, _context) {
     if (overallScore >= this.VETO_THRESHOLD) {
       return `Semantic validation PASSED (${(overallScore * 100).toFixed(1)}% confidence). Changes adequately address the requirements.`;
     }

package/dist/src/cli/commands/conductor-traces.js

@@ -0,0 +1,314 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+function classifyErrorText(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("lint") || lower.includes("eslint") || lower.includes("prettier"))
+    return "lint_failure";
+  if (lower.includes("test") && (lower.includes("fail") || lower.includes("error")))
+    return "test_failure";
+  if (lower.includes("timeout") || lower.includes("timed out"))
+    return "timeout";
+  if (lower.includes("conflict") || lower.includes("merge"))
+    return "git_conflict";
+  if (lower.includes("429") || lower.includes("rate limit"))
+    return "rate_limit";
+  if (lower.includes("permission") || lower.includes("EACCES") || lower.includes("not found"))
+    return "permission_or_missing";
+  if (lower.includes("build") && lower.includes("error"))
+    return "build_failure";
+  return null;
+}
+function getTracesDbPath() {
+  return join(homedir(), ".stackmemory", "conductor", "traces.db");
+}
+function openTracesDb(dbPath) {
+  const path = dbPath ?? getTracesDbPath();
+  mkdirSync(join(path, ".."), { recursive: true });
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS conductor_traces (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      issue_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      attempt INTEGER NOT NULL,
+      turn_number INTEGER NOT NULL,
+      timestamp INTEGER NOT NULL,
+      phase TEXT,
+      tool_names TEXT,
+      tool_count INTEGER DEFAULT 0,
+      files_modified INTEGER DEFAULT 0,
+      input_tokens INTEGER DEFAULT 0,
+      output_tokens INTEGER DEFAULT 0,
+      cache_creation_tokens INTEGER DEFAULT 0,
+      cache_read_tokens INTEGER DEFAULT 0,
+      message_preview TEXT,
+      event_json TEXT NOT NULL,
+      UNIQUE(session_id, turn_number)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_traces_issue
+      ON conductor_traces(issue_id, attempt);
+    CREATE INDEX IF NOT EXISTS idx_traces_session
+      ON conductor_traces(session_id);
+    CREATE INDEX IF NOT EXISTS idx_traces_phase
+      ON conductor_traces(phase);
+    CREATE INDEX IF NOT EXISTS idx_traces_timestamp
+      ON conductor_traces(timestamp DESC);
+  `);
+  return db;
+}
+function withDb(db, fn) {
+  const ownDb = db ?? openTracesDb();
+  try {
+    return fn(ownDb);
+  } finally {
+    if (!db) ownDb.close();
+  }
+}
+class TraceCollector {
+  db;
+  ownsDb;
+  sessionId;
+  issueId;
+  attempt;
+  turnCounter = 0;
+  insertStmt;
+  constructor(opts) {
+    this.issueId = opts.issueId;
+    this.attempt = opts.attempt;
+    this.sessionId = `${opts.issueId}-${opts.attempt}-${randomUUID().slice(0, 8)}`;
+    this.ownsDb = !opts.db;
+    this.db = opts.db ?? openTracesDb();
+    this.insertStmt = this.db.prepare(`
+      INSERT INTO conductor_traces (
+        issue_id, session_id, attempt, turn_number, timestamp,
+        phase, tool_names, tool_count, files_modified,
+        input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+        message_preview, event_json
+      ) VALUES (
+        @issue_id, @session_id, @attempt, @turn_number, @timestamp,
+        @phase, @tool_names, @tool_count, @files_modified,
+        @input_tokens, @output_tokens, @cache_creation_tokens, @cache_read_tokens,
+        @message_preview, @event_json
+      )
+    `);
+  }
+  get session() {
+    return this.sessionId;
+  }
+  /**
+   * Record a turn using pre-extracted data from the orchestrator's stream parser.
+   * Avoids re-iterating content blocks — the caller already did that work.
+   */
+  recordTurn(turnData, phase, eventJson) {
+    this.insertStmt.run({
+      issue_id: this.issueId,
+      session_id: this.sessionId,
+      attempt: this.attempt,
+      turn_number: this.turnCounter++,
+      timestamp: Date.now(),
+      phase: phase ?? null,
+      tool_names: turnData.toolNames.length > 0 ? JSON.stringify(turnData.toolNames) : null,
+      tool_count: turnData.toolCount,
+      files_modified: turnData.filesModified,
+      input_tokens: turnData.inputTokens,
+      output_tokens: turnData.outputTokens,
+      cache_creation_tokens: turnData.cacheCreationTokens,
+      cache_read_tokens: turnData.cacheReadTokens,
+      message_preview: turnData.textPreview,
+      event_json: eventJson
+    });
+  }
+  /** Record a result event (final output) */
+  recordResult(event) {
+    const resultText = typeof event.result === "string" ? event.result : JSON.stringify(event.result);
+    this.insertStmt.run({
+      issue_id: this.issueId,
+      session_id: this.sessionId,
+      attempt: this.attempt,
+      turn_number: this.turnCounter++,
+      timestamp: Date.now(),
+      phase: "result",
+      tool_names: null,
+      tool_count: 0,
+      files_modified: 0,
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_creation_tokens: 0,
+      cache_read_tokens: 0,
+      message_preview: (resultText || "").slice(0, 500),
+      event_json: JSON.stringify(event).slice(0, 5e4)
+    });
+  }
+  /** Close the DB connection only if we own it */
+  close() {
+    if (!this.ownsDb) return;
+    try {
+      this.db.close();
+    } catch {
+    }
+  }
+}
+function stringifyEventTruncated(event) {
+  return JSON.stringify(event, (_key, value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const obj = value;
+      if (obj.type === "tool_use" && obj.input) {
+        const inputStr = JSON.stringify(obj.input);
+        if (inputStr.length > 2e3) {
+          return {
+            ...obj,
+            input: { _truncated: true, length: inputStr.length }
+          };
+        }
+      }
+      if (obj.type === "tool_result" && obj.content) {
+        const contentStr = typeof obj.content === "string" ? obj.content : JSON.stringify(obj.content);
+        if (contentStr.length > 2e3) {
+          return { ...obj, content: `[truncated: ${contentStr.length} chars]` };
+        }
+      }
+    }
+    return value;
+  });
+}
+function listSessions(issueId, db) {
+  return withDb(db, (d) => {
+    const rows = d.prepare(
+      `
+      SELECT
+        issue_id,
+        session_id,
+        attempt,
+        COUNT(*) as total_turns,
+        SUM(tool_count) as total_tool_calls,
+        SUM(files_modified) as total_files_modified,
+        SUM(input_tokens) as total_input_tokens,
+        SUM(output_tokens) as total_output_tokens,
+        GROUP_CONCAT(DISTINCT phase) as phases,
+        MIN(timestamp) as started_at,
+        MAX(timestamp) as ended_at
+      FROM conductor_traces
+      WHERE issue_id = ?
+      GROUP BY session_id
+      ORDER BY started_at DESC
+    `
+    ).all(issueId);
+    return rows.map((r) => ({
+      issue_id: r.issue_id,
+      session_id: r.session_id,
+      attempt: r.attempt,
+      total_turns: r.total_turns,
+      total_tool_calls: r.total_tool_calls || 0,
+      total_files_modified: r.total_files_modified || 0,
+      total_input_tokens: r.total_input_tokens || 0,
+      total_output_tokens: r.total_output_tokens || 0,
+      phases: (r.phases || "").split(",").filter(Boolean),
+      started_at: r.started_at,
+      ended_at: r.ended_at,
+      duration_ms: r.ended_at - r.started_at
+    }));
+  });
+}
+function getSessionTurns(sessionId, db) {
+  return withDb(
+    db,
+    (d) => d.prepare(
+      `
+      SELECT * FROM conductor_traces
+      WHERE session_id = ?
+      ORDER BY turn_number ASC
+    `
+    ).all(sessionId)
+  );
+}
+function getPhaseBreakdown(sessionId, db) {
+  return withDb(
+    db,
+    (d) => d.prepare(
+      `
+      SELECT
+        phase,
+        COUNT(*) as turns,
+        SUM(tool_count) as tool_calls,
+        SUM(input_tokens) as input_tokens,
+        SUM(output_tokens) as output_tokens
+      FROM conductor_traces
+      WHERE session_id = ? AND phase IS NOT NULL
+      GROUP BY phase
+      ORDER BY MIN(turn_number) ASC
+    `
+    ).all(sessionId)
+  );
+}
+function getToolFrequencies(issueId, db) {
+  return withDb(
+    db,
+    (d) => d.prepare(
+      `
+      SELECT j.value as tool_name, COUNT(*) as count
+      FROM conductor_traces, json_each(tool_names) j
+      WHERE issue_id = ? AND tool_names IS NOT NULL
+      GROUP BY j.value
+      ORDER BY count DESC
+    `
+    ).all(issueId)
+  );
+}
+function getFailureTurns(issueId, tailCount = 5, db) {
+  return withDb(
+    db,
+    (d) => d.prepare(
+      `
+      SELECT t.* FROM conductor_traces t
+      INNER JOIN (
+        SELECT session_id, MAX(turn_number) as max_turn
+        FROM conductor_traces
+        WHERE issue_id = ?
+        GROUP BY session_id
+      ) latest ON t.session_id = latest.session_id
+        AND t.turn_number > latest.max_turn - ?
+      WHERE t.issue_id = ?
+      ORDER BY t.session_id, t.turn_number ASC
+    `
+    ).all(issueId, tailCount, issueId)
+  );
+}
+function getTraceStats(db) {
+  return withDb(
+    db,
+    (d) => d.prepare(
+      `
+      SELECT
+        COUNT(DISTINCT session_id) as total_sessions,
+        COUNT(*) as total_turns,
+        SUM(input_tokens) as total_input_tokens,
+        SUM(output_tokens) as total_output_tokens,
+        COUNT(DISTINCT issue_id) as issues_traced
+      FROM conductor_traces
+    `
+    ).get()
+  );
+}
+export {
+  TraceCollector,
+  classifyErrorText,
+  getFailureTurns,
+  getPhaseBreakdown,
+  getSessionTurns,
+  getToolFrequencies,
+  getTraceStats,
+  getTracesDbPath,
+  listSessions,
+  openTracesDb,
+  stringifyEventTruncated
+};

package/dist/src/cli/commands/context-rehydrate.js

@@ -289,7 +289,7 @@ async function listCheckpoints() {
       console.log(
         "\u{1F4A1} Verify: stackmemory context rehydrate --verify -c <checkpoint-id>"
       );
-    } catch (err) {
+    } catch {
       console.log("\u{1F4ED} No rehydration checkpoints directory found");
       console.log(
         "\u{1F4A1} Create first checkpoint with: stackmemory context rehydrate --create"
@@ -382,7 +382,7 @@ async function captureStackTraces() {
   try {
     const traces = [];
     const fs = await import("fs/promises");
-    const { execSync } = await import("child_process");
+    const { _execSync } = await import("child_process");
     const stackMemoryLogs = [
       ".stackmemory/error.log",
       ".stackmemory/compaction.log",

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

@@ -10,7 +10,7 @@ function createLogCommand() {
   const log = new Command("log").alias("history").description("View recent activity log").option("-n, --lines <n>", "Number of entries to show", "20").option("-t, --type <type>", "Filter by type (task, frame, event, sync)").option("-f, --follow", "Follow log in real-time").action(async (options) => {
     const projectRoot = process.cwd();
     const dbPath = join(projectRoot, ".stackmemory", "context.db");
-    const tasksPath = join(projectRoot, ".stackmemory", "tasks.jsonl");
+    const _tasksPath = join(projectRoot, ".stackmemory", "tasks.jsonl");
     if (!existsSync(dbPath)) {
       console.log(
         '\u274C StackMemory not initialized. Run "stackmemory init" first.'

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

@@ -99,7 +99,7 @@ async function runOnboarding() {
         console.log(chalk.gray(`Opening signup page: ${signupUrl}`));
         const mod = await import("open");
         await mod.default(signupUrl);
-      } catch (e) {
+      } catch {
         console.log(
           chalk.yellow(
             "Could not open browser automatically. Please sign up and obtain your DATABASE_URL."
@@ -379,7 +379,7 @@ DATABASE_URL=${config.databaseUrl}
           "    Tip: export DATABASE_URL from this file in your shell profile."
         )
       );
-    } catch (e) {
+    } catch {
       console.log(chalk.yellow("  \u26A0 Could not write hosted DB env file"));
     }
   }
@@ -410,7 +410,7 @@ exec stackmemory "$@"
       execFileSync("ln", ["-s", sourcePath, binPath]);
       console.log(chalk.green("  \u2713 Created claude-sm command"));
     }
-  } catch (error) {
+  } catch {
     console.log(
       chalk.yellow("  \u26A0 Could not create claude-sm symlink (may need sudo)")
     );
@@ -506,7 +506,7 @@ fi
       execFileSync("ln", ["-s", codexSourcePath, codexBinPath]);
       console.log(chalk.green("  \u2713 Created codex-sm command"));
     }
-  } catch (error) {
+  } catch {
     console.log(
       chalk.yellow("  \u26A0 Could not create codex-sm symlink (may need sudo)")
     );