@stackmemoryai/stackmemory 1.10.5 → 1.14.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/patterns.js

@@ -0,0 +1,254 @@
+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 Database from "better-sqlite3";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { PatternStore } from "../../core/patterns/pattern-store.js";
+function getDb() {
+  const dbPath = join(homedir(), ".stackmemory", "stackmemory.db");
+  return new Database(dbPath);
+}
+function getStore() {
+  return new PatternStore(getDb());
+}
+function createPatternsCommand() {
+  const patterns = new Command("patterns").description(
+    "Manage learned behavioral patterns"
+  );
+  patterns.command("list").description("List learned patterns").option("-d, --domain <domain>", "Filter by domain").option("-s, --status <status>", "Filter by status", "active").option("--min-confidence <n>", "Minimum confidence", "0").option("--json", "Output JSON").action((opts) => {
+    const store = getStore();
+    const list = store.list({
+      domain: opts.domain,
+      status: opts.status,
+      minConfidence: parseFloat(opts.minConfidence)
+    });
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(list, null, 2) + "\n");
+      return;
+    }
+    if (list.length === 0) {
+      process.stdout.write("No patterns found.\n");
+      return;
+    }
+    for (const p of list) {
+      const bar = confidenceBar(p.confidence);
+      const scope = p.scope === "global" ? "[global]" : "[project]";
+      process.stdout.write(
+        `${bar} ${p.confidence.toFixed(2)}  ${scope}  ${p.id}
+   trigger: ${p.trigger}
+   action:  ${p.action}
+   domain:  ${p.domain}  obs: ${p.observationCount}  status: ${p.status}
+
+`
+      );
+    }
+  });
+  patterns.command("learn").description("Manually record a pattern").requiredOption("-t, --trigger <text>", "When this happens").requiredOption("-a, --action <text>", "Do this").option("-d, --domain <domain>", "Pattern domain", "general").option("--scope <scope>", "project or global", "project").option("--id <id>", "Pattern ID (auto-generated if omitted)").action((opts) => {
+    const store = getStore();
+    const id = opts.id ?? slugify(`${opts.domain}-${opts.trigger.slice(0, 40)}`);
+    const input = {
+      id,
+      domain: opts.domain,
+      trigger: opts.trigger,
+      action: opts.action,
+      scope: opts.scope,
+      source: "manual",
+      confidence: 0.5
+    };
+    const pattern = store.create(input);
+    process.stdout.write(
+      `Pattern created: ${pattern.id} (confidence: ${pattern.confidence})
+`
+    );
+  });
+  patterns.command("stats").description("Show pattern statistics").option("--json", "Output JSON").action((opts) => {
+    const store = getStore();
+    const s = store.stats();
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(s, null, 2) + "\n");
+      return;
+    }
+    const lines = [
+      `Total patterns: ${s.total}`,
+      `Avg confidence: ${s.avgConfidence.toFixed(2)}`,
+      "",
+      "By domain:",
+      ...Object.entries(s.byDomain).map(([d, n]) => `  ${d}: ${n}`),
+      "",
+      "By status:",
+      ...Object.entries(s.byStatus).map(([d, n]) => `  ${d}: ${n}`)
+    ];
+    if (s.topPatterns.length > 0) {
+      lines.push("", "Top patterns:");
+      for (const p of s.topPatterns) {
+        lines.push(
+          `  ${confidenceBar(p.confidence)} ${p.confidence.toFixed(2)}  ${p.id}`
+        );
+      }
+    }
+    process.stdout.write(lines.join("\n") + "\n");
+  });
+  patterns.command("prune").description("Remove old pending patterns").option("--days <n>", "Max age in days", "30").action((opts) => {
+    const store = getStore();
+    const removed = store.prune(parseInt(opts.days, 10));
+    process.stdout.write(
+      `Pruned ${removed} pending patterns older than ${opts.days} days.
+`
+    );
+  });
+  patterns.command("export").description("Export patterns to JSON file").option("-o, --output <path>", "Output file", "patterns-export.json").option("--min-confidence <n>", "Minimum confidence", "0.3").action((opts) => {
+    const store = getStore();
+    const list = store.list({
+      status: "active",
+      minConfidence: parseFloat(opts.minConfidence)
+    });
+    writeFileSync(opts.output, JSON.stringify(list, null, 2), "utf-8");
+    process.stdout.write(
+      `Exported ${list.length} patterns to ${opts.output}
+`
+    );
+  });
+  patterns.command("import").description("Import patterns from JSON file").argument("<file>", "JSON file to import").option("--scope <scope>", "Override scope", "project").action((file, opts) => {
+    if (!existsSync(file)) {
+      process.stderr.write(`File not found: ${file}
+`);
+      process.exit(1);
+    }
+    const store = getStore();
+    const data = JSON.parse(readFileSync(file, "utf-8"));
+    const patterns2 = Array.isArray(data) ? data : [data];
+    let imported = 0;
+    for (const p of patterns2) {
+      if (!p.id || !p.trigger || !p.action) continue;
+      const existing = store.get(p.id);
+      if (existing) {
+        store.reinforce(p.id, "imported");
+      } else {
+        store.create({
+          id: p.id,
+          domain: p.domain ?? "general",
+          trigger: p.trigger,
+          action: p.action,
+          evidence: p.evidence ?? ["imported"],
+          scope: opts.scope ?? p.scope ?? "project",
+          source: "imported",
+          confidence: p.confidence ?? 0.5
+        });
+      }
+      imported++;
+    }
+    process.stdout.write(`Imported ${imported} patterns.
+`);
+  });
+  patterns.command("promote").description("Promote a project-scoped pattern to global").argument("[id]", "Pattern ID to promote (omit for auto-candidates)").option("--dry-run", "Show candidates without promoting").action((id, opts) => {
+    const store = getStore();
+    if (id) {
+      const pattern = store.get(id);
+      if (!pattern) {
+        process.stderr.write(`Pattern not found: ${id}
+`);
+        process.exit(1);
+      }
+      if (pattern.scope === "global") {
+        process.stdout.write(`Already global: ${id}
+`);
+        return;
+      }
+      if (!opts.dryRun) {
+        store.promote(id);
+        process.stdout.write(`Promoted to global: ${id}
+`);
+      } else {
+        process.stdout.write(
+          `Would promote: ${id} (confidence: ${pattern.confidence.toFixed(2)})
+`
+        );
+      }
+      return;
+    }
+    const candidates = store.promotionCandidates(0.7);
+    if (candidates.length === 0) {
+      process.stdout.write(
+        "No promotion candidates found (need 0.7+ confidence in 2+ projects).\n"
+      );
+      return;
+    }
+    for (const c of candidates) {
+      const action = opts.dryRun ? "candidate" : "promoted";
+      if (!opts.dryRun) store.promote(c.id);
+      process.stdout.write(
+        `${action}: ${c.id} (${c.confidence.toFixed(2)}, project: ${c.projectId})
+`
+      );
+    }
+    if (opts.dryRun) {
+      process.stdout.write(
+        `
+${candidates.length} candidates. Run without --dry-run to promote.
+`
+      );
+    }
+  });
+  patterns.command("projects").description("List projects with pattern counts").option("--json", "Output JSON").action((opts) => {
+    const store = getStore();
+    const projs = store.projects();
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(projs, null, 2) + "\n");
+      return;
+    }
+    if (projs.length === 0) {
+      process.stdout.write("No project-scoped patterns found.\n");
+      return;
+    }
+    for (const p of projs) {
+      process.stdout.write(
+        `${p.projectId}  ${p.count} patterns  avg confidence: ${p.avgConfidence.toFixed(2)}
+`
+      );
+    }
+  });
+  patterns.command("evolve").description("Analyze pattern clusters and suggest evolved structures").option("--min-cluster <n>", "Minimum cluster size", "2").option("--json", "Output JSON").action((opts) => {
+    const store = getStore();
+    const clusters = store.findClusters(parseInt(opts.minCluster, 10));
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(clusters, null, 2) + "\n");
+      return;
+    }
+    if (clusters.length === 0) {
+      process.stdout.write(
+        "No pattern clusters found. Need 2+ active patterns in a domain.\n"
+      );
+      return;
+    }
+    for (const cluster of clusters) {
+      const avgConf = cluster.patterns.reduce((s, p) => s + p.confidence, 0) / cluster.patterns.length;
+      const label = avgConf >= 0.8 ? "SKILL candidate" : avgConf >= 0.6 ? "command candidate" : "cluster";
+      process.stdout.write(
+        `
+[${cluster.domain}] ${cluster.patterns.length} patterns \u2014 ${label} (avg: ${avgConf.toFixed(2)})
+`
+      );
+      for (const p of cluster.patterns) {
+        process.stdout.write(
+          `  ${confidenceBar(p.confidence)} ${p.id}: ${p.trigger}
+`
+        );
+      }
+    }
+  });
+  return patterns;
+}
+function confidenceBar(confidence) {
+  const filled = Math.round(confidence * 10);
+  return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+export {
+  createPatternsCommand
+};