@stackmemoryai/stackmemory 1.9.0 → 1.10.2

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

@@ -1255,11 +1255,10 @@ class Conductor {
       const claudeBin = this.findClaudeBinary();
       const args = [
         "-p",
+        "--bare",
         "--output-format",
         "stream-json",
-        "--dangerously-skip-permissions",
-        "--settings",
-        '{"hooks":{}}'
+        "--dangerously-skip-permissions"
       ];
       if (selectedModel) {
         args.push("--model", selectedModel);
@@ -1594,10 +1593,32 @@ class Conductor {
       );
     }
     const priorContext = contextParts.join("\n");
-    if (existsSync(templatePath)) {
+    const templateDir = join(
+      __dirname,
+      "..",
+      "..",
+      "..",
+      "scripts",
+      "conductor",
+      "templates"
+    );
+    const labelNames = issue.labels.map((l) => l.name.toLowerCase());
+    let templateName = "implement-feature.md";
+    if (labelNames.includes("bug") || labelNames.includes("fix") || /\bfix\b|\bbug\b/i.test(issue.title)) {
+      templateName = "fix-bug.md";
+    } else if (labelNames.includes("test") || labelNames.includes("coverage") || /\btest\b|\bcoverage\b/i.test(issue.title)) {
+      templateName = "write-tests.md";
+    }
+    const typedTemplatePath = join(templateDir, templateName);
+    const selectedPath = existsSync(typedTemplatePath) ? typedTemplatePath : templatePath;
+    if (existsSync(selectedPath)) {
       try {
-        let template = readFileSync(templatePath, "utf-8");
-        template = template.replace(/\{\{ISSUE_ID\}\}/g, issue.identifier).replace(/\{\{TITLE\}\}/g, issue.title).replace(/\{\{DESCRIPTION\}\}/g, issue.description || "").replace(/\{\{LABELS\}\}/g, labels).replace(/\{\{PRIORITY\}\}/g, priority).replace(/\{\{ATTEMPT\}\}/g, String(attempt)).replace(/\{\{PRIOR_CONTEXT\}\}/g, priorContext);
+        let template = readFileSync(selectedPath, "utf-8");
+        template = template.replace(/^---[\s\S]*?---\n?/, "");
+        template = template.replace(/\{\{ISSUE_ID\}\}/g, issue.identifier).replace(/\{\{TITLE\}\}/g, issue.title).replace(/\{\{DESCRIPTION\}\}/g, issue.description || "").replace(/\{\{LABELS\}\}/g, labels).replace(/\{\{PRIORITY\}\}/g, priority).replace(
+          /\{\{SCOPE\}\}/g,
+          issue.identifier.toLowerCase().replace(/-\d+$/, "")
+        ).replace(/\{\{ATTEMPT\}\}/g, String(attempt)).replace(/\{\{PRIOR_CONTEXT\}\}/g, priorContext);
         return template;
       } catch {
       }

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

@@ -13,6 +13,7 @@ import { ralphDebugger } from "../../integrations/ralph/visualization/ralph-debu
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { trace } from "../../core/trace/index.js";
 import { SystemError, ErrorCode } from "../../core/errors/index.js";
+import { LoopMaxRunner } from "../../integrations/ralph/loopmax.js";
 function createRalphCommand() {
   const ralph = new Command("ralph").description(
     "Ralph Wiggum Loop integration with StackMemory"
@@ -1001,6 +1002,48 @@ ${contextResponse.context}`;
       );
     }
   );
+  ralph.command("loopmax").description(
+    "Aggressive autonomous loop: no planning, just go until tests pass"
+  ).argument("<task>", "What to accomplish").option(
+    "-c, --criteria <criteria>",
+    "Completion criteria",
+    "All tests pass, lint clean, build succeeds"
+  ).option("--no-worktree", "Skip git worktree isolation (work in-place)").option("--max-loops <n>", "Max loop iterations (0=infinite)", "0").option("--max-stuck <n>", "Respawn after N stuck loops", "3").option("--commit-every <n>", "Auto-commit every N tool calls", "25").option("--model <model>", "Claude model to use", "sonnet").action(
+    async (task, options) => {
+      return trace.command(
+        "ralph-loopmax",
+        { task, ...options },
+        async () => {
+          try {
+            console.log("LOOPMAX MODE ACTIVATED");
+            console.log(`Task: ${task}`);
+            console.log(`Criteria: ${options.criteria}`);
+            console.log(
+              `Worktree: ${options.worktree !== false ? "yes" : "no"}`
+            );
+            console.log(`Max loops: ${options.maxLoops || "infinite"}`);
+            console.log("");
+            const runner = new LoopMaxRunner({
+              task,
+              criteria: options.criteria,
+              useWorktree: options.worktree !== false,
+              maxLoops: parseInt(options.maxLoops) || 0,
+              maxStuckBeforeRespawn: parseInt(options.maxStuck) || 3,
+              commitEvery: parseInt(options.commitEvery) || 25,
+              model: options.model,
+              verbose: true
+            });
+            await runner.run();
+            await runner.cleanup();
+          } catch (error) {
+            logger.error("LoopMax failed", error);
+            console.error("LoopMax crashed:", error.message);
+            process.exit(1);
+          }
+        }
+      );
+    }
+  );
   return ralph;
 }
 var ralph_default = createRalphCommand;

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

@@ -0,0 +1,250 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Command } from "commander";
+import chalk from "chalk";
+import Database from "better-sqlite3";
+import * as fs from "fs";
+import * as path from "path";
+import { RuleEngine } from "../../core/rules/rule-engine.js";
+import { filterByScope } from "../../core/rules/built-in-rules.js";
+function getDb() {
+  const smDir = path.join(process.cwd(), ".stackmemory");
+  if (!fs.existsSync(smDir)) {
+    fs.mkdirSync(smDir, { recursive: true });
+  }
+  return new Database(path.join(smDir, "context.db"));
+}
+function severityColor(severity) {
+  switch (severity) {
+    case "error":
+      return chalk.red;
+    case "warn":
+      return chalk.yellow;
+    case "info":
+      return chalk.blue;
+    default:
+      return chalk.gray;
+  }
+}
+function severityIcon(severity) {
+  switch (severity) {
+    case "error":
+      return "x";
+    case "warn":
+      return "!";
+    case "info":
+      return "i";
+    default:
+      return "-";
+  }
+}
+function createRulesCommand() {
+  const cmd = new Command("rule").description(
+    "Manage project rules (lint, commit, migration checks)"
+  );
+  cmd.command("list").description("List configured rules").option("-t, --trigger <type>", "Filter by trigger type").option("-a, --all", "Include disabled rules").option("--json", "Output as JSON").action((options) => {
+    const db = getDb();
+    try {
+      const engine = new RuleEngine(db);
+      const rules = engine.listRules({
+        trigger: options.trigger,
+        enabled: options.all ? false : void 0
+      });
+      if (options.json) {
+        console.log(JSON.stringify(rules, null, 2));
+        return;
+      }
+      if (rules.length === 0) {
+        console.log(chalk.gray("No rules found."));
+        return;
+      }
+      console.log(chalk.cyan(`
+  Rules (${rules.length})
+`));
+      for (const rule of rules) {
+        const enabled = rule.enabled ? chalk.green("on") : chalk.gray("off");
+        const sev = severityColor(rule.severity)(rule.severity.toUpperCase());
+        const builtin = rule.builtin ? chalk.gray(" [built-in]") : "";
+        console.log(
+          `  ${enabled}  ${sev}  ${chalk.white(rule.id)}${builtin}`
+        );
+        console.log(`       ${chalk.gray(rule.description)}`);
+        console.log(
+          `       trigger: ${rule.trigger_type}  scope: ${rule.scope}`
+        );
+        console.log();
+      }
+    } finally {
+      db.close();
+    }
+  });
+  cmd.command("check").description("Run rules against files or commit message").option("-t, --trigger <type>", "Trigger type filter", "on-demand").option("-f, --files <glob>", "File glob to check").option("-m, --commit-message <msg>", "Commit message to check").option("--all", "Run all rules regardless of trigger").option("--json", "Output as JSON").action(
+    (options) => {
+      const db = getDb();
+      try {
+        const engine = new RuleEngine(db);
+        const projectRoot = process.cwd();
+        let files = [];
+        if (options.files) {
+          files = collectFiles(projectRoot, options.files);
+        }
+        const content = /* @__PURE__ */ new Map();
+        for (const file of files) {
+          const fullPath = path.isAbsolute(file) ? file : path.join(projectRoot, file);
+          try {
+            content.set(file, fs.readFileSync(fullPath, "utf-8"));
+          } catch {
+          }
+        }
+        const ctx = {
+          trigger: options.trigger ?? "on-demand",
+          files,
+          content,
+          commitMessage: options.commitMessage ?? "",
+          projectRoot
+        };
+        const result = options.all ? engine.evaluateAll(ctx) : engine.evaluate(ctx);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          process.exitCode = result.passed ? 0 : 1;
+          return;
+        }
+        if (result.passed) {
+          console.log(chalk.green("\n  All rules passed.\n"));
+          return;
+        }
+        console.log(
+          chalk.red(`
+  ${result.violations.length} violation(s) found
+`)
+        );
+        for (const v of result.violations) {
+          const icon = severityIcon(v.severity);
+          const color = severityColor(v.severity);
+          const loc = v.file ? `${v.file}${v.line ? `:${v.line}` : ""}` : "";
+          console.log(`  ${color(`[${icon}]`)} ${chalk.white(v.ruleName)}`);
+          console.log(`     ${v.message}`);
+          if (loc) console.log(`     ${chalk.gray(loc)}`);
+          if (v.suggestion) console.log(`     ${chalk.cyan(v.suggestion)}`);
+          console.log();
+        }
+        const errors = result.violations.filter(
+          (v) => v.severity === "error"
+        );
+        if (errors.length > 0) {
+          process.exitCode = 1;
+        }
+      } finally {
+        db.close();
+      }
+    }
+  );
+  cmd.command("enable <id>").description("Enable a rule").action((id) => {
+    const db = getDb();
+    try {
+      const engine = new RuleEngine(db);
+      if (engine.enableRule(id)) {
+        console.log(chalk.green(`Rule '${id}' enabled.`));
+      } else {
+        console.log(chalk.red(`Rule '${id}' not found.`));
+        process.exitCode = 1;
+      }
+    } finally {
+      db.close();
+    }
+  });
+  cmd.command("disable <id>").description("Disable a rule").action((id) => {
+    const db = getDb();
+    try {
+      const engine = new RuleEngine(db);
+      if (engine.disableRule(id)) {
+        console.log(chalk.yellow(`Rule '${id}' disabled.`));
+      } else {
+        console.log(chalk.red(`Rule '${id}' not found.`));
+        process.exitCode = 1;
+      }
+    } finally {
+      db.close();
+    }
+  });
+  cmd.command("seed").description("Re-seed built-in rules (useful after upgrades)").action(() => {
+    const db = getDb();
+    try {
+      const engine = new RuleEngine(db);
+      const rules = engine.listRules();
+      const builtins = rules.filter((r) => r.builtin);
+      console.log(chalk.green(`Seeded ${builtins.length} built-in rules.`));
+    } finally {
+      db.close();
+    }
+  });
+  cmd.command("add <id>").description("Add a custom rule (metadata only)").requiredOption("-n, --name <name>", "Rule display name").option("-d, --description <desc>", "Rule description", "").option("-t, --trigger <type>", "Trigger type", "on-demand").option("-s, --severity <level>", "Severity level", "warn").option("--scope <glob>", "File scope glob", "**/*").action(
+    (id, options) => {
+      const db = getDb();
+      try {
+        const engine = new RuleEngine(db);
+        engine.getStore().upsert({
+          id,
+          name: options.name,
+          description: options.description,
+          trigger_type: options.trigger,
+          severity: options.severity,
+          scope: options.scope,
+          enabled: 1,
+          builtin: 0
+        });
+        console.log(chalk.green(`Rule '${id}' added.`));
+      } finally {
+        db.close();
+      }
+    }
+  );
+  return cmd;
+}
+function collectFiles(root, pattern) {
+  const results = [];
+  if (pattern.includes("*")) {
+    walkDir(root, root, pattern, results);
+  } else {
+    const fullPath = path.join(root, pattern);
+    if (fs.existsSync(fullPath)) {
+      const stat = fs.statSync(fullPath);
+      if (stat.isFile()) {
+        results.push(pattern);
+      } else if (stat.isDirectory()) {
+        walkDir(fullPath, root, "**/*", results);
+      }
+    }
+  }
+  return results;
+}
+function walkDir(dir, root, pattern, results) {
+  const SKIP = /* @__PURE__ */ new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "coverage",
+    ".stackmemory"
+  ]);
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (SKIP.has(entry.name)) continue;
+      const fullPath = path.join(dir, entry.name);
+      const relPath = path.relative(root, fullPath);
+      if (entry.isDirectory()) {
+        walkDir(fullPath, root, pattern, results);
+      } else if (entry.isFile()) {
+        if (filterByScope([relPath], pattern).length > 0) {
+          results.push(relPath);
+        }
+      }
+    }
+  } catch {
+  }
+}
+export {
+  createRulesCommand
+};