@theglitchking/semantic-memory 1.0.1 → 1.1.1

package/dist/cli/index.js

@@ -1,19 +1,196 @@
 #!/usr/bin/env node
+import "../chunk-PZ5AY32C.js";
 
 // src/cli/index.ts
 import { program } from "commander";
-import { resolve, join, dirname, relative } from "path";
-import { existsSync, readFileSync, writeFileSync, rmSync } from "fs";
+import { resolve as resolve2, join as join2, dirname, relative } from "path";
+import { existsSync as existsSync2, readFileSync, writeFileSync, rmSync } from "fs";
 import { createRequire } from "module";
 import { spawnSync } from "child_process";
 import { registerUpdateCommands } from "@theglitchking/claude-plugin-runtime";
+
+// src/cli/skills.ts
+import { mkdir, readFile, writeFile, copyFile, readdir, rm } from "fs/promises";
+import { existsSync } from "fs";
+import { join, resolve } from "path";
+import { homedir } from "os";
+import { createHash } from "crypto";
+var MANIFEST_FILE = ".semantic-memory-skill-manifest.json";
+function resolveTarget(agent, scope, projectRoot) {
+  const root = resolve(projectRoot);
+  const home = homedir();
+  const map = {
+    claude: { global: join(home, ".claude", "skills"), local: join(root, ".claude", "skills") },
+    codex: { global: join(home, ".codex", "skills"), local: join(root, ".codex", "skills") },
+    copilot: { global: join(home, ".copilot", "skills"), local: join(root, ".github", "skills") },
+    pi: { global: join(home, ".pi", "agent", "skills"), local: join(root, ".pi", "skills") }
+  };
+  return { agent, scope, path: map[agent][scope] };
+}
+async function listShippedSkills(sourceRoot) {
+  const skillsDir = join(sourceRoot, "skills");
+  if (!existsSync(skillsDir)) return [];
+  const entries = await readdir(skillsDir, { withFileTypes: true });
+  const out = [];
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    const dir = join(skillsDir, e.name);
+    const skillFile = join(dir, "SKILL.md");
+    if (!existsSync(skillFile)) continue;
+    out.push({ name: e.name, dir });
+  }
+  return out;
+}
+async function sha256OfFile(path) {
+  const buf = await readFile(path);
+  return createHash("sha256").update(buf).digest("hex");
+}
+async function copyBundle(srcDir, destDir) {
+  await mkdir(destDir, { recursive: true });
+  const entries = await readdir(srcDir, { withFileTypes: true });
+  const written = [];
+  for (const e of entries) {
+    const src = join(srcDir, e.name);
+    const dest = join(destDir, e.name);
+    if (e.isDirectory()) {
+      const childWritten = await copyBundle(src, dest);
+      written.push(...childWritten);
+      continue;
+    }
+    if (!e.isFile()) continue;
+    await copyFile(src, dest);
+    written.push(dest);
+  }
+  return written;
+}
+async function installSkills(opts) {
+  const target = resolveTarget(opts.agent, opts.scope, opts.projectRoot);
+  const shipped = await listShippedSkills(opts.sourceRoot);
+  const filter = opts.only && opts.only.length > 0 ? new Set(opts.only) : null;
+  const toInstall = filter ? shipped.filter((s) => filter.has(s.name)) : shipped;
+  if (toInstall.length === 0) {
+    return {
+      agent: opts.agent,
+      scope: opts.scope,
+      target_path: target.path,
+      installed: [],
+      skipped: [],
+      reason: filter ? `No matching skills found (only=${[...filter].join(",")}).` : "No shipped skills found at sourceRoot/skills/."
+    };
+  }
+  const manifestPath = join(target.path, MANIFEST_FILE);
+  const existing = await readManifest(manifestPath);
+  if (existing && !opts.force) {
+    const drift = await detectDrift(existing, toInstall);
+    if (drift.length > 0) {
+      return {
+        agent: opts.agent,
+        scope: opts.scope,
+        target_path: target.path,
+        installed: [],
+        skipped: toInstall.map((s) => s.name),
+        reason: `Drift detected on ${drift.length} skill(s): ${drift.join(", ")}. Pass --force to overwrite.`,
+        manifest_path: manifestPath
+      };
+    }
+  }
+  await mkdir(target.path, { recursive: true });
+  const installed = [];
+  const skillEntries = [];
+  for (const skill of toInstall) {
+    const destDir = join(target.path, skill.name);
+    await copyBundle(skill.dir, destDir);
+    const skillFile = join(skill.dir, "SKILL.md");
+    skillEntries.push({ name: skill.name, sha256: await sha256OfFile(skillFile) });
+    installed.push(skill.name);
+  }
+  const manifest = {
+    package: "@theglitchking/semantic-memory",
+    version: opts.version,
+    agent: opts.agent,
+    scope: opts.scope,
+    installed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    skills: skillEntries
+  };
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  return {
+    agent: opts.agent,
+    scope: opts.scope,
+    target_path: target.path,
+    installed,
+    skipped: [],
+    manifest_path: manifestPath
+  };
+}
+async function uninstallSkills(opts) {
+  const target = resolveTarget(opts.agent, opts.scope, opts.projectRoot);
+  const manifestPath = join(target.path, MANIFEST_FILE);
+  const manifest = await readManifest(manifestPath);
+  if (!manifest) {
+    return {
+      agent: opts.agent,
+      scope: opts.scope,
+      target_path: target.path,
+      removed: [],
+      manifest_present: false,
+      reason: "No semantic-memory manifest found \u2014 nothing to uninstall."
+    };
+  }
+  const removed = [];
+  for (const skill of manifest.skills) {
+    const dir = join(target.path, skill.name);
+    if (existsSync(dir)) {
+      await rm(dir, { recursive: true, force: true });
+      removed.push(skill.name);
+    }
+  }
+  await rm(manifestPath, { force: true });
+  return {
+    agent: opts.agent,
+    scope: opts.scope,
+    target_path: target.path,
+    removed,
+    manifest_present: true
+  };
+}
+async function readManifest(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const raw = await readFile(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.package !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function detectDrift(existing, toInstall) {
+  const driftNames = [];
+  const existingByName = new Map(existing.skills.map((s) => [s.name, s.sha256]));
+  for (const skill of toInstall) {
+    const sourceSha = await sha256OfFile(join(skill.dir, "SKILL.md"));
+    const existingSha = existingByName.get(skill.name);
+    if (existingSha !== void 0 && existingSha !== sourceSha) {
+      driftNames.push(skill.name);
+    }
+  }
+  return driftNames;
+}
+var SKILL_BUNDLER_AGENTS = ["claude", "codex", "copilot", "pi"];
+
+// src/cli/index.ts
 var require_ = createRequire(import.meta.url);
 var { version } = require_("../../package.json");
-var PKG_NAME = "@theglitchking/semantic-sidekick";
+var PKG_NAME = "@theglitchking/semantic-memory";
+var LEGACY_PKG_NAME = "@theglitchking/semantic-sidekick";
 function runRelink(cwd) {
-  const linker = join(cwd, "node_modules", "@theglitchking", "semantic-sidekick", "scripts", "link-skills.js");
-  const script = existsSync(linker) ? linker : resolve(process.cwd(), "scripts", "link-skills.js");
-  if (!existsSync(script)) {
+  const candidates = [
+    join2(cwd, "node_modules", "@theglitchking", "semantic-memory", "scripts", "link-skills.js"),
+    join2(cwd, "node_modules", "@theglitchking", "semantic-sidekick", "scripts", "link-skills.js"),
+    resolve2(process.cwd(), "scripts", "link-skills.js")
+  ];
+  const script = candidates.find((p) => existsSync2(p));
+  if (!script) {
     console.error("link-skills.js not found \u2014 is the package installed?");
     return;
   }
@@ -24,8 +201,14 @@ function runRelink(cwd) {
   });
 }
 function findLocalBin(cwd) {
-  const p = join(cwd, "node_modules", "@theglitchking", "semantic-sidekick", "bin", "semantic-sidekick");
-  return existsSync(p) ? p : null;
+  const candidates = [
+    join2(cwd, "node_modules", "@theglitchking", "semantic-memory", "bin", "semantic-memory"),
+    join2(cwd, "node_modules", "@theglitchking", "semantic-sidekick", "bin", "semantic-sidekick")
+  ];
+  for (const p of candidates) {
+    if (existsSync2(p)) return p;
+  }
+  return null;
 }
 function localBinArg(cwd) {
   const abs = findLocalBin(cwd);
@@ -45,7 +228,9 @@ function isNpxForm(entry) {
   if (!entry || typeof entry !== "object") return false;
   const cmd = entry.command;
   const args = Array.isArray(entry.args) ? entry.args : [];
-  return cmd === "npx" && args.some((a) => typeof a === "string" && a.includes(PKG_NAME));
+  return cmd === "npx" && args.some(
+    (a) => typeof a === "string" && (a.includes(PKG_NAME) || a.includes(LEGACY_PKG_NAME))
+  );
 }
 function extractNotesPath(entry) {
   const args = Array.isArray(entry?.args) ? entry.args : [];
@@ -218,7 +403,7 @@ var TOOL_CATEGORIES = {
 function printToolList() {
   console.log("\nSemantic Pages \u2014 21 MCP Tools\n");
   console.log("Usage: These tools are available via MCP when the server is running.");
-  console.log("       Run `semantic-sidekick tools <name>` for details on a specific tool.\n");
+  console.log("       Run `semantic-memory tools <name>` for details on a specific tool.\n");
   for (const [category, tools] of Object.entries(TOOL_CATEGORIES)) {
     console.log(`  ${category}:`);
     for (const name of tools) {
@@ -227,13 +412,13 @@ function printToolList() {
     }
     console.log();
   }
-  console.log("Run `semantic-sidekick tools <tool-name>` for arguments and examples.");
+  console.log("Run `semantic-memory tools <tool-name>` for arguments and examples.");
 }
 function printToolDetail(name) {
   const tool = TOOL_HELP[name];
   if (!tool) {
     console.error(`Unknown tool: ${name}`);
-    console.error(`Run \`semantic-sidekick tools\` to see all available tools.`);
+    console.error(`Run \`semantic-memory tools\` to see all available tools.`);
     process.exit(1);
   }
   console.log(`
@@ -271,7 +456,7 @@ program.command("search <query>").description("Run a vault search and print top
 });
 program.command("lint").description("Lint the vault against vault.schema.yml (schema violations + missing provenance + stale)").requiredOption("--notes <path>", "Path to markdown notes directory").option("--rule <name>", "Limit output to one rule: schema_violations | missing_provenance | stale").option("--json", "Emit JSON instead of the human-readable report").option("--strict", "Exit non-zero on warnings too (default: exit non-zero only on errors)").action(async (opts) => {
   const { lintVault, formatLintReport } = await import("../lint-GMXQF4RW.js");
-  const report = await lintVault(resolve(opts.notes));
+  const report = await lintVault(resolve2(opts.notes));
   if (opts.json) {
     const out = opts.rule ? report.byRule[opts.rule] : report;
     console.log(JSON.stringify(out, null, 2));
@@ -294,7 +479,7 @@ program.command("log-event").description("Append a structured event to the vault
     }
   }
   try {
-    const entry = await logEvent(resolve(opts.notes), {
+    const entry = await logEvent(resolve2(opts.notes), {
       kind: opts.kind,
       summary: opts.summary,
       payload
@@ -308,7 +493,7 @@ program.command("log-event").description("Append a structured event to the vault
 program.command("log-query").description("Read structured log entries from log.md \u2014 filters by kind, date range, limit").requiredOption("--notes <path>", "Path to markdown notes directory").option("--kind <name>", "Filter by kind (ingest, synthesis, error, mode_change, etc.)").option("--after <iso>", "ISO timestamp \u2014 only entries on or after").option("--before <iso>", "ISO timestamp \u2014 only entries on or before").option("--limit <n>", "Max entries (most recent)", (v) => parseInt(v, 10)).action(async (opts) => {
   const { logQuery } = await import("../log-LQXIJXIA.js");
   try {
-    const entries = await logQuery(resolve(opts.notes), {
+    const entries = await logQuery(resolve2(opts.notes), {
       kind: opts.kind,
       after: opts.after,
       before: opts.before,
@@ -322,7 +507,7 @@ program.command("log-query").description("Read structured log entries from log.m
 });
 program.command("install-schema").description("Bootstrap vault.schema.yml in the vault root with the default schema").requiredOption("--notes <path>", "Path to markdown notes directory").option("--force", "Overwrite existing schema file").action(async (opts) => {
   const { installDefaultSchema } = await import("../schema-F3RTY6SQ.js");
-  const r = await installDefaultSchema(resolve(opts.notes), opts.force);
+  const r = await installDefaultSchema(resolve2(opts.notes), opts.force);
   console.log(r.written ? `Installed default schema: ${r.path}` : `Schema already exists: ${r.path} (use --force to overwrite)`);
   process.exit(0);
 });
@@ -335,8 +520,8 @@ program.command("tools [name]").description("List all MCP tools, or show details
   process.exit(0);
 });
 program.command("serve", { isDefault: true }).description("Start the MCP server (default command)").requiredOption("--notes <path>", "Path to markdown notes directory").option("--reindex", "Force full reindex and exit").option("--stats", "Show vault statistics and exit").option("--wait-for-ready", "Block startup until index is fully built before serving (default: index in background; tools return 'Indexing in progress' until ready)").option("--read-only", "Suppress write tools (create_note, update_note, delete_note, move_note, update_frontmatter, manage_tags, rename_tag) \u2014 use for shared docs vaults owned by another tool").option("--model <name>", "Embedding model to use (default: all-MiniLM-L6-v2, fast; use nomic-ai/nomic-embed-text-v1.5 for higher quality)").option("--workers <n>", "Number of worker threads for parallel embedding", parseInt).option("--batch-size <n>", "Texts per ONNX forward pass (default: 8)", parseInt).option("--no-quantized", "Use full-precision model instead of quantized (slower, slightly higher quality)").option("--no-watch", "Disable file watcher").action(async (opts) => {
-  const notesPath = resolve(opts.notes);
-  if (!existsSync(notesPath)) {
+  const notesPath = resolve2(opts.notes);
+  if (!existsSync2(notesPath)) {
     console.error(`Error: notes directory not found: ${notesPath}`);
     process.exit(1);
   }
@@ -380,16 +565,16 @@ program.command("serve", { isDefault: true }).description("Start the MCP server
 });
 registerUpdateCommands(program, {
   packageName: PKG_NAME,
-  pluginName: "semantic-sidekick",
-  configFile: "semantic-sidekick.json",
+  pluginName: "semantic-memory",
+  configFile: "semantic-memory.json",
   onAfterUpdate: (cwd) => runRelink(cwd)
 });
 program.command("normalize-config").description(
   "Rewrite fragile `npx @latest` entries in .mcp.json to the stable node-against-node_modules form (with backup and validation)"
 ).option("--dry-run", "print the proposed changes but don't write").action((opts) => {
   const cwd = process.cwd();
-  const mcpPath = join(cwd, ".mcp.json");
-  if (!existsSync(mcpPath)) {
+  const mcpPath = join2(cwd, ".mcp.json");
+  if (!existsSync2(mcpPath)) {
     console.log("no .mcp.json in current directory \u2014 nothing to do");
     process.exit(0);
   }
@@ -401,8 +586,8 @@ program.command("normalize-config").description(
   const bin = localBinArg(cwd);
   if (!bin) {
     console.error(
-      `no local install found at ./node_modules/@theglitchking/semantic-sidekick/bin/semantic-sidekick.
-run 'npm install --save @theglitchking/semantic-sidekick' first, then re-run this command.`
+      `no local install found at ./node_modules/@theglitchking/semantic-memory/bin/semantic-memory (or the legacy semantic-sidekick path).
+run 'npm install --save @theglitchking/semantic-memory' first, then re-run this command.`
     );
     process.exit(1);
   }
@@ -429,7 +614,7 @@ run 'npm install --save @theglitchking/semantic-sidekick' first, then re-run thi
     console.log("--- (dry-run; no changes written)");
     process.exit(0);
   }
-  const bakPath = join(dirname(mcpPath), ".mcp.json.bak");
+  const bakPath = join2(dirname(mcpPath), ".mcp.json.bak");
   try {
     writeFileSync(bakPath, readFileSync(mcpPath, "utf8"));
     console.log(`backup written: ${bakPath}`);
@@ -450,17 +635,17 @@ ${verify.stderr?.toString() || ""}`);
   process.exit(0);
 });
 program.command("healthcheck").description(
-  "Verify the local install starts cleanly; self-heal common npx-cache corruption (ERR_MODULE_NOT_FOUND)"
-).action(() => {
+  "Verify the local install starts cleanly + run drift detection. Self-heals common npx-cache corruption (ERR_MODULE_NOT_FOUND). With --fast, skips the slow tier (full vault lint)."
+).option("--fast", "Run only the fast-tier drift checks (file-system probes). Skips the slow tier (full vault lint).", false).option("--json", "Emit structured JSON output instead of human-readable text.", false).action(async (opts) => {
   const cwd = process.cwd();
   const bin = findLocalBin(cwd);
   if (!bin) {
-    console.error(`no local install at ./node_modules/@theglitchking/semantic-sidekick/bin/semantic-sidekick`);
-    console.error(`run 'npm install --save @theglitchking/semantic-sidekick' to install.`);
+    console.error(`no local install at ./node_modules/@theglitchking/semantic-memory/bin/semantic-memory (or legacy semantic-sidekick path)`);
+    console.error(`run 'npm install --save @theglitchking/semantic-memory' to install.`);
     process.exit(1);
   }
-  const mcpPath = join(cwd, ".mcp.json");
-  if (existsSync(mcpPath)) {
+  const mcpPath = join2(cwd, ".mcp.json");
+  if (existsSync2(mcpPath)) {
     const data = readJsonSafe(mcpPath);
     const entries = data?.mcpServers && typeof data.mcpServers === "object" ? Object.entries(data.mcpServers) : [];
     const fragile = entries.filter(([, e]) => isNpxForm(e)).map(([k]) => k);
@@ -469,7 +654,7 @@ program.command("healthcheck").description(
         `\u26A0\uFE0F  .mcp.json uses the fragile npx-@latest form for: ${fragile.join(", ")}`
       );
       console.warn(`   Rewrite to the stable form:`);
-      console.warn(`     npx --no @theglitchking/semantic-sidekick normalize-config`);
+      console.warn(`     npx --no @theglitchking/semantic-memory normalize-config`);
     }
   }
   const r = spawnSync("node", [bin, "--version"], { cwd, stdio: "pipe", timeout: 15e3 });
@@ -498,8 +683,113 @@ ${r2.stderr?.toString() || ""}`);
       console.error(`ERR_MODULE_NOT_FOUND but could not locate offending cache path in the error.`);
     }
   }
-  console.error(stderr || `local install failed (exit ${r.status})`);
-  process.exit(1);
+  if (stderr) console.error(stderr);
+  if (r.status !== 0) {
+    console.error(`local install failed (exit ${r.status})`);
+    process.exit(1);
+  }
+});
+var driftHealthcheckActionPostprocess = async (opts) => {
+  try {
+    const { runHealthcheck, formatDriftBanner } = await import("../healthcheck-DCFGPI7M.js");
+    const projectRoot = process.cwd();
+    const vaultCandidate = join2(projectRoot, ".claude", ".vault");
+    const vaultPath = existsSync2(vaultCandidate) ? vaultCandidate : void 0;
+    const result = await runHealthcheck({
+      projectRoot,
+      vaultPath,
+      tier: opts.fast ? "fast" : "all",
+      force: true
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    const banner = formatDriftBanner(result);
+    if (banner) {
+      console.log("");
+      console.log(banner);
+    } else {
+      console.log("");
+      console.log(`\u2713 no drift detected (${result.findings.length} checks ran in ${result.duration_ms}ms)`);
+    }
+  } catch (err) {
+    console.error(`drift check threw: ${err?.message ?? err}`);
+  }
+};
+var healthcheckCmd = program.commands.find((c) => c.name() === "healthcheck");
+if (healthcheckCmd) {
+  healthcheckCmd.hook("postAction", async (thisCmd) => {
+    const opts = thisCmd.opts();
+    await driftHealthcheckActionPostprocess({ fast: !!opts.fast, json: !!opts.json });
+  });
+}
+function parseAgent(input) {
+  const a = input.toLowerCase();
+  if (!SKILL_BUNDLER_AGENTS.includes(a)) {
+    console.error(`Unknown agent: ${input}. Supported: ${SKILL_BUNDLER_AGENTS.join(", ")}.`);
+    process.exit(2);
+  }
+  return a;
+}
+function parseScope(input) {
+  if (input !== "global" && input !== "local") {
+    console.error(`Unknown scope: ${input}. Use 'global' or 'local'.`);
+    process.exit(2);
+  }
+  return input;
+}
+function findSourceRoot() {
+  for (const pkg of ["semantic-memory", "semantic-sidekick"]) {
+    const installed = join2(process.cwd(), "node_modules", "@theglitchking", pkg);
+    if (existsSync2(installed)) return installed;
+  }
+  const dev = resolve2(new URL("../../", import.meta.url).pathname);
+  return dev;
+}
+var skillsCmd = program.command("skills").description("Install, target, or uninstall skill bundles for non-Claude agents (codex, copilot, pi). Claude installs continue to use the npm postinstall flow.");
+skillsCmd.command("targets").description("Preview where skill bundles would be installed for one or more agents.").option("--agent <name...>", "One or more agents (default: all). Repeatable.", void 0).option("--scope <scope>", "global or local (default: local)", "local").option("--project <path>", "Project root for local-scope paths (default: cwd)", process.cwd()).action((opts) => {
+  const scope = parseScope(opts.scope);
+  const agents = (opts.agent && opts.agent.length > 0 ? opts.agent : SKILL_BUNDLER_AGENTS).map(parseAgent);
+  const out = agents.map((a) => resolveTarget(a, scope, opts.project));
+  console.log(JSON.stringify(out, null, 2));
+});
+skillsCmd.command("install").description("Install skill bundles into an agent's skill directory. Non-destructive by default; --force to overwrite.").requiredOption("--agent <name>", "Agent runtime (claude, codex, copilot, pi)").option("--scope <scope>", "global or local (default: local)", "local").option("--project <path>", "Project root for local-scope paths (default: cwd)", process.cwd()).option("--only <names...>", "Restrict to specific skill names (default: all shipped)").option("--force", "Overwrite even if drift is detected against an existing manifest", false).action(async (opts) => {
+  const agent = parseAgent(opts.agent);
+  const scope = parseScope(opts.scope);
+  if (agent === "claude") {
+    console.error(
+      "Claude skill installs are handled by the npm postinstall (claude-plugin-runtime). Run `npm install @theglitchking/semantic-memory` instead \u2014 that flow symlinks skills into ~/.claude/skills/ or .claude/skills/ automatically. The skills CLI is intended for non-Claude agents (codex, copilot, pi) which do not have that postinstall integration."
+    );
+    process.exit(2);
+  }
+  const sourceRoot = findSourceRoot();
+  const result = await installSkills({
+    agent,
+    scope,
+    sourceRoot,
+    projectRoot: opts.project,
+    version,
+    only: opts.only,
+    force: opts.force === true
+  });
+  console.log(JSON.stringify(result, null, 2));
+  if (result.installed.length === 0 && result.reason) process.exit(1);
+});
+skillsCmd.command("uninstall").description("Remove skill bundles tracked by the semantic-memory manifest. User-written skills outside the manifest are left untouched.").requiredOption("--agent <name>", "Agent runtime (claude, codex, copilot, pi)").option("--scope <scope>", "global or local (default: local)", "local").option("--project <path>", "Project root for local-scope paths (default: cwd)", process.cwd()).action(async (opts) => {
+  const agent = parseAgent(opts.agent);
+  const scope = parseScope(opts.scope);
+  if (agent === "claude") {
+    console.error("Claude skill uninstalls go through the npm uninstall flow. The skills CLI is for non-Claude agents.");
+    process.exit(2);
+  }
+  const result = await uninstallSkills({ agent, scope, projectRoot: opts.project });
+  console.log(JSON.stringify(result, null, 2));
+});
+skillsCmd.command("list").description("List the skill bundles shipped with this plugin version.").action(async () => {
+  const sourceRoot = findSourceRoot();
+  const shipped = await listShippedSkills(sourceRoot);
+  console.log(JSON.stringify(shipped.map((s) => s.name), null, 2));
 });
 program.parse();
 //# sourceMappingURL=index.js.map