@withmata/blueprints 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { intro, outro, log as log5 } from "@clack/prompts";
-import pc2 from "picocolors";
+import { intro as intro2, outro as outro2, log as log6 } from "@clack/prompts";
+import pc3 from "picocolors";
 
 // src/constants.ts
 var API_URL = process.env["WITHMATA_API_URL"] || "https://blueprints.withmata.dev";
-var VERSION = "0.2.0";
+var VERSION = "0.3.1";
 
 // src/steps/auth.ts
 import { log } from "@clack/prompts";
@@ -27,6 +27,15 @@ var WITHMATA_DIR = join(homedir(), ".withmata");
 var BLUEPRINTS_DIR = join(WITHMATA_DIR, "blueprints");
 var CREDENTIALS_PATH = join(WITHMATA_DIR, "credentials.json");
 var CONFIG_PATH = join(WITHMATA_DIR, "config.json");
+var SKILLS_SOURCE_DIR = join(BLUEPRINTS_DIR, ".claude", "skills");
+var CLAUDE_SKILLS_DIR = join(homedir(), ".claude", "skills");
+var OPENCODE_SKILLS_DIR = join(
+  homedir(),
+  ".config",
+  "opencode",
+  "skills"
+);
+var CURSOR_SKILLS_DIR = join(homedir(), ".cursor", "skills");
 var CLAUDE_COMMANDS_DIR = ".claude/commands";
 var OPENCODE_COMMANDS_DIR = ".opencode/commands";
 var CURSOR_COMMANDS_DIR = ".cursor/commands";
@@ -149,23 +158,11 @@ async function downloadBlueprints(_token) {
       recursive: true
     });
   }
-  const claudeCommandsSource = join3(sourcePath, ".claude", "commands");
-  if (existsSync3(claudeCommandsSource)) {
-    const target = join3(BLUEPRINTS_DIR, ".claude", "commands");
-    mkdirSync2(target, { recursive: true });
-    cpSync(claudeCommandsSource, target, { recursive: true });
-  }
-  const opencodeCommandsSource = join3(sourcePath, ".opencode", "commands");
-  if (existsSync3(opencodeCommandsSource)) {
-    const target = join3(BLUEPRINTS_DIR, ".opencode", "commands");
-    mkdirSync2(target, { recursive: true });
-    cpSync(opencodeCommandsSource, target, { recursive: true });
-  }
-  const cursorCommandsSource = join3(sourcePath, ".cursor", "commands");
-  if (existsSync3(cursorCommandsSource)) {
-    const target = join3(BLUEPRINTS_DIR, ".cursor", "commands");
+  const skillsSource = join3(sourcePath, ".claude", "skills");
+  if (existsSync3(skillsSource)) {
+    const target = join3(BLUEPRINTS_DIR, ".claude", "skills");
     mkdirSync2(target, { recursive: true });
-    cpSync(cursorCommandsSource, target, { recursive: true });
+    cpSync(skillsSource, target, { recursive: true });
   }
   const engineeringSource = join3(sourcePath, "ENGINEERING.md");
   if (existsSync3(engineeringSource)) {
@@ -226,188 +223,129 @@ import {
   existsSync as existsSync4,
   mkdirSync as mkdirSync3,
   symlinkSync,
-  readFileSync as readFileSync2,
-  appendFileSync,
-  writeFileSync as writeFileSync2,
   lstatSync,
   unlinkSync as unlinkSync2,
   renameSync,
   readdirSync as readdirSync2,
-  cpSync as cpSync2
+  readlinkSync
 } from "fs";
 import { join as join4, resolve as resolve2 } from "path";
 import { spinner as spinner2, log as log3 } from "@clack/prompts";
-async function linkToProject(tools) {
-  let commandsLinked = 0;
-  const rulesFilesUpdated = [];
-  const targetDir = process.cwd();
+async function installSkillsGlobally(tools) {
+  let skillsInstalled = 0;
   for (const tool of tools) {
     if (tool === "claude-code") {
-      const result = linkCommands(
-        join4(BLUEPRINTS_DIR, CLAUDE_COMMANDS_DIR),
-        join4(targetDir, CLAUDE_COMMANDS_DIR),
+      skillsInstalled += installSkills(
+        SKILLS_SOURCE_DIR,
+        CLAUDE_SKILLS_DIR,
         "Claude Code"
       );
-      commandsLinked += result;
-      if (updateRulesFile(targetDir, "CLAUDE.md")) {
-        rulesFilesUpdated.push("CLAUDE.md");
-      }
     }
     if (tool === "opencode") {
-      const result = linkCommands(
-        join4(BLUEPRINTS_DIR, OPENCODE_COMMANDS_DIR),
-        join4(targetDir, OPENCODE_COMMANDS_DIR),
+      skillsInstalled += installSkills(
+        SKILLS_SOURCE_DIR,
+        OPENCODE_SKILLS_DIR,
         "OpenCode"
       );
-      commandsLinked += result;
-      if (updateRulesFile(targetDir, "AGENTS.md")) {
-        if (!rulesFilesUpdated.includes("AGENTS.md")) {
-          rulesFilesUpdated.push("AGENTS.md");
-        }
-      }
     }
     if (tool === "cursor") {
-      const result = linkCommands(
-        join4(BLUEPRINTS_DIR, CURSOR_COMMANDS_DIR),
-        join4(targetDir, CURSOR_COMMANDS_DIR),
+      skillsInstalled += installSkills(
+        SKILLS_SOURCE_DIR,
+        CURSOR_SKILLS_DIR,
         "Cursor"
       );
-      commandsLinked += result;
-      if (updateRulesFile(targetDir, "AGENTS.md")) {
-        if (!rulesFilesUpdated.includes("AGENTS.md")) {
-          rulesFilesUpdated.push("AGENTS.md");
-        }
-      }
     }
   }
-  const engineeringCopied = copyEngineering(targetDir);
-  return { commandsLinked, rulesFilesUpdated, engineeringCopied };
+  const legacyCommandsCleaned = cleanupLegacyCommands(process.cwd());
+  return { skillsInstalled, legacyCommandsCleaned };
 }
-function linkCommands(sourceDir, targetDir, toolLabel) {
+function installSkills(sourceDir, globalTargetDir, toolLabel) {
   const s = spinner2();
-  s.start(`Linking commands for ${toolLabel}...`);
-  mkdirSync3(targetDir, { recursive: true });
-  let count = 0;
+  s.start(`Installing skills for ${toolLabel}...`);
+  mkdirSync3(globalTargetDir, { recursive: true });
   if (!existsSync4(sourceDir)) {
-    s.stop(`No commands found for ${toolLabel}`);
+    s.stop(`No skills found for ${toolLabel}`);
     return 0;
   }
-  for (const file of readdirSync2(sourceDir)) {
-    if (!file.endsWith(".md")) continue;
-    const source = resolve2(sourceDir, file);
-    const target = join4(targetDir, file);
-    if (existsSync4(target)) {
+  let count = 0;
+  for (const entry of readdirSync2(sourceDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const source = resolve2(sourceDir, entry.name);
+    const target = join4(globalTargetDir, entry.name);
+    if (existsSync4(target) || lstatExists(target)) {
       if (lstatSync(target).isSymbolicLink()) {
         unlinkSync2(target);
       } else {
-        renameSync(target, `${target}.bak`);
+        const backup = `${target}.bak`;
+        if (existsSync4(backup)) {
+          unlinkSync2(backup);
+        }
+        renameSync(target, backup);
       }
     }
     symlinkSync(source, target);
     count++;
   }
-  s.stop(`${count} commands linked for ${toolLabel}`);
+  s.stop(`${count} skills installed for ${toolLabel}`);
   return count;
 }
-var MARKER_START = "# --- withmata-blueprints ---";
-var MARKER_END = "# --- /withmata-blueprints ---";
-function buildRulesBlock() {
-  return `
-${MARKER_START}
-## Blueprint System (withmata.dev)
-
-You have access to production-ready blueprints for scaffolding project infrastructure. Blueprints encode battle-tested patterns and configurations that save hours of setup. They work in both monorepo and single-repo projects.
-
-### Commands
-
-\`/new-project\`, \`/discover\`, \`/scaffold-foundation\`, \`/scaffold-auth\`, \`/scaffold-db\`, \`/audit\`
-
-### Available Blueprints
-
-| Blueprint | Tier | What it does | Dependencies | Command |
-|-----------|------|-------------|--------------|---------|
-| Product Discovery | Discovery | Structured session producing product thesis, user archetypes, and competitive analysis. No code. | None | \`/discover\` |
-| Monorepo Foundation | Foundation | Turborepo + pnpm monorepo with Next.js, Biome, TypeScript strict, Tailwind v4. | None | \`/scaffold-foundation\` |
-| Database | Feature | Drizzle ORM + PostgreSQL: schema groups, migrations, seed scripts. | None | \`/scaffold-db\` |
-| Authentication | Feature | Better Auth + Drizzle + PostgreSQL: social login, email/password, organizations, role-based permissions. | Database | \`/scaffold-auth\` |
-
-### When to Recommend
-
-Suggest a blueprint when you observe these signals. Be helpful, not pushy \u2014 mention it once, then follow the user's lead.
-
-**\`/discover\`** \u2014 User describes a new product idea, asks "what should I build", is unsure about scope or target users, is non-technical or building their first product, or project has no product documentation.
-
-**\`/scaffold-foundation\`** \u2014 User wants to set up a monorepo, mentions Turborepo or project structure, or project has no \`turbo.json\` / \`pnpm-workspace.yaml\`. Best after discovery. Skip for single-repo apps.
-
-**\`/scaffold-db\`** \u2014 User mentions database, Drizzle, PostgreSQL, schemas, migrations, or needs a structured db layer. Or is writing raw SQL or using an ORM without organized schemas.
-
-**\`/scaffold-auth\`** \u2014 User mentions login, signup, users, accounts, teams, organizations, permissions, or authentication. Or is implementing auth from scratch. Recommend \`/scaffold-db\` first if not already installed.
-
-**\`/audit\`** \u2014 User asks "what should I do next?", wants to understand their project's state, or has hand-rolled infrastructure that a blueprint could improve.
-
-### Lifecycle & Dependencies
-
-Discovery \u2192 Foundation \u2192 Features is the recommended flow, but blueprints can be applied at any stage.
-
-- **New project, no code:** Start with \`/discover\` (especially for non-technical users) or \`/scaffold-foundation\` (for monorepos)
-- **Single-repo project:** Skip foundation \u2014 go directly to feature blueprints (\`/scaffold-db\`, \`/scaffold-auth\`)
-- **Has monorepo, missing features:** Suggest specific feature blueprints
-- **Existing project:** Feature blueprints adapt to existing structures \u2014 no foundation required
-- **Dependencies:** \`/scaffold-auth\` works best after \`/scaffold-db\` (auth builds on db patterns). Install dependencies first.
-
-### Important
-
-- Read \`.project-context.md\` first \u2014 it tracks what is already set up. Do not recommend blueprints already recorded there.
-- Read the full BLUEPRINT.md before scaffolding. Follow ENGINEERING.md for coding conventions.
-- Only recommend blueprints listed above. Other blueprints are in development and not yet available.
-- Blueprints location: \`${BLUEPRINTS_DIR}\`
-${MARKER_END}
-`;
-}
-function updateRulesFile(targetDir, filename) {
-  const filepath = join4(targetDir, filename);
-  const block = buildRulesBlock();
-  if (existsSync4(filepath)) {
-    const content = readFileSync2(filepath, "utf-8");
-    if (content.includes(MARKER_START)) {
-      const startIdx = content.indexOf(MARKER_START);
-      const endIdx = content.indexOf(MARKER_END);
-      if (endIdx === -1) {
-        appendFileSync(filepath, block);
-      } else {
-        const before = content.slice(0, startIdx);
-        const after = content.slice(endIdx + MARKER_END.length);
-        writeFileSync2(filepath, before + block.trimStart() + after);
+function cleanupLegacyCommands(targetDir) {
+  let cleaned = 0;
+  const legacyDirs = [
+    join4(targetDir, CLAUDE_COMMANDS_DIR),
+    join4(targetDir, OPENCODE_COMMANDS_DIR),
+    join4(targetDir, CURSOR_COMMANDS_DIR)
+  ];
+  for (const dir of legacyDirs) {
+    if (!existsSync4(dir)) continue;
+    let dirEmpty = true;
+    for (const file of readdirSync2(dir)) {
+      const filePath = join4(dir, file);
+      if (lstatSync(filePath).isSymbolicLink()) {
+        try {
+          const linkTarget = readlinkSync(filePath);
+          if (linkTarget.includes(BLUEPRINTS_DIR)) {
+            unlinkSync2(filePath);
+            cleaned++;
+            continue;
+          }
+        } catch {
+          unlinkSync2(filePath);
+          cleaned++;
+          continue;
+        }
+      }
+      dirEmpty = false;
+    }
+    if (dirEmpty && readdirSync2(dir).length === 0) {
+      try {
+        readdirSync2(dir);
+        if (readdirSync2(dir).length === 0) {
+          unlinkSync2(dir);
+        }
+      } catch {
       }
-      log3.success(`Updated ${filename} (refreshed blueprint catalog)`);
-      return true;
     }
-    appendFileSync(filepath, block);
-  } else {
-    writeFileSync2(filepath, block.trimStart());
   }
-  log3.success(`Updated ${filename}`);
-  return true;
+  if (cleaned > 0) {
+    log3.info(`Cleaned up ${cleaned} legacy command symlink(s)`);
+  }
+  return cleaned;
 }
-function copyEngineering(targetDir) {
-  const source = join4(BLUEPRINTS_DIR, "ENGINEERING.md");
-  const target = join4(targetDir, "ENGINEERING.md");
-  if (!existsSync4(source)) return false;
-  if (existsSync4(target)) {
-    const sourceContent = readFileSync2(source, "utf-8");
-    const targetContent = readFileSync2(target, "utf-8");
-    if (sourceContent === targetContent) return false;
+function lstatExists(path) {
+  try {
+    lstatSync(path);
+    return true;
+  } catch {
+    return false;
   }
-  cpSync2(source, target);
-  log3.success("Copied ENGINEERING.md");
-  return true;
 }
 
 // src/steps/summary.ts
 import { log as log4, note } from "@clack/prompts";
 import pc from "picocolors";
-function showSummary({ linked, tools, blueprintCount }) {
-  const commands = [
+function showSummary({ installed, tools, blueprintCount }) {
+  const skills = [
     `${pc.cyan("/new-project")}          Start a new project`,
     `${pc.cyan("/scaffold-auth")}        Add auth to this project`,
     `${pc.cyan("/scaffold-db")}          Set up database package`,
@@ -415,38 +353,144 @@ function showSummary({ linked, tools, blueprintCount }) {
     `${pc.cyan("/discover")}             Run product discovery`,
     `${pc.cyan("/audit")}                Run a project health check`
   ].join("\n");
-  note(commands, "Available commands");
+  note(skills, "Available skills (global)");
   const toolNameMap = {
     "claude-code": "Claude Code",
     opencode: "OpenCode",
     cursor: "Cursor"
   };
-  const toolNames = tools.map((t) => toolNameMap[t]).join(" or ");
-  log4.info(`Open ${pc.bold(toolNames)} in this directory to use them.`);
-  log4.info(pc.dim(`Manage your account at https://withmata.dev/dashboard`));
+  const toolNames = tools.map((t) => toolNameMap[t]).join(", ");
+  log4.info(
+    `${pc.bold(String(installed.skillsInstalled))} skills installed globally for ${toolNames}.`
+  );
+  log4.info("These skills work in any project \u2014 no per-project setup needed.");
+  if (installed.legacyCommandsCleaned > 0) {
+    log4.info(
+      pc.dim(
+        `Cleaned up ${installed.legacyCommandsCleaned} legacy command symlink(s).`
+      )
+    );
+  }
+}
+
+// src/steps/uninstall.ts
+import {
+  existsSync as existsSync5,
+  readdirSync as readdirSync3,
+  lstatSync as lstatSync2,
+  readlinkSync as readlinkSync2,
+  unlinkSync as unlinkSync3,
+  rmSync as rmSync2
+} from "fs";
+import { join as join5 } from "path";
+import { intro, outro, confirm, log as log5, spinner as spinner3 } from "@clack/prompts";
+import pc2 from "picocolors";
+var SKILL_DIRS = [CLAUDE_SKILLS_DIR, OPENCODE_SKILLS_DIR, CURSOR_SKILLS_DIR];
+async function runUninstall() {
+  intro(
+    `${pc2.bgCyan(pc2.black(" @withmata/blueprints "))} ${pc2.dim(`v${VERSION}`)} ${pc2.yellow("uninstall")}`
+  );
+  const s = spinner3();
+  s.start("Scanning for withmata skill symlinks...");
+  let symlinksRemoved = 0;
+  for (const dir of SKILL_DIRS) {
+    if (!existsSync5(dir)) continue;
+    for (const entry of readdirSync3(dir)) {
+      const fullPath = join5(dir, entry);
+      try {
+        if (!lstatSync2(fullPath).isSymbolicLink()) continue;
+        const target = readlinkSync2(fullPath);
+        if (target.startsWith(BLUEPRINTS_DIR)) {
+          unlinkSync3(fullPath);
+          symlinksRemoved++;
+        }
+      } catch {
+      }
+    }
+  }
+  s.stop(
+    symlinksRemoved > 0 ? `Removed ${symlinksRemoved} skill symlink(s)` : "No withmata symlinks found"
+  );
+  let blueprintsRemoved = false;
+  if (existsSync5(BLUEPRINTS_DIR)) {
+    rmSync2(BLUEPRINTS_DIR, { recursive: true, force: true });
+    blueprintsRemoved = true;
+    log5.success("Removed cached blueprints (~/.withmata/blueprints/)");
+  }
+  let configRemoved = false;
+  if (existsSync5(WITHMATA_DIR)) {
+    const removeAll = await confirm({
+      message: "Also remove credentials and config (~/.withmata/)?",
+      initialValue: false
+    });
+    if (removeAll === true) {
+      rmSync2(WITHMATA_DIR, { recursive: true, force: true });
+      configRemoved = true;
+      log5.success("Removed ~/.withmata/");
+    }
+  }
+  if (!symlinksRemoved && !blueprintsRemoved && !configRemoved) {
+    outro("Nothing to clean up \u2014 already uninstalled.");
+  } else {
+    const parts = [];
+    if (symlinksRemoved > 0) parts.push(`${symlinksRemoved} symlink(s)`);
+    if (blueprintsRemoved) parts.push("cached blueprints");
+    if (configRemoved) parts.push("credentials & config");
+    outro(`Uninstalled: ${parts.join(", ")}`);
+  }
 }
 
 // src/index.ts
+var HELP = `
+Usage: @withmata/blueprints [command]
+
+Commands:
+  install      Install blueprints and skills (default)
+  uninstall    Remove skills, symlinks, and cached data
+
+Options:
+  -h, --help      Show this help message
+  -v, --version   Show version number
+`.trim();
 async function main() {
-  intro(`${pc2.bgCyan(pc2.black(" @withmata/blueprints "))} ${pc2.dim(`v${VERSION}`)}`);
+  const arg = process.argv[2];
+  if (arg === "--version" || arg === "-v") {
+    console.log(VERSION);
+    return;
+  }
+  if (arg === "--help" || arg === "-h") {
+    console.log(HELP);
+    return;
+  }
+  if (arg === "uninstall") {
+    await runUninstall();
+    return;
+  }
+  if (arg && arg !== "install") {
+    console.log(`Unknown command: ${arg}
+`);
+    console.log(HELP);
+    process.exit(1);
+  }
+  intro2(`${pc3.bgCyan(pc3.black(" @withmata/blueprints "))} ${pc3.dim(`v${VERSION}`)}`);
   const user = await checkAuth();
   if (user) {
-    log5.success(`Logged in as ${user.email} (${user.tier} plan)`);
+    log6.success(`Logged in as ${user.email} (${user.tier} plan)`);
   } else {
-    log5.info("Running in local mode");
+    log6.info("Running in local mode");
   }
   const tools = await detectAndSelectTools(process.cwd());
   const blueprints = await downloadBlueprints(user?.token);
-  const linked = await linkToProject(tools);
+  const installed = await installSkillsGlobally(tools);
   showSummary({
-    linked,
+    installed,
     tools,
     blueprintCount: blueprints.total
   });
-  outro("Setup complete!");
+  outro2("Setup complete!");
 }
 main().catch((err) => {
-  log5.error(
+  log6.error(
     err instanceof Error ? err.message : "An unexpected error occurred"
   );
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withmata/blueprints",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Set up AI-powered project blueprints for Claude Code, OpenCode, and Cursor",
   "type": "module",
   "bin": {
@@ -9,17 +9,16 @@
   "files": [
     "dist",
     "blueprints",
-    ".claude/commands",
-    ".opencode/commands",
-    ".cursor/commands",
+    ".claude/skills",
     "ENGINEERING.md"
   ],
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit",
-    "copy-blueprints": "node scripts/copy-blueprints.mjs",
-    "prepublishOnly": "node scripts/copy-blueprints.mjs && tsup"
+    "copy-blueprints": "bun scripts/copy-blueprints.mjs",
+    "prepublishOnly": "bun scripts/copy-blueprints.mjs && tsup",
+    "release": "bun scripts/release.ts"
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
@@ -38,7 +37,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/With-Mata/my-blueprints.git",
+    "url": "git+https://github.com/With-Mata/my-blueprints.git",
     "directory": "cli"
   },
   "keywords": [