@stackmemoryai/stackmemory 1.10.4 → 1.12.0

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

@@ -0,0 +1,322 @@
+#!/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";
+import * as os from "os";
+import { execSync } from "child_process";
+import * as yaml from "js-yaml";
+import {
+  getSkillPackRegistry,
+  loadPackFromDir
+} from "../../core/skill-packs/index.js";
+function resolvePackSource(source) {
+  if (fs.existsSync(source) && fs.statSync(source).isDirectory()) {
+    return source;
+  }
+  if (fs.existsSync(source) && (source.endsWith(".yaml") || source.endsWith(".yml"))) {
+    return path.dirname(source);
+  }
+  if (/^[\w-]+\/[\w-]+$/.test(source)) {
+    return cloneFromGitHub(source);
+  }
+  if (source.startsWith("https://github.com/")) {
+    return cloneFromGitHub(source);
+  }
+  throw new Error(
+    `Cannot resolve pack source: ${source}
+Expected: local directory, pack.yaml path, namespace/pack-name, or GitHub URL`
+  );
+}
+function cloneFromGitHub(source) {
+  const registryOrg = process.env["STACKMEMORY_PACK_REGISTRY"] || "stackmemoryai";
+  let repoUrl;
+  let packSubdir;
+  if (source.startsWith("https://")) {
+    repoUrl = source;
+  } else {
+    repoUrl = `https://github.com/${registryOrg}/skill-packs.git`;
+    packSubdir = source.replace("/", "/");
+  }
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sm-pack-"));
+  try {
+    execSync(`git clone --depth 1 ${repoUrl} ${tmpDir}`, {
+      stdio: "pipe",
+      timeout: 3e4
+    });
+  } catch {
+    throw new Error(
+      `Failed to clone ${repoUrl}. Check the URL or run: git clone ${repoUrl}`
+    );
+  }
+  const packDir = packSubdir ? path.join(tmpDir, packSubdir) : tmpDir;
+  if (!fs.existsSync(path.join(packDir, "pack.yaml"))) {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    throw new Error(`No pack.yaml found in ${packSubdir || "repository root"}`);
+  }
+  return packDir;
+}
+function formatPack(pack) {
+  const m = pack.manifest;
+  const tools = m.mcp?.tools?.length ?? 0;
+  const examples = m.examples?.length ?? 0;
+  const runtime = m.runtime?.type ?? "local";
+  const installed = pack.metadata?.installedAt ? new Date(pack.metadata.installedAt).toLocaleDateString() : "";
+  return [
+    `  ${chalk.bold(m.name)} ${chalk.dim(`v${m.version}`)}`,
+    `  ${chalk.dim(m.description)}`,
+    `  ${chalk.dim(`runtime: ${runtime} | tools: ${tools} | examples: ${examples}`)}`,
+    installed ? `  ${chalk.dim(`installed: ${installed}`)}` : ""
+  ].filter(Boolean).join("\n");
+}
+function createPackCommand() {
+  const cmd = new Command("pack").description(
+    "Manage skill packs \u2014 versioned, distributable agent bundles (pack.yaml)"
+  );
+  cmd.command("install <source>").description(
+    "Install a skill pack from a local dir, GitHub URL, or namespace/name"
+  ).option("--force", "Overwrite existing pack").action(async (source, options) => {
+    try {
+      const dir = resolvePackSource(source);
+      const pack = await loadPackFromDir(dir);
+      const registry = getSkillPackRegistry();
+      const existing = registry.get(pack.manifest.name);
+      if (existing && !options.force) {
+        console.log(
+          chalk.yellow(
+            `Pack ${pack.manifest.name}@${existing.manifest.version} already installed. Use --force to overwrite.`
+          )
+        );
+        return;
+      }
+      registry.install(pack);
+      console.log(
+        chalk.green(
+          `\u2713 Installed ${pack.manifest.name}@${pack.manifest.version}`
+        )
+      );
+      if (pack.manifest.mcp?.tools?.length) {
+        console.log(
+          chalk.dim(
+            `  ${pack.manifest.mcp.tools.length} MCP tools registered`
+          )
+        );
+      }
+    } catch (err) {
+      console.error(
+        chalk.red(
+          `Failed to install: ${err instanceof Error ? err.message : err}`
+        )
+      );
+      process.exit(1);
+    }
+  });
+  cmd.command("uninstall <name>").description("Remove an installed skill pack").action((name) => {
+    const registry = getSkillPackRegistry();
+    if (registry.uninstall(name)) {
+      console.log(chalk.green(`\u2713 Uninstalled ${name}`));
+    } else {
+      console.log(chalk.yellow(`Pack ${name} not found`));
+    }
+  });
+  cmd.command("list").description("List installed skill packs").option("--namespace <ns>", "Filter by namespace").option("--json", "Output as JSON").action((options) => {
+    const registry = getSkillPackRegistry();
+    const packs = registry.list(
+      options.namespace ? { namespace: options.namespace } : void 0
+    );
+    if (options.json) {
+      console.log(JSON.stringify(packs, null, 2));
+      return;
+    }
+    if (packs.length === 0) {
+      console.log(
+        chalk.dim(
+          "No packs installed. Run: stackmemory pack install <source>"
+        )
+      );
+      return;
+    }
+    console.log(chalk.bold(`${packs.length} pack(s) installed:
+`));
+    for (const pack of packs) {
+      console.log(formatPack(pack));
+      console.log();
+    }
+  });
+  cmd.command("search <query>").description("Search installed packs by keyword").action((query) => {
+    const registry = getSkillPackRegistry();
+    const results = registry.search(query);
+    if (results.length === 0) {
+      console.log(chalk.dim(`No packs matching "${query}"`));
+      return;
+    }
+    console.log(chalk.bold(`${results.length} result(s):
+`));
+    for (const pack of results) {
+      console.log(formatPack(pack));
+      console.log();
+    }
+  });
+  cmd.command("show <name>").description("Show details of an installed pack").action((name) => {
+    const registry = getSkillPackRegistry();
+    const pack = registry.get(name);
+    if (!pack) {
+      console.log(chalk.yellow(`Pack ${name} not found`));
+      return;
+    }
+    const m = pack.manifest;
+    console.log(chalk.bold(m.name) + " " + chalk.dim(`v${m.version}`));
+    console.log(chalk.dim(m.description));
+    console.log();
+    if (m.author) console.log(`  Author:  ${m.author}`);
+    if (m.license) console.log(`  License: ${m.license}`);
+    if (m.runtime) console.log(`  Runtime: ${m.runtime.type}`);
+    if (pack.metadata?.installedAt)
+      console.log(`  Installed: ${pack.metadata.installedAt}`);
+    if (pack.metadata?.source)
+      console.log(`  Source: ${pack.metadata.source}`);
+    if (m.mcp?.tools?.length) {
+      console.log(`
+  MCP Tools:`);
+      for (const tool of m.mcp.tools) {
+        console.log(`    - ${tool.name}: ${tool.description}`);
+      }
+    }
+    if (m.examples?.length) {
+      console.log(`
+  Examples: ${m.examples.length}`);
+    }
+    if (m.ingestion?.sources?.length) {
+      console.log(`
+  Ingestion sources: ${m.ingestion.sources.join(", ")}`);
+    }
+    if (pack.instructions) {
+      console.log(`
+  Instructions: ${pack.instructions.length} chars`);
+    }
+  });
+  cmd.command("init <name>").description(
+    "Initialize a new skill pack in the current directory (creates pack.yaml)"
+  ).option("--runtime <type>", "Runtime type", "local").action((name, options) => {
+    const yamlPath = path.join(process.cwd(), "pack.yaml");
+    if (fs.existsSync(yamlPath)) {
+      console.log(chalk.yellow("pack.yaml already exists in this directory"));
+      return;
+    }
+    const template = `name: ${name}
+version: 0.1.0
+description: <one-line description>
+author: <your-name>
+license: MIT
+runtime:
+  type: ${options.runtime || "local"}
+ingestion:
+  sources: []
+ontology:
+  entities: []
+  relations: []
+mcp:
+  tools: []
+examples: []
+instructions: instructions.md
+`;
+    fs.writeFileSync(yamlPath, template, "utf-8");
+    const instrPath = path.join(process.cwd(), "instructions.md");
+    if (!fs.existsSync(instrPath)) {
+      fs.writeFileSync(
+        instrPath,
+        `# ${name}
+
+Instructions for this skill pack.
+`,
+        "utf-8"
+      );
+    }
+    console.log(chalk.green(`\u2713 Created pack.yaml for ${name}`));
+    console.log(chalk.dim("  Edit pack.yaml and instructions.md, then:"));
+    console.log(chalk.dim("  stackmemory pack install ."));
+  });
+  cmd.command("fork <name> <new-name>").description("Fork an installed pack under a new namespace/name").action((name, newName) => {
+    const registry = getSkillPackRegistry();
+    const existing = registry.get(name);
+    if (!existing) {
+      console.log(chalk.yellow(`Pack ${name} not found`));
+      return;
+    }
+    const targetDir = path.join(process.cwd(), newName.replace("/", "-"));
+    if (fs.existsSync(targetDir)) {
+      console.log(chalk.yellow(`Directory ${targetDir} already exists`));
+      return;
+    }
+    fs.mkdirSync(targetDir, { recursive: true });
+    const forked = {
+      ...existing.manifest,
+      name: newName,
+      version: "0.1.0"
+    };
+    fs.writeFileSync(
+      path.join(targetDir, "pack.yaml"),
+      yaml.dump(forked),
+      "utf-8"
+    );
+    if (existing.instructions) {
+      fs.writeFileSync(
+        path.join(targetDir, "instructions.md"),
+        existing.instructions,
+        "utf-8"
+      );
+    }
+    console.log(chalk.green(`\u2713 Forked ${name} \u2192 ${newName} in ${targetDir}`));
+    console.log(
+      chalk.dim("  Edit and install: stackmemory pack install " + targetDir)
+    );
+  });
+  cmd.command("publish [dir]").description(
+    "Validate and publish a pack to the public registry (creates a GitHub PR)"
+  ).option("--dry-run", "Validate only, do not publish").action(async (dir, options) => {
+    const packDir = dir || process.cwd();
+    try {
+      const pack = await loadPackFromDir(packDir);
+      console.log(
+        chalk.green(
+          `\u2713 Valid pack: ${pack.manifest.name}@${pack.manifest.version}`
+        )
+      );
+      if (options.dryRun) {
+        console.log(chalk.dim("Dry run \u2014 skipping publish"));
+        return;
+      }
+      const registryOrg = process.env["STACKMEMORY_PACK_REGISTRY"] || "stackmemoryai";
+      console.log();
+      console.log(chalk.bold("To publish to the public registry:"));
+      console.log(
+        chalk.dim(`  1. Fork https://github.com/${registryOrg}/skill-packs`)
+      );
+      console.log(
+        chalk.dim(
+          `  2. Add your pack to ${pack.manifest.name.replace("/", "/")}/`
+        )
+      );
+      console.log(chalk.dim("  3. Open a pull request"));
+      console.log();
+      console.log(
+        chalk.dim("Automated publish via `gh pr create` coming soon.")
+      );
+    } catch (err) {
+      console.error(
+        chalk.red(
+          `Validation failed: ${err instanceof Error ? err.message : err}`
+        )
+      );
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+export {
+  createPackCommand
+};

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({
@@ -1011,14 +1005,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)
         }