@withmata/blueprints 0.3.3 → 0.3.5

package/dist/index.js

@@ -2,23 +2,16 @@
 
 // src/index.ts
 import { intro as intro2, outro as outro2, log as log6 } from "@clack/prompts";
-import pc3 from "picocolors";
+import pc4 from "picocolors";
 
 // src/constants.ts
 var API_URL = process.env["WITHMATA_API_URL"] || "https://blueprints.withmata.dev";
-var VERSION = "0.3.3";
-
-// src/steps/auth.ts
-import { log } from "@clack/prompts";
+var VERSION = "0.3.5";
 
-// src/lib/credentials.ts
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-  unlinkSync
-} from "fs";
+// src/lib/install-state.ts
+import { existsSync, readdirSync, lstatSync, readlinkSync } from "fs";
+import { execSync } from "child_process";
+import { join as join2 } from "path";
 
 // src/lib/paths.ts
 import { join } from "path";
@@ -41,9 +34,92 @@ var OPENCODE_COMMANDS_DIR = ".opencode/commands";
 var CURSOR_COMMANDS_DIR = ".cursor/commands";
 var BLUEPRINTS_PATH_ENV = "WITHMATA_BLUEPRINTS_PATH";
 
+// src/lib/install-state.ts
+function detectInstallState(targetDir) {
+  const previousSkillCount = countSkillDirs(SKILLS_SOURCE_DIR);
+  const toolStates = {
+    "claude-code": {
+      detected: hasClaudeCode(targetDir),
+      ...countInstalledSkills(CLAUDE_SKILLS_DIR)
+    },
+    opencode: {
+      detected: hasOpenCode(targetDir),
+      ...countInstalledSkills(OPENCODE_SKILLS_DIR)
+    },
+    cursor: {
+      detected: hasCursor(targetDir),
+      ...countInstalledSkills(CURSOR_SKILLS_DIR)
+    }
+  };
+  const anyToolHasSkills = Object.values(toolStates).some(
+    (s) => s.skillsInstalled
+  );
+  const isUpdate = anyToolHasSkills || existsSync(BLUEPRINTS_DIR) && previousSkillCount > 0;
+  return { isUpdate, previousSkillCount, toolStates };
+}
+function countSkillDirs(dir) {
+  if (!existsSync(dir)) return 0;
+  return readdirSync(dir, { withFileTypes: true }).filter(
+    (e) => e.isDirectory()
+  ).length;
+}
+function countInstalledSkills(skillsDir) {
+  if (!existsSync(skillsDir)) {
+    return { skillsInstalled: false, installedCount: 0 };
+  }
+  let count = 0;
+  for (const entry of readdirSync(skillsDir)) {
+    const entryPath = join2(skillsDir, entry);
+    try {
+      if (lstatSync(entryPath).isSymbolicLink()) {
+        const target = readlinkSync(entryPath);
+        if (target.includes(BLUEPRINTS_DIR)) {
+          count++;
+        }
+      }
+    } catch {
+    }
+  }
+  return { skillsInstalled: count > 0, installedCount: count };
+}
+function hasClaudeCode(targetDir) {
+  try {
+    execSync("which claude", { stdio: "ignore" });
+    return true;
+  } catch {
+    return existsSync(join2(targetDir, ".claude")) || existsSync(join2(targetDir, "CLAUDE.md"));
+  }
+}
+function hasOpenCode(targetDir) {
+  try {
+    execSync("which opencode", { stdio: "ignore" });
+    return true;
+  } catch {
+    return existsSync(join2(targetDir, ".opencode")) || existsSync(join2(targetDir, "opencode.json"));
+  }
+}
+function hasCursor(targetDir) {
+  try {
+    execSync("which cursor", { stdio: "ignore" });
+    return true;
+  } catch {
+    return existsSync(join2(targetDir, ".cursor"));
+  }
+}
+
+// src/steps/auth.ts
+import { log } from "@clack/prompts";
+
 // src/lib/credentials.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync
+} from "fs";
 function readCredentials() {
-  if (!existsSync(CREDENTIALS_PATH)) return null;
+  if (!existsSync2(CREDENTIALS_PATH)) return null;
   try {
     const raw = readFileSync(CREDENTIALS_PATH, "utf-8");
     const data = JSON.parse(raw);
@@ -65,37 +141,35 @@ async function checkAuth() {
 }
 
 // src/steps/tool-detect.ts
-import { existsSync as existsSync2 } from "fs";
-import { execSync } from "child_process";
-import { join as join2 } from "path";
 import { multiselect, isCancel, cancel } from "@clack/prompts";
-async function detectAndSelectTools(targetDir) {
-  const claudeDetected = hasClaudeCode(targetDir);
-  const opencodeDetected = hasOpenCode(targetDir);
-  const cursorDetected = hasCursor(targetDir);
+import pc from "picocolors";
+async function detectAndSelectTools(installState) {
+  const { isUpdate, toolStates } = installState;
   const choices = [
     {
       value: "claude-code",
       label: "Claude Code",
-      hint: claudeDetected ? "detected" : void 0
+      hint: buildHint(toolStates["claude-code"])
     },
     {
       value: "opencode",
       label: "OpenCode",
-      hint: opencodeDetected ? "detected" : void 0
+      hint: buildHint(toolStates.opencode)
     },
     {
       value: "cursor",
       label: "Cursor",
-      hint: cursorDetected ? "detected" : void 0
+      hint: buildHint(toolStates.cursor)
     }
   ];
   const initialValues = [];
-  if (claudeDetected) initialValues.push("claude-code");
-  if (opencodeDetected) initialValues.push("opencode");
-  if (cursorDetected) initialValues.push("cursor");
+  for (const [tool, state] of Object.entries(toolStates)) {
+    if (state.detected || state.skillsInstalled) {
+      initialValues.push(tool);
+    }
+  }
   const tools = await multiselect({
-    message: "Which AI coding tools do you use?",
+    message: isUpdate ? "Update skills for these tools?" : "Which AI coding tools do you use?",
     options: choices,
     initialValues,
     required: true
@@ -106,39 +180,27 @@ async function detectAndSelectTools(targetDir) {
   }
   return tools;
 }
-function hasClaudeCode(targetDir) {
-  try {
-    execSync("which claude", { stdio: "ignore" });
-    return true;
-  } catch {
-    return existsSync2(join2(targetDir, ".claude")) || existsSync2(join2(targetDir, "CLAUDE.md"));
+function buildHint(state) {
+  if (state.detected && state.skillsInstalled) {
+    return pc.green("detected \xB7 installed");
   }
-}
-function hasOpenCode(targetDir) {
-  try {
-    execSync("which opencode", { stdio: "ignore" });
-    return true;
-  } catch {
-    return existsSync2(join2(targetDir, ".opencode")) || existsSync2(join2(targetDir, "opencode.json"));
+  if (state.detected) {
+    return "detected";
   }
-}
-function hasCursor(targetDir) {
-  try {
-    execSync("which cursor", { stdio: "ignore" });
-    return true;
-  } catch {
-    return existsSync2(join2(targetDir, ".cursor"));
+  if (state.skillsInstalled) {
+    return "installed";
   }
+  return void 0;
 }
 
 // src/steps/download.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, cpSync, rmSync, readdirSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, cpSync, rmSync, readdirSync as readdirSync2 } from "fs";
 import { join as join3, resolve, dirname } from "path";
 import { fileURLToPath } from "url";
 import { spinner, log as log2 } from "@clack/prompts";
-async function downloadBlueprints(_token) {
+async function downloadBlueprints(_token, isUpdate = false) {
   const s = spinner();
-  s.start("Resolving blueprints...");
+  s.start(isUpdate ? "Updating blueprints..." : "Resolving blueprints...");
   const sourcePath = resolveBlueprintsSource();
   if (!sourcePath) {
     s.stop("Could not find blueprints source");
@@ -149,7 +211,7 @@ async function downloadBlueprints(_token) {
     );
     process.exit(1);
   }
-  s.message("Copying blueprints...");
+  s.message(isUpdate ? "Updating blueprints..." : "Copying blueprints...");
   rmSync(BLUEPRINTS_DIR, { recursive: true, force: true });
   mkdirSync2(BLUEPRINTS_DIR, { recursive: true });
   const blueprintsSource = join3(sourcePath, "blueprints");
@@ -169,7 +231,9 @@ async function downloadBlueprints(_token) {
     cpSync(engineeringSource, join3(BLUEPRINTS_DIR, "ENGINEERING.md"));
   }
   const blueprintIds = discoverBlueprints(join3(BLUEPRINTS_DIR, "blueprints"));
-  s.stop(`${blueprintIds.length} blueprints installed`);
+  s.stop(
+    `${blueprintIds.length} blueprints ${isUpdate ? "updated" : "installed"}`
+  );
   return {
     blueprintIds,
     total: blueprintIds.length,
@@ -209,7 +273,7 @@ function discoverBlueprints(blueprintsDir) {
   for (const tier of tiers) {
     const tierDir = join3(blueprintsDir, tier);
     if (!existsSync3(tierDir)) continue;
-    for (const entry of readdirSync(tierDir, { withFileTypes: true })) {
+    for (const entry of readdirSync2(tierDir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
         ids.push(entry.name);
       }
@@ -223,57 +287,62 @@ import {
   existsSync as existsSync4,
   mkdirSync as mkdirSync3,
   symlinkSync,
-  lstatSync,
+  lstatSync as lstatSync2,
   unlinkSync as unlinkSync2,
   renameSync,
-  readdirSync as readdirSync2,
-  readlinkSync
+  readdirSync as readdirSync3,
+  readlinkSync as readlinkSync2
 } from "fs";
 import { join as join4, resolve as resolve2 } from "path";
 import { spinner as spinner2, log as log3 } from "@clack/prompts";
-async function installSkillsGlobally(tools) {
+async function installSkillsGlobally(tools, isUpdate = false) {
   let skillsInstalled = 0;
   for (const tool of tools) {
     if (tool === "claude-code") {
       skillsInstalled += installSkills(
         SKILLS_SOURCE_DIR,
         CLAUDE_SKILLS_DIR,
-        "Claude Code"
+        "Claude Code",
+        isUpdate
       );
     }
     if (tool === "opencode") {
       skillsInstalled += installSkills(
         SKILLS_SOURCE_DIR,
         OPENCODE_SKILLS_DIR,
-        "OpenCode"
+        "OpenCode",
+        isUpdate
       );
     }
     if (tool === "cursor") {
       skillsInstalled += installSkills(
         SKILLS_SOURCE_DIR,
         CURSOR_SKILLS_DIR,
-        "Cursor"
+        "Cursor",
+        isUpdate
       );
     }
   }
   const legacyCommandsCleaned = cleanupLegacyCommands(process.cwd());
   return { skillsInstalled, legacyCommandsCleaned };
 }
-function installSkills(sourceDir, globalTargetDir, toolLabel) {
+function installSkills(sourceDir, globalTargetDir, toolLabel, isUpdate) {
   const s = spinner2();
-  s.start(`Installing skills for ${toolLabel}...`);
+  s.start(
+    isUpdate ? `Updating skills for ${toolLabel}...` : `Installing skills for ${toolLabel}...`
+  );
   mkdirSync3(globalTargetDir, { recursive: true });
   if (!existsSync4(sourceDir)) {
     s.stop(`No skills found for ${toolLabel}`);
     return 0;
   }
   let count = 0;
-  for (const entry of readdirSync2(sourceDir, { withFileTypes: true })) {
+  for (const entry of readdirSync3(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()) {
+      if (lstatSync2(target).isSymbolicLink()) {
         unlinkSync2(target);
       } else {
         const backup = `${target}.bak`;
@@ -286,7 +355,9 @@ function installSkills(sourceDir, globalTargetDir, toolLabel) {
     symlinkSync(source, target);
     count++;
   }
-  s.stop(`${count} skills installed for ${toolLabel}`);
+  s.stop(
+    `${count} skills ${isUpdate ? "updated" : "installed"} for ${toolLabel}`
+  );
   return count;
 }
 function cleanupLegacyCommands(targetDir) {
@@ -299,11 +370,11 @@ function cleanupLegacyCommands(targetDir) {
   for (const dir of legacyDirs) {
     if (!existsSync4(dir)) continue;
     let dirEmpty = true;
-    for (const file of readdirSync2(dir)) {
+    for (const file of readdirSync3(dir)) {
       const filePath = join4(dir, file);
-      if (lstatSync(filePath).isSymbolicLink()) {
+      if (lstatSync2(filePath).isSymbolicLink()) {
         try {
-          const linkTarget = readlinkSync(filePath);
+          const linkTarget = readlinkSync2(filePath);
           if (linkTarget.includes(BLUEPRINTS_DIR)) {
             unlinkSync2(filePath);
             cleaned++;
@@ -317,10 +388,10 @@ function cleanupLegacyCommands(targetDir) {
       }
       dirEmpty = false;
     }
-    if (dirEmpty && readdirSync2(dir).length === 0) {
+    if (dirEmpty && readdirSync3(dir).length === 0) {
       try {
-        readdirSync2(dir);
-        if (readdirSync2(dir).length === 0) {
+        readdirSync3(dir);
+        if (readdirSync3(dir).length === 0) {
           unlinkSync2(dir);
         }
       } catch {
@@ -334,7 +405,7 @@ function cleanupLegacyCommands(targetDir) {
 }
 function lstatExists(path) {
   try {
-    lstatSync(path);
+    lstatSync2(path);
     return true;
   } catch {
     return false;
@@ -343,30 +414,92 @@ function lstatExists(path) {
 
 // src/steps/summary.ts
 import { log as log4, note } from "@clack/prompts";
-import pc from "picocolors";
-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`,
-    `${pc.cyan("/scaffold-foundation")}  Set up monorepo skeleton`,
-    `${pc.cyan("/discover")}             Run product discovery`,
-    `${pc.cyan("/audit")}                Run a project health check`
-  ].join("\n");
-  note(skills, "Available skills (global)");
+import pc2 from "picocolors";
+var SKILL_GROUPS = [
+  {
+    title: "Getting Started",
+    skills: [
+      {
+        command: "/new-project",
+        description: "Build a new product end-to-end \u2014 from idea to running code"
+      },
+      {
+        command: "/discover",
+        description: "Define your product vision before writing any code"
+      }
+    ]
+  },
+  {
+    title: "Add to Your Project",
+    skills: [
+      {
+        command: "/scaffold-foundation",
+        description: "Set up a monorepo with Turborepo and shared tooling"
+      },
+      {
+        command: "/scaffold-db",
+        description: "Add a database with Drizzle ORM and PostgreSQL"
+      },
+      {
+        command: "/scaffold-auth",
+        description: "Add authentication, sessions, and organization support"
+      },
+      {
+        command: "/scaffold-env",
+        description: "Add validated environment variables with type-safe access"
+      },
+      {
+        command: "/scaffold-tailwind",
+        description: "Add a design system with Tailwind v4 tokens and animations"
+      },
+      {
+        command: "/scaffold-ui",
+        description: "Add a component library powered by shadcn/ui"
+      }
+    ]
+  },
+  {
+    title: "Maintain",
+    skills: [
+      {
+        command: "/audit",
+        description: "Check project health and find available upgrades"
+      }
+    ]
+  }
+];
+function showSummary({
+  installed,
+  tools,
+  isUpdate
+}) {
+  const maxCommandLen = Math.max(
+    ...SKILL_GROUPS.flatMap((g) => g.skills.map((s) => s.command.length))
+  );
+  const sections = SKILL_GROUPS.map((group) => {
+    const header = pc2.bold(group.title);
+    const lines = group.skills.map((skill) => {
+      const padded = skill.command.padEnd(maxCommandLen + 2);
+      return `  ${pc2.cyan(padded)}${pc2.dim(skill.description)}`;
+    });
+    return `${header}
+${lines.join("\n")}`;
+  });
+  note(sections.join("\n\n"), "Available skills");
   const toolNameMap = {
     "claude-code": "Claude Code",
     opencode: "OpenCode",
     cursor: "Cursor"
   };
   const toolNames = tools.map((t) => toolNameMap[t]).join(", ");
+  const verb = isUpdate ? "updated" : "installed";
   log4.info(
-    `${pc.bold(String(installed.skillsInstalled))} skills installed globally for ${toolNames}.`
+    `${pc2.bold(String(installed.skillsInstalled))} skills ${verb} for ${toolNames}.`
   );
   log4.info("These skills work in any project \u2014 no per-project setup needed.");
   if (installed.legacyCommandsCleaned > 0) {
     log4.info(
-      pc.dim(
+      pc2.dim(
         `Cleaned up ${installed.legacyCommandsCleaned} legacy command symlink(s).`
       )
     );
@@ -376,30 +509,30 @@ function showSummary({ installed, tools, blueprintCount }) {
 // src/steps/uninstall.ts
 import {
   existsSync as existsSync5,
-  readdirSync as readdirSync3,
-  lstatSync as lstatSync2,
-  readlinkSync as readlinkSync2,
+  readdirSync as readdirSync4,
+  lstatSync as lstatSync3,
+  readlinkSync as readlinkSync3,
   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";
+import pc3 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")}`
+    `${pc3.bgCyan(pc3.black(" @withmata/blueprints "))} ${pc3.dim(`v${VERSION}`)} ${pc3.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)) {
+    for (const entry of readdirSync4(dir)) {
       const fullPath = join5(dir, entry);
       try {
-        if (!lstatSync2(fullPath).isSymbolicLink()) continue;
-        const target = readlinkSync2(fullPath);
+        if (!lstatSync3(fullPath).isSymbolicLink()) continue;
+        const target = readlinkSync3(fullPath);
         if (target.startsWith(BLUEPRINTS_DIR)) {
           unlinkSync3(fullPath);
           symlinksRemoved++;
@@ -472,22 +605,30 @@ async function main() {
     console.log(HELP);
     process.exit(1);
   }
-  intro2(`${pc3.bgCyan(pc3.black(" @withmata/blueprints "))} ${pc3.dim(`v${VERSION}`)}`);
+  const installState = detectInstallState(process.cwd());
+  const { isUpdate } = installState;
+  const modeLabel = isUpdate ? ` ${pc4.dim("\xB7 update")}` : "";
+  intro2(
+    `${pc4.bgCyan(pc4.black(" @withmata/blueprints "))} ${pc4.dim(`v${VERSION}`)}${modeLabel}`
+  );
   const user = await checkAuth();
   if (user) {
     log6.success(`Logged in as ${user.email} (${user.tier} plan)`);
   } else {
     log6.info("Running in local mode");
   }
-  const tools = await detectAndSelectTools(process.cwd());
-  const blueprints = await downloadBlueprints(user?.token);
-  const installed = await installSkillsGlobally(tools);
+  const tools = await detectAndSelectTools(installState);
+  const blueprints = await downloadBlueprints(user?.token, isUpdate);
+  const installed = await installSkillsGlobally(tools, isUpdate);
   showSummary({
     installed,
     tools,
-    blueprintCount: blueprints.total
+    blueprintCount: blueprints.total,
+    isUpdate
   });
-  outro2("Setup complete!");
+  outro2(
+    isUpdate ? "Updated! Changes take effect in your next conversation." : "Setup complete! Type /new-project in any project to get started."
+  );
 }
 main().catch((err) => {
   log6.error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withmata/blueprints",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Set up AI-powered project blueprints for Claude Code, OpenCode, and Cursor",
   "type": "module",
   "bin": {