@stackmemoryai/stackmemory 1.10.5 → 1.14.0

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

@@ -0,0 +1,161 @@
+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 { networkInterfaces } from "os";
+import {
+  PortalServer,
+  ensureToken,
+  readStatus,
+  stopRunning
+} from "../../features/portal/index.js";
+import { DEFAULT_PORTAL_CONFIG } from "../../features/portal/types.js";
+function tailscaleIp() {
+  const nets = networkInterfaces();
+  for (const addrs of Object.values(nets)) {
+    for (const a of addrs ?? []) {
+      if (a.family === "IPv4" && a.address.startsWith("100.")) {
+        return a.address;
+      }
+    }
+  }
+  return void 0;
+}
+function printAccessUrls(host, port, token) {
+  const path = token ? `/?token=${token}` : "/";
+  const ts = tailscaleIp();
+  console.log(chalk.cyan("\nAccess your agent:"));
+  if (ts) {
+    console.log(
+      chalk.green(`  http://${ts}:${port}${path}`) + chalk.gray("  (tailnet)")
+    );
+  }
+  console.log(chalk.gray(`  http://localhost:${port}${path}`));
+  if (!ts && host === "0.0.0.0") {
+    console.log(
+      chalk.gray(
+        "  Tip: connect this machine to Tailscale, then use its 100.x address."
+      )
+    );
+  }
+}
+function createPortalCommand() {
+  const cmd = new Command("portal").description("Browser terminal into a persistent tmux Claude Code session").addHelpText(
+    "after",
+    `
+Examples:
+  stackmemory portal start                 Start the portal (foreground)
+  stackmemory portal start --port 8080     Use a custom port
+  stackmemory portal start --command "claude --resume"
+  stackmemory portal start --no-auth       Disable token (Tailscale-only)
+  stackmemory portal status                Show running status + access URL
+  stackmemory portal stop                  Stop a backgrounded portal
+  stackmemory portal token                 Print the access token
+
+Run it on a VPS behind Tailscale for 24/7 agents. See docs/guides/PORTAL.md.
+`
+  );
+  cmd.command("start").description("Start the portal server (runs in the foreground)").option(
+    "--port <number>",
+    "Port to listen on",
+    String(DEFAULT_PORTAL_CONFIG.port)
+  ).option("--host <host>", "Interface to bind", DEFAULT_PORTAL_CONFIG.host).option(
+    "--session <name>",
+    "tmux session name",
+    DEFAULT_PORTAL_CONFIG.session
+  ).option(
+    "--command <cmd>",
+    "Command tmux runs in the session",
+    DEFAULT_PORTAL_CONFIG.command
+  ).option("--cwd <dir>", "Working directory for the session").option("--no-auth", "Disable token auth (rely on Tailscale)").action(async (options) => {
+    const server = new PortalServer({
+      port: parseInt(options.port, 10),
+      host: options.host,
+      session: options.session,
+      command: options.command,
+      cwd: options.cwd,
+      noAuth: options.auth === false
+    });
+    try {
+      const status = await server.start();
+      const cfg = server.getConfig();
+      console.log(chalk.green("\u2713 StackMemory Portal started"));
+      console.log(
+        chalk.gray(
+          `  Session: ${cfg.session}  (tmux new-session -A -s ${cfg.session})`
+        )
+      );
+      console.log(chalk.gray(`  Command: ${cfg.command}`));
+      console.log(chalk.gray(`  Listening: ${cfg.host}:${status.port}`));
+      if (cfg.noAuth) {
+        console.log(
+          chalk.yellow("  Auth: disabled (anyone on the network can connect)")
+        );
+      }
+      printAccessUrls(cfg.host, cfg.port, cfg.token);
+      console.log(
+        chalk.gray(
+          "\nPress Ctrl+C to stop the portal (your tmux session keeps running)."
+        )
+      );
+    } catch (error) {
+      console.error(
+        chalk.red("Failed to start portal:"),
+        error.message
+      );
+      process.exit(1);
+    }
+    const shutdown = async () => {
+      console.log(chalk.gray("\nShutting down portal\u2026"));
+      await server.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  });
+  cmd.command("status").description("Show portal status and access URL").action(() => {
+    const status = readStatus();
+    if (!status.running) {
+      console.log(chalk.yellow("Portal is not running"));
+      console.log(chalk.gray("  Start with: stackmemory portal start"));
+      return;
+    }
+    console.log(chalk.green("Portal is running"));
+    console.log(chalk.gray(`  PID: ${status.pid}`));
+    console.log(chalk.gray(`  Session: ${status.session}`));
+    console.log(chalk.gray(`  Listening: ${status.host}:${status.port}`));
+    if (status.startedAt) {
+      const up = Math.floor((Date.now() - status.startedAt) / 1e3);
+      console.log(chalk.gray(`  Uptime: ${formatUptime(up)}`));
+    }
+    const token = ensureToken();
+    if (status.port)
+      printAccessUrls(status.host ?? "0.0.0.0", status.port, token);
+  });
+  cmd.command("stop").description("Stop a running portal server").action(() => {
+    if (stopRunning()) {
+      console.log(chalk.green("\u2713 Portal stopped"));
+    } else {
+      console.log(chalk.yellow("Portal is not running"));
+    }
+  });
+  cmd.command("token").description("Print the portal access token (auto-generated on first use)").action(() => {
+    console.log(ensureToken());
+  });
+  return cmd;
+}
+function formatUptime(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  if (seconds < 86400) {
+    const h = Math.floor(seconds / 3600);
+    return `${h}h ${Math.floor(seconds % 3600 / 60)}m`;
+  }
+  const d = Math.floor(seconds / 86400);
+  return `${d}d ${Math.floor(seconds % 86400 / 3600)}h`;
+}
+export {
+  createPortalCommand
+};

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

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+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 * as fs from "fs";
+import * as path from "path";
+const DIRS = ["company", "wiki", "skills", "clients", "raw", ".stackmemory"];
+const TEMPLATES = {
+  "company/voice.md": "---\nname: Voice Guide\ndescription: How we write and communicate\n---\n\n# Voice Guide\n\n## Tone\n- [Your tone descriptors here]\n\n## Words we use\n- [Preferred terms]\n\n## Words we avoid\n- [Banned terms]\n",
+  "company/team.md": "---\nname: Team Directory\ndescription: Who works here and what they do\n---\n\n# Team\n\n| Name | Role | Contact |\n|------|------|---------||\n",
+  "company/design.md": "---\nname: Design System\ndescription: Logos, colors, components\n---\n\n# Design System\n\n## Colors\n- Primary:\n- Secondary:\n\n## Logos\n- [paths or URLs]\n",
+  "wiki/README.md": "# Wiki \u2014 SOPs & Playbooks\n\nAdd markdown files here. Files with skill frontmatter become Claude skills.\n\nSOPs should follow the Company OS schema:\n\n- `## Objective`\n- `## Procedure`\n- `## Verification`\n- `## Non-compliance`\n\nEach SOP must reference a PROSE Expectation from `docs/specs/COMPANY-OS-PROSE.md`.\n",
+  "wiki/SOP-301-onboarding.md": "# SOP-301 New Hire Onboarding\n\n**Owner:** People Ops  \n**Status:** Active  \n**Related PROSE Expectation:** [E.1 Onboarding completeness](../docs/specs/COMPANY-OS-PROSE.md#e1-onboarding-completeness)\n\n## Objective\nEnsure every new hire has accounts, hardware, and access documented before their start date.\n\n## Procedure\n\n1. **Pre-start checklist (5 days before)**\n   - Hiring manager opens an onboarding ticket.\n   - People Ops confirms laptop requirement and shipping address.\n\n2. **Account provisioning (3 days before)**\n   - IT creates SSO account and adds the hire to default groups.\n   - People Ops sends welcome email with first-week schedule.\n\n3. **Access verification (1 day before)**\n   - Hiring manager verifies the hire can log in to primary systems.\n\n## Verification\n\n- Run audit: `stackmemory company-os audit onboarding`\n- Expected result: 100% of hires in last 30 days have completed checklist.\n\n## Non-compliance\n\nOnboarding missing SSO access or hardware assignment on start date is non-compliant.\n",
+  "skills/README.md": '# Skills\n\nClaude skill-packs. Each file is a markdown instruction set with frontmatter.\n\n```yaml\n---\nname: skill-name\ndescription: What this skill does\nactivates_on: [keyword1, keyword2]\nversion: "1.0"\n---\n```\n',
+  "clients/README.md": "# Clients\n\nEach client gets a subfolder with icp.md, voice.md, campaigns/, context/.\n",
+  "raw/README.md": "# Raw\n\nUnstructured data: transcripts, research, scrapes.\n",
+  ".stackmemory/config.yml": `# StackMemory Company OS Configuration
+
+sources:
+  - path: ./company
+    type: reference
+  - path: ./wiki
+    type: sop
+  - path: ./skills
+    type: skill
+  - path: ./raw
+    type: raw
+
+tenants: {}
+
+freshness_threshold_hours: 24
+
+skill_rot:
+  enabled: true
+  stale_days: 90
+  correction_threshold: 5
+`
+};
+function createScaffoldCommand() {
+  const cmd = new Command("scaffold").alias("os-init").description(
+    "Scaffold a Company OS folder structure for local context management"
+  ).option("--force", "Overwrite existing template files").option("--dir <path>", "Target directory (default: current directory)").action(async (options) => {
+    const targetDir = path.resolve(options.dir || process.cwd());
+    const created = [];
+    const skipped = [];
+    for (const dir of DIRS) {
+      const fullPath = path.join(targetDir, dir);
+      if (!fs.existsSync(fullPath)) {
+        fs.mkdirSync(fullPath, { recursive: true });
+        created.push(dir + "/");
+      }
+    }
+    for (const [relPath, content] of Object.entries(TEMPLATES)) {
+      const fullPath = path.join(targetDir, relPath);
+      const dir = path.dirname(fullPath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      if (fs.existsSync(fullPath) && !options.force) {
+        skipped.push(relPath);
+        continue;
+      }
+      fs.writeFileSync(fullPath, content, "utf-8");
+      created.push(relPath);
+    }
+    console.log(chalk.cyan("\n  Company OS scaffolded\n"));
+    if (created.length) {
+      console.log(chalk.green(`  Created: ${created.length} files/dirs`));
+      for (const f of created) {
+        console.log(chalk.gray(`    + ${f}`));
+      }
+    }
+    if (skipped.length) {
+      console.log(chalk.gray(`  Skipped: ${skipped.length} (already exist)`));
+    }
+    console.log();
+    console.log(chalk.gray("  Next steps:"));
+    console.log(
+      chalk.gray("    1. Edit company/voice.md with your tone and brand")
+    );
+    console.log(chalk.gray("    2. Add skills to skills/ as markdown files"));
+    console.log(
+      chalk.gray("    3. Set COMPANY_OS_ROOT=. in .env for MCP auto-indexing")
+    );
+    console.log();
+  });
+  return cmd;
+}
+export {
+  createScaffoldCommand
+};

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

@@ -7,12 +7,16 @@ import Database from "better-sqlite3";
 import { join } from "path";
 import { existsSync } from "fs";
 import { z } from "zod";
+import { CrossProjectSearch } from "../../core/cross-search/cross-project-search.js";
 const SearchQuerySchema = z.string().min(1, "Search query is required").max(500, "Search query too long (max 500 characters)").transform((val) => {
   return val.replace(/[%_\\]/g, "\\$&");
 });
 const LimitSchema = z.string().transform((val) => parseInt(val, 10)).pipe(z.number().int().min(1).max(100).default(20));
 function createSearchCommand() {
-  const search = new Command("search").alias("find").description("Search across tasks and context").argument("<query>", "Search query").option("-t, --tasks", "Search only tasks").option("-c, --context", "Search only context").option("-l, --limit <n>", "Limit results", "20").action(async (rawQuery, options) => {
+  const search = new Command("search").alias("find").description("Search across tasks and context").argument("<query>", "Search query").option("-t, --tasks", "Search only tasks").option("-c, --context", "Search only context").option(
+    "-a, --all-projects",
+    "Search across all registered project databases"
+  ).option("-l, --limit <n>", "Limit results", "20").action(async (rawQuery, options) => {
     const projectRoot = process.cwd();
     const dbPath = join(projectRoot, ".stackmemory", "context.db");
     if (!existsSync(dbPath)) {
@@ -34,6 +38,41 @@ function createSearchCommand() {
       }
       return;
     }
+    if (options.allProjects) {
+      console.log(
+        `
+\u{1F50D} Searching across all projects for "${rawQuery}"...
+`
+      );
+      const crossSearch = new CrossProjectSearch();
+      const results = await crossSearch.search({
+        query: rawQuery,
+        limit
+      });
+      if (results.length === 0) {
+        console.log("No results found across project databases.\n");
+        console.log(
+          'Tip: Run "stackmemory search --all-projects" after "stackmemory projects scan" to discover databases.'
+        );
+        return;
+      }
+      console.log(`\u{1F4C1} Cross-Project Results (${results.length})
+`);
+      for (const r of results) {
+        const date = new Date(r.createdAt).toLocaleDateString();
+        console.log(
+          `  [${r.projectName}] ${r.name} (${r.type}, score: ${r.score.toFixed(3)})`
+        );
+        if (r.digestText) {
+          console.log(`    ${r.digestText.slice(0, 100)}`);
+        }
+        console.log(`    ${date} | ${r.projectPath}`);
+      }
+      console.log(`
+Found ${results.length} results.
+`);
+      return;
+    }
     const db = new Database(dbPath);
     const searchTasks = !options.context || options.tasks;
     const searchContext = !options.tasks || options.context;

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

@@ -241,13 +241,7 @@ function createDoctorCommand() {
       const toolDefs = new MCPToolDefinitions();
       const allTools = toolDefs.getAllToolDefinitions();
       const toolNames = allTools.map((t) => t.name);
-      const expectedTools = [
-        "sm_digest",
-        "cord_spawn",
-        "team_search",
-        "get_context",
-        "create_task"
-      ];
+      const expectedTools = ["sm_digest", "get_context", "create_task"];
       const missing = expectedTools.filter((t) => !toolNames.includes(t));
       if (missing.length === 0) {
         results.push({
@@ -684,7 +678,6 @@ function createSetupPluginsCommand() {
     }
     console.log(chalk.gray(`Source: ${sourcePluginsDir}
 `));
-    const plugins = ["stackmemory", "ralph-wiggum"];
     let installed = 0;
     for (const plugin of plugins) {
       const sourcePath = join(sourcePluginsDir, plugin);
@@ -741,9 +734,7 @@ function createSetupPluginsCommand() {
       console.log(
         chalk.white("  /sm-help      ") + chalk.gray("Show all commands")
       );
-      console.log(
-        chalk.white("  /ralph-loop   ") + chalk.gray("Start Ralph iteration loop")
-      );
+      console.log(chalk.gray("Start Ralph iteration loop"));
     } else {
       console.log(chalk.yellow("No plugins installed"));
     }
@@ -1011,14 +1002,190 @@ Logs: ${logDir}/remote-mcp.log`));
   });
   return cmd;
 }
+function createSetupCommandsCommand() {
+  const cmd = new Command("setup-commands");
+  cmd.description("Install StackMemory command packs for Claude Code").argument("[pack]", "Pack name to install (default: core)", "core").option("--list", "List available packs and their commands").option("--force", "Overwrite existing command files").option("--uninstall", "Remove installed commands").option("--dry-run", "Show what would be installed without making changes").action(async (pack, options) => {
+    const commandsDir = join(CLAUDE_DIR, "commands");
+    const possiblePaths = [
+      join(process.cwd(), "packs"),
+      join(__dirname, "..", "..", "..", "packs")
+    ];
+    try {
+      const globalRoot = execSync("npm root -g", {
+        encoding: "utf-8"
+      }).trim();
+      possiblePaths.push(
+        join(globalRoot, "@stackmemoryai", "stackmemory", "packs")
+      );
+    } catch {
+    }
+    let packsDir;
+    for (const p of possiblePaths) {
+      if (existsSync(p)) {
+        packsDir = p;
+        break;
+      }
+    }
+    if (!packsDir) {
+      console.log(chalk.red("Could not find packs directory"));
+      process.exit(1);
+    }
+    if (options.list) {
+      console.log(chalk.cyan("\nAvailable command packs:\n"));
+      const packs = readdirSync(packsDir).filter(
+        (d) => existsSync(join(packsDir, d, "manifest.json"))
+      );
+      for (const p of packs) {
+        const manifest2 = JSON.parse(
+          readFileSync(join(packsDir, p, "manifest.json"), "utf8")
+        );
+        console.log(
+          chalk.white(`  ${manifest2.name}`) + chalk.gray(` v${manifest2.version} \u2014 ${manifest2.description}`)
+        );
+        if (manifest2.commands?.public) {
+          for (const cmd2 of manifest2.commands.public) {
+            console.log(
+              chalk.green(`    /${cmd2.name}`) + chalk.gray(` \u2014 ${cmd2.description}`)
+            );
+          }
+        }
+        if (manifest2.commands?.internal) {
+          console.log(
+            chalk.gray(
+              `    + ${manifest2.commands.internal.length} internal deps`
+            )
+          );
+        }
+        console.log("");
+      }
+      return;
+    }
+    const packDir = join(packsDir, pack);
+    const manifestPath = join(packDir, "manifest.json");
+    if (!existsSync(manifestPath)) {
+      console.log(chalk.red(`Pack "${pack}" not found`));
+      console.log(chalk.gray("Run: stackmemory setup-commands --list"));
+      process.exit(1);
+    }
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    const allCommands = [
+      ...manifest.commands?.public || [],
+      ...manifest.commands?.internal || []
+    ];
+    if (options.uninstall) {
+      console.log(
+        chalk.cyan(
+          `
+Uninstalling pack: ${manifest.name} v${manifest.version}
+`
+        )
+      );
+      let removed = 0;
+      for (const cmd2 of allCommands) {
+        const targetPath = join(commandsDir, `${cmd2.name}.md`);
+        if (existsSync(targetPath)) {
+          if (options.dryRun) {
+            console.log(chalk.gray(`  Would remove: /${cmd2.name}`));
+          } else {
+            rmSync(targetPath, { force: true });
+            console.log(chalk.green(`  [OK]`) + ` Removed /${cmd2.name}`);
+            removed++;
+          }
+        }
+      }
+      console.log(chalk.green(`
+Removed ${removed} command(s)`));
+      return;
+    }
+    console.log(
+      chalk.cyan(`
+Installing pack: ${manifest.name} v${manifest.version}
+`)
+    );
+    console.log(chalk.gray(`${manifest.description}
+`));
+    if (!existsSync(commandsDir)) {
+      if (options.dryRun) {
+        console.log(chalk.gray(`Would create: ${commandsDir}`));
+      } else {
+        mkdirSync(commandsDir, { recursive: true });
+      }
+    }
+    let installed = 0;
+    let skipped = 0;
+    for (const cmd2 of allCommands) {
+      const sourcePath = join(packDir, cmd2.file);
+      const targetPath = join(commandsDir, `${cmd2.name}.md`);
+      const isPublic = manifest.commands?.public?.some(
+        (c) => c.name === cmd2.name
+      );
+      if (!existsSync(sourcePath)) {
+        console.log(
+          chalk.red(`  [MISS] /${cmd2.name}`) + chalk.gray(` \u2014 source not found: ${cmd2.file}`)
+        );
+        continue;
+      }
+      if (existsSync(targetPath) && !options.force) {
+        console.log(
+          chalk.gray(`  [SKIP] /${cmd2.name} \u2014 exists (use --force)`)
+        );
+        skipped++;
+        continue;
+      }
+      if (options.dryRun) {
+        const tag = isPublic ? chalk.green("PUBLIC") : chalk.gray("INTERNAL");
+        console.log(
+          chalk.gray(`  Would install: `) + chalk.white(`/${cmd2.name}`) + ` [${tag}]`
+        );
+        installed++;
+        continue;
+      }
+      if (existsSync(targetPath)) {
+        rmSync(targetPath, { force: true });
+      }
+      try {
+        execSync(`ln -s "${sourcePath}" "${targetPath}"`, {
+          encoding: "utf-8"
+        });
+        const tag = isPublic ? chalk.green("PUBLIC") : chalk.gray("INTERNAL");
+        console.log(
+          chalk.green(`  [OK]`) + ` /${cmd2.name} [${tag}]` + chalk.gray(` \u2014 ${cmd2.description}`)
+        );
+        installed++;
+      } catch (err) {
+        console.log(
+          chalk.red(`  [ERROR] /${cmd2.name}`) + chalk.gray(` \u2014 ${err.message}`)
+        );
+      }
+    }
+    console.log("");
+    if (installed > 0) {
+      console.log(chalk.green(`Installed ${installed} command(s)`));
+    }
+    if (skipped > 0) {
+      console.log(chalk.gray(`Skipped ${skipped} (already exist)`));
+    }
+    if (!options.dryRun && installed > 0) {
+      console.log(chalk.cyan("\nAvailable commands in Claude Code:"));
+      for (const cmd2 of manifest.commands?.public || []) {
+        console.log(
+          chalk.white(`  /${cmd2.name}`) + chalk.gray(`  ${cmd2.description}`)
+        );
+      }
+    }
+  });
+  return cmd;
+}
 function registerSetupCommands(program) {
   program.addCommand(createSetupMCPCommand());
   program.addCommand(createDoctorCommand());
   program.addCommand(createSetupPluginsCommand());
   program.addCommand(createSetupRemoteCommand());
+  program.addCommand(createSetupCommandsCommand());
 }
 export {
   createDoctorCommand,
+  createSetupCommandsCommand,
   createSetupMCPCommand,
   createSetupPluginsCommand,
   createSetupRemoteCommand,

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

@@ -46,6 +46,9 @@ function getVersion() {
   _version = "0.0.0";
   return _version;
 }
+function collectRepeatedOption(value, previous = []) {
+  return [...previous, value];
+}
 function _getEnv(key, defaultValue) {
   const value = process.env[key];
   if (value === void 0) {
@@ -309,7 +312,12 @@ function createSkillsCommand() {
     "--execute",
     "Execute implementer (codex-sm) instead of dry-run",
     false
-  ).option("--audit-dir <path>", "Persist spike results to directory").option("--record-frame", "Record as real frame with anchors", false).option(
+  ).option("--audit-dir <path>", "Persist spike results to directory").option(
+    "--verify <cmd>",
+    "Verification command to run after each implementation attempt; repeatable",
+    collectRepeatedOption,
+    []
+  ).option("--record-frame", "Record as real frame with anchors", false).option(
     "--record",
     "Record plan & critique into StackMemory context",
     false
@@ -329,6 +337,7 @@ function createSkillsCommand() {
           maxIters: parseInt(options.maxIters),
           dryRun: !options.execute,
           auditDir: options.auditDir,
+          verificationCommands: options.verify,
           recordFrame: Boolean(options.recordFrame),
           record: Boolean(options.record)
         }