@aistoragedepot/mcp 0.3.0 → 0.5.0

package/README.md

@@ -52,22 +52,43 @@ Your stored content shows up where you actually work:
 ## Slash-commands (`pull`)
 
 Not every client turns MCP prompts into `/` slash-commands (some only use the tools). To get
-your prompts as **native** slash-commands that always work, sync them to command files:
+your library as **native** slash-commands, sync it to command files — for every AI tool you
+use, not just Claude:
 
 ```bash
-npx -y @aistoragedepot/mcp pull --token=aisd_your_token
+npx -y @aistoragedepot/mcp pull --token=aisd_your_token --to=all
 ```
 
-This writes `~/.claude/commands/aistoragedepot/*.md` — start a new chat and type
-**`/aistoragedepot`** to see them. Re-run any time; it only clears and rewrites its own
-namespaced folder.
+| Target | Writes to | Commands appear as |
+| --- | --- | --- |
+| `claude` *(default)* | `~/.claude/commands/aistoragedepot/` | `/aistoragedepot:<name>` |
+| `cursor` | `~/.cursor/commands/` | `/aisd-<name>` |
+| `vscode` | your VS Code profile's `prompts/` folder (Copilot Chat) | `/aisd-<name>` |
+| `windsurf` | `~/.codeium/windsurf/global_workflows/` (Cascade) | `/aisd-<name>` |
+| `codex` | `~/.codex/prompts/` | `/prompts:aisd-<name>` |
+
+Tools that aren't installed are skipped automatically. Each tool gets its own dialect
+(frontmatter, argument hints, `$ARGUMENTS` where supported). **Skills** run as-is.
+**Prompts** take input: their `[fields]` show as an argument hint, and whatever you type
+after the command fills them —
+
+```
+/aistoragedepot:cold-outreach Jane at Globex, about our payments API
+```
+
+— with the AI asking for any value you left out.
 
 | Option | Default | |
 | --- | --- | --- |
+| `--to=…` | `claude` | Which tools to write commands for — comma list, or `all`. |
 | `--token=…` | `AISD_TOKEN` env | Your API token. |
+| `--types=…` | `skill,prompt` | Which item types become commands (e.g. `skill` for skills only). |
 | `--workspaces="A,B"` | your personal library | Which workspaces to pull (names, or `all`). |
-| `--project` | off | Write to `./.claude/commands/…` (this repo) instead of your home dir. |
-| `--dir=<path>` | `~/.claude/commands/aistoragedepot` | Write somewhere else entirely. |
+| `--project` | off | Write into the current repo instead: `.claude/commands/`, `.cursor/commands/`, `.github/prompts/`, `.windsurf/workflows/`. |
+| `--dir=<path>` | per-target | Write somewhere else entirely (single `--to` only). |
+
+Re-runs are safe: each target only clears its own files (claude: its namespaced folder;
+the others: only files with the `aisd-` prefix — your own commands are never touched).
 
 ## Notes
 

package/index.mjs

@@ -23,11 +23,21 @@ import {
 
 const BASE_URL = (process.env.AISD_BASE_URL || "https://www.aistoragedepot.com").replace(/\/+$/, "");
 
-// CLI mode: `aistoragedepot-mcp pull` syncs prompts to native slash-command files, then exits.
+// CLI mode: `aistoragedepot-mcp pull` syncs the library to native slash-command files, then
+// exits. The brief settle delay lets undici finish closing its sockets (Connection: close)
+// before process.exit — a hard exit mid-teardown trips a libuv assert on Windows (Node 24)
+// that prints a scary-but-harmless message after the sync succeeds.
 if (process.argv[2] === "pull") {
   const { pull } = await import("./pull.mjs");
-  await pull({ BASE_URL, argv: process.argv.slice(3) });
-  process.exit(0);
+  let code = 0;
+  try {
+    await pull({ BASE_URL, argv: process.argv.slice(3) });
+  } catch (err) {
+    console.error(err?.message || err);
+    code = 1;
+  }
+  await new Promise((r) => setTimeout(r, 50));
+  process.exit(code);
 }
 
 const TOKEN = process.env.AISD_TOKEN;
@@ -131,7 +141,7 @@ function fillBody(body, placeholders, args) {
 }
 
 const server = new Server(
-  { name: "aistoragedepot", version: "0.3.0" },
+  { name: "aistoragedepot", version: "0.5.0" },
   { capabilities: { resources: {}, prompts: {}, tools: {} } },
 );
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aistoragedepot/mcp",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Model Context Protocol server for your AIStorageDepot library — exposes your prompts, rules, docs, and skills to MCP-aware AI clients (Claude, Cursor, Cline, …).",
   "type": "module",
   "bin": {

package/pull.mjs

@@ -1,17 +1,175 @@
-// `aistoragedepot-mcp pull` — sync your library into native slash-command files.
+// `aistoragedepot-mcp pull` — sync your library into native slash-command files for the
+// AI tools you use.
 //
-// MCP prompts-as-slash-commands are supported inconsistently across clients, so this writes
-// real command files that any Claude Code client picks up: ~/.claude/commands/aistoragedepot/*.md
-// (a /aistoragedepot:<name> command each). Defaults to the **skills** in your personal library
-// (self-contained instructions that run cleanly as commands); widen with --workspaces / include
-// prompts with --types. Re-run any time — it clears and rewrites only its own namespaced folder.
-import { mkdir, writeFile, rm } from "node:fs/promises";
+// Every major client now reads commands from a folder of markdown files; only the folder
+// and the frontmatter dialect differ. Targets (--to=claude,cursor,vscode,windsurf,codex | all):
+//   claude    ~/.claude/commands/aistoragedepot/*.md          → /aistoragedepot:<name>
+//   cursor    ~/.cursor/commands/aisd-*.md                    → /aisd-<name>
+//   vscode    <VS Code User>/prompts/aisd-*.prompt.md         → /aisd-<name>      (Copilot Chat)
+//   windsurf  ~/.codeium/windsurf/global_workflows/aisd-*.md  → /aisd-<name>      (Cascade)
+//   codex     ~/.codex/prompts/aisd-*.md                      → /prompts:aisd-<name>
+//
+// Defaults to --to=claude with the **skills and prompts** in your personal library. Skills
+// run as-is; prompts become commands that take input — their [fields] are declared as an
+// argument-hint and filled from what you type after the command (real $ARGUMENTS where the
+// tool substitutes it: claude + codex; a fill-from-my-message instruction elsewhere), with
+// the AI asking for anything missing. Narrow with --types / widen with --workspaces.
+// Re-runs clear only their own files (claude: its namespaced folder; others: the aisd- prefix).
+import { mkdir, writeFile, rm, readdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 
 const slug = (s) =>
   String(s).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "item";
 const typeOf = (it) => (it.type?.slug || it.type?.name || "").toLowerCase();
+const isPromptItem = (it) => it.type?.format === "prompt" || typeOf(it) === "prompt";
+
+const FIELD_RE = /\[([A-Za-z0-9 ]+)\]/g;
+const yq = (s) => String(s).replace(/"/g, "'").replace(/\s+/g, " ").trim(); // YAML-safe one-liner
+const fieldsOf = (body) => [...new Set([...String(body).matchAll(FIELD_RE)].map((m) => m[1]))];
+
+// Split a leading YAML frontmatter block off a body (skills carry their own). Values are
+// only shallow-parsed — we just need `description` — everything else is passed through or
+// dropped depending on the target.
+function splitFrontmatter(body) {
+  const m = String(body).match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!m) return { meta: {}, content: String(body) };
+  const meta = {};
+  for (const line of m[1].split(/\r?\n/)) {
+    const kv = line.match(/^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/);
+    if (kv) meta[kv[1].toLowerCase()] = kv[2].trim().replace(/^["']|["']$/g, "");
+  }
+  return { meta, content: String(body).slice(m[0].length) };
+}
+
+function descFor(it, meta) {
+  if (meta.description) return meta.description;
+  return `${isPromptItem(it) ? "Prompt — " : ""}${it.title} (AIStorageDepot)`;
+}
+
+function fmFile(fm, body) {
+  return ["---", ...Object.entries(fm).map(([k, v]) => `${k}: "${yq(v)}"`), "---", "", String(body).trim(), ""].join("\n");
+}
+
+// Tail for tools that substitute $ARGUMENTS (claude, codex).
+const argsTail = (fields) =>
+  fields.length
+    ? `\n\nInput: $ARGUMENTS\n\nFill the bracketed ${fields.length === 1 ? "field" : "fields"} in the prompt above from the input — ask me for any value that's missing — then carry out the prompt.`
+    : "\n\n$ARGUMENTS";
+// Tail for tools that just pass the typed text along with the inserted prompt.
+const fillTail = (fields) =>
+  `\n\nFill the bracketed ${fields.length === 1 ? "field" : "fields"} (${fields.map((f) => `[${f}]`).join(", ")}) from anything I typed along with this command — ask me for any value that's missing — then carry out the prompt.`;
+
+// ── per-target renderers ─────────────────────────────────────────────────────
+
+// Claude Code: skills keep their own frontmatter verbatim; prompts get description +
+// argument-hint + $ARGUMENTS; anything else gets a description wrapper.
+function renderClaude(it) {
+  const body = it.body || "";
+  if (isPromptItem(it)) {
+    const { content } = splitFrontmatter(body);
+    const fields = fieldsOf(content);
+    const fm = { description: `Prompt — ${it.title} (AIStorageDepot)` };
+    if (fields.length) fm["argument-hint"] = fields.map((f) => `[${f}]`).join(" ");
+    return fmFile(fm, content.trim() + argsTail(fields));
+  }
+  if (/^---\r?\n/.test(body)) return body.endsWith("\n") ? body : `${body}\n`;
+  return fmFile({ description: `${it.title} (AIStorageDepot)` }, body);
+}
+
+// Codex custom prompts: same dialect as Claude (description, argument-hint, $ARGUMENTS),
+// but Codex doesn't know claude-specific skill frontmatter — rebuild it clean.
+function renderCodex(it) {
+  const { meta, content } = splitFrontmatter(it.body || "");
+  const fields = isPromptItem(it) ? fieldsOf(content) : [];
+  const fm = { description: descFor(it, meta) };
+  if (isPromptItem(it) && fields.length) fm["argument-hint"] = fields.map((f) => `[${f}]`).join(" ");
+  return fmFile(fm, content.trim() + (isPromptItem(it) ? argsTail(fields) : ""));
+}
+
+// VS Code prompt files: description + argument-hint frontmatter; typed extras arrive as
+// part of the chat message (no $ARGUMENTS substitution).
+function renderVscode(it) {
+  const { meta, content } = splitFrontmatter(it.body || "");
+  const fields = isPromptItem(it) ? fieldsOf(content) : [];
+  const fm = { description: descFor(it, meta) };
+  if (fields.length) fm["argument-hint"] = fields.map((f) => `[${f}]`).join(" ");
+  return fmFile(fm, content.trim() + (fields.length ? fillTail(fields) : ""));
+}
+
+// Windsurf workflows: description frontmatter; 12k char cap per file (enforced by caller).
+function renderWindsurf(it) {
+  const { meta, content } = splitFrontmatter(it.body || "");
+  const fields = isPromptItem(it) ? fieldsOf(content) : [];
+  return fmFile({ description: descFor(it, meta) }, content.trim() + (fields.length ? fillTail(fields) : ""));
+}
+
+// Cursor commands: plain markdown — no frontmatter dialect; the body IS the prompt.
+function renderCursor(it) {
+  const { content } = splitFrontmatter(it.body || "");
+  const fields = isPromptItem(it) ? fieldsOf(content) : [];
+  return content.trim() + (fields.length ? fillTail(fields) : "") + "\n";
+}
+
+// ── targets ──────────────────────────────────────────────────────────────────
+
+function vscodeUserDir(home) {
+  if (process.platform === "win32")
+    return join(process.env.APPDATA || join(home, "AppData", "Roaming"), "Code", "User");
+  if (process.platform === "darwin") return join(home, "Library", "Application Support", "Code", "User");
+  return join(home, ".config", "Code", "User");
+}
+
+// prefix'd targets share folders with the user's own files — we only ever delete our prefix.
+function targetDefs(project) {
+  const home = homedir();
+  return {
+    claude: {
+      dir: project ? resolve(".claude", "commands", "aistoragedepot") : join(home, ".claude", "commands", "aistoragedepot"),
+      parent: null, // Claude Code owns ~/.claude; safe to create
+      ownsFolder: true,
+      prefix: "",
+      ext: ".md",
+      render: renderClaude,
+      tip: "type /aistoragedepot in a new chat (first sync: fully restart Claude Code — end claude.exe on Windows)",
+    },
+    cursor: {
+      dir: project ? resolve(".cursor", "commands") : join(home, ".cursor", "commands"),
+      parent: project ? null : join(home, ".cursor"),
+      prefix: "aisd-",
+      ext: ".md",
+      render: renderCursor,
+      tip: "type /aisd- in Cursor's Agent input",
+    },
+    vscode: {
+      dir: project ? resolve(".github", "prompts") : join(vscodeUserDir(home), "prompts"),
+      parent: project ? null : vscodeUserDir(home),
+      prefix: "aisd-",
+      ext: ".prompt.md",
+      render: renderVscode,
+      tip: "type /aisd- in Copilot Chat",
+    },
+    windsurf: {
+      dir: project ? resolve(".windsurf", "workflows") : join(home, ".codeium", "windsurf", "global_workflows"),
+      parent: project ? null : join(home, ".codeium", "windsurf"),
+      prefix: "aisd-",
+      ext: ".md",
+      render: renderWindsurf,
+      maxBytes: 12000, // Windsurf rejects workflow files past ~12k chars
+      tip: "type /aisd- in Cascade",
+    },
+    codex: {
+      dir: join(process.env.CODEX_HOME || join(home, ".codex"), "prompts"), // global only
+      parent: process.env.CODEX_HOME || join(home, ".codex"),
+      prefix: "aisd-",
+      ext: ".md",
+      render: renderCodex,
+      noProject: true,
+      tip: "type /prompts:aisd- (or /aisd-) in Codex — restart codex to load",
+    },
+  };
+}
 
 function parseArgs(argv) {
   const o = {};
@@ -32,59 +190,95 @@ export async function pull({ BASE_URL, argv }) {
     process.exit(1);
   }
   const api = async (p) => {
-    const r = await fetch(BASE_URL + p, { headers: { Authorization: `Bearer ${token}`, Accept: "application/json" } });
+    // Connection: close — keep-alive sockets left open at exit trip a libuv assert on
+    // Windows (Node 24), printing a scary (but harmless) message after the sync finishes.
+    const r = await fetch(BASE_URL + p, {
+      headers: { Authorization: `Bearer ${token}`, Accept: "application/json", Connection: "close" },
+    });
     if (r.status === 401) throw new Error("Token rejected (401) — check it in Settings → API tokens.");
     if (!r.ok) throw new Error(`${p} → HTTP ${r.status}`);
     return r.json();
   };
 
-  // Which item types to pull. Default: skills only. --types=skill,prompt | all.
-  const TYPES = String(o.types || "skill").toLowerCase().split(",").map((s) => s.trim()).filter(Boolean);
+  // Which tools to write for. Default: claude. --to=cursor,vscode | all.
+  const DEFS = targetDefs(!!o.project);
+  const toRaw = String(o.to || "claude").toLowerCase().split(",").map((s) => s.trim()).filter(Boolean);
+  const targets = toRaw.includes("all") ? Object.keys(DEFS) : toRaw;
+  const unknown = targets.filter((t) => !DEFS[t]);
+  if (unknown.length) {
+    console.error(`Unknown --to target(s): ${unknown.join(", ")}. Valid: ${Object.keys(DEFS).join(", ")}, all.`);
+    process.exit(1);
+  }
+  if (o.dir && targets.length > 1) {
+    console.error("--dir only makes sense with a single --to target.");
+    process.exit(1);
+  }
+
+  // Which item types to pull. Default: skills + prompts. --types=skill | prompt | all.
+  const TYPES = String(o.types || "skill,prompt").toLowerCase().split(",").map((s) => s.trim()).filter(Boolean);
   const wantType = (it) => {
     const t = typeOf(it);
     const isSkill = t === "skill";
-    const isPrompt = it.type?.format === "prompt" || t === "prompt";
+    const isPrompt = isPromptItem(it);
     if (TYPES.includes("all")) return isSkill || isPrompt;
     return (TYPES.includes("skill") && isSkill) || (TYPES.includes("prompt") && isPrompt) || TYPES.includes(t);
   };
 
   const workspaces = await api("/api/workspaces");
-  // Scope: default every workspace; --workspaces="A,B" | "personal" | "all".
+  // Scope: default your personal library; --workspaces="A,B" | "all".
   const names = String(o.workspaces || "").split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
   let scope;
   if (names.includes("all") || names.includes("*")) scope = workspaces;
   else if (names.length) scope = workspaces.filter((w) => names.includes((w.name || "").toLowerCase()));
-  else scope = workspaces.filter((w) => w.type === "PERSONAL"); // default: just your personal library
+  else scope = workspaces.filter((w) => w.type === "PERSONAL");
 
   const libs = await Promise.all(
     scope.map((w) => api(`/api/library?workspace=${encodeURIComponent(w.id)}`).catch(() => ({ items: [] }))),
   );
   const items = libs.flatMap((l) => (l.items || []).filter(wantType));
 
-  const dir = o.dir
-    ? resolve(String(o.dir))
-    : o.project
-      ? resolve(".claude", "commands", "aistoragedepot")
-      : join(homedir(), ".claude", "commands", "aistoragedepot");
-  await rm(dir, { recursive: true, force: true }); // clean re-sync of our namespaced folder only
-  await mkdir(dir, { recursive: true });
-
-  const used = new Set();
-  let n = 0;
-  for (const it of items) {
-    let name = slug(it.title);
-    while (used.has(name)) name = `${name}-${it.id.slice(-4)}`;
-    used.add(name);
-    const body = it.body || "";
-    // Skills already carry their own YAML frontmatter (name/description) — keep it as-is; for anything
-    // without frontmatter (e.g. prompts), add a description so it shows nicely in the / menu.
-    const content = /^---\r?\n/.test(body)
-      ? body.endsWith("\n") ? body : `${body}\n`
-      : `---\ndescription: "${`${it.title} (AIStorageDepot)`.replace(/"/g, "'").replace(/\s+/g, " ").trim()}"\n---\n\n${body}\n`;
-    await writeFile(join(dir, `${name}.md`), content, "utf8");
-    n++;
-  }
+  for (const tname of targets) {
+    const t = DEFS[tname];
+    if (t.noProject && o.project) console.log(`  (${tname} has no per-project location — writing globally)`);
+    // Don't invent config folders for tools that aren't installed (claude is exempt: it's
+    // our home target and Claude Code tolerates a pre-made commands dir).
+    if (t.parent && !existsSync(t.parent)) {
+      console.log(`↷ ${tname} skipped — ${t.parent} not found (is it installed? use --to without it, or install first)`);
+      continue;
+    }
+    const dir = o.dir && targets.length === 1 ? resolve(String(o.dir)) : t.dir;
+    if (t.ownsFolder) await rm(dir, { recursive: true, force: true }); // clean re-sync of OUR folder only
+    await mkdir(dir, { recursive: true });
+    if (!t.ownsFolder) {
+      // shared folder: remove only files we wrote before (our prefix)
+      const existing = await readdir(dir).catch(() => []);
+      await Promise.all(
+        existing.filter((n) => n.startsWith(t.prefix) && n.endsWith(t.ext)).map((n) => rm(join(dir, n), { force: true })),
+      );
+    }
 
-  console.log(`✓ Synced ${n} item${n === 1 ? "" : "s"} (${TYPES.join(", ")}) → ${dir}`);
-  console.log(`  Start a new chat and type /aistoragedepot to use them.`);
+    const used = new Set();
+    let n = 0;
+    let skipped = 0;
+    for (const it of items) {
+      // Clean names; on a title collision, the type breaks the tie before an id suffix.
+      let name = slug(it.title);
+      if (used.has(name)) {
+        const alt = slug(`${it.title} ${typeOf(it) || "item"}`);
+        name = used.has(alt) ? `${slug(it.title)}-${it.id.slice(-4)}` : alt;
+      }
+      while (used.has(name)) name = `${name}-${it.id.slice(-4)}`;
+      used.add(name);
+      const content = t.render(it);
+      if (t.maxBytes && content.length > t.maxBytes) {
+        console.log(`  ! ${tname}: skipped "${it.title}" — over the ${t.maxBytes}-char limit`);
+        skipped++;
+        continue;
+      }
+      await writeFile(join(dir, `${t.prefix}${name}${t.ext}`), content, "utf8");
+      n++;
+    }
+    console.log(`✓ ${tname} — ${n} command${n === 1 ? "" : "s"}${skipped ? ` (${skipped} skipped)` : ""} → ${dir}`);
+    console.log(`  ${t.tip}`);
+  }
 }