@withmata/blueprints 0.2.0

package/dist/index.js

@@ -0,0 +1,453 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { intro, outro, log as log5 } from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/constants.ts
+var API_URL = process.env["WITHMATA_API_URL"] || "https://blueprints.withmata.dev";
+var VERSION = "0.2.0";
+
+// src/steps/auth.ts
+import { log } from "@clack/prompts";
+
+// src/lib/credentials.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync
+} from "fs";
+
+// src/lib/paths.ts
+import { join } from "path";
+import { homedir } from "os";
+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 CLAUDE_COMMANDS_DIR = ".claude/commands";
+var OPENCODE_COMMANDS_DIR = ".opencode/commands";
+var CURSOR_COMMANDS_DIR = ".cursor/commands";
+var BLUEPRINTS_PATH_ENV = "WITHMATA_BLUEPRINTS_PATH";
+
+// src/lib/credentials.ts
+function readCredentials() {
+  if (!existsSync(CREDENTIALS_PATH)) return null;
+  try {
+    const raw = readFileSync(CREDENTIALS_PATH, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.expiresAt && new Date(data.expiresAt) < /* @__PURE__ */ new Date()) {
+      unlinkSync(CREDENTIALS_PATH);
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+// src/steps/auth.ts
+async function checkAuth() {
+  const creds = readCredentials();
+  if (!creds) return null;
+  return { ...creds.user, token: creds.token };
+}
+
+// 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);
+  const choices = [
+    {
+      value: "claude-code",
+      label: "Claude Code",
+      hint: claudeDetected ? "detected" : void 0
+    },
+    {
+      value: "opencode",
+      label: "OpenCode",
+      hint: opencodeDetected ? "detected" : void 0
+    },
+    {
+      value: "cursor",
+      label: "Cursor",
+      hint: cursorDetected ? "detected" : void 0
+    }
+  ];
+  const initialValues = [];
+  if (claudeDetected) initialValues.push("claude-code");
+  if (opencodeDetected) initialValues.push("opencode");
+  if (cursorDetected) initialValues.push("cursor");
+  const tools = await multiselect({
+    message: "Which AI coding tools do you use?",
+    options: choices,
+    initialValues,
+    required: true
+  });
+  if (isCancel(tools)) {
+    cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  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 hasOpenCode(targetDir) {
+  try {
+    execSync("which opencode", { stdio: "ignore" });
+    return true;
+  } catch {
+    return existsSync2(join2(targetDir, ".opencode")) || existsSync2(join2(targetDir, "opencode.json"));
+  }
+}
+function hasCursor(targetDir) {
+  try {
+    execSync("which cursor", { stdio: "ignore" });
+    return true;
+  } catch {
+    return existsSync2(join2(targetDir, ".cursor"));
+  }
+}
+
+// src/steps/download.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, cpSync, rmSync, readdirSync } 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) {
+  const s = spinner();
+  s.start("Resolving blueprints...");
+  const sourcePath = resolveBlueprintsSource();
+  if (!sourcePath) {
+    s.stop("Could not find blueprints source");
+    log2.error(
+      `Unable to locate the blueprints repository.
+  Set ${BLUEPRINTS_PATH_ENV} to the path of your my-blueprints repo,
+  or run this command from within the repo.`
+    );
+    process.exit(1);
+  }
+  s.message("Copying blueprints...");
+  rmSync(BLUEPRINTS_DIR, { recursive: true, force: true });
+  mkdirSync2(BLUEPRINTS_DIR, { recursive: true });
+  const blueprintsSource = join3(sourcePath, "blueprints");
+  if (existsSync3(blueprintsSource)) {
+    cpSync(blueprintsSource, join3(BLUEPRINTS_DIR, "blueprints"), {
+      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");
+    mkdirSync2(target, { recursive: true });
+    cpSync(cursorCommandsSource, target, { recursive: true });
+  }
+  const engineeringSource = join3(sourcePath, "ENGINEERING.md");
+  if (existsSync3(engineeringSource)) {
+    cpSync(engineeringSource, join3(BLUEPRINTS_DIR, "ENGINEERING.md"));
+  }
+  const blueprintIds = discoverBlueprints(join3(BLUEPRINTS_DIR, "blueprints"));
+  s.stop(`${blueprintIds.length} blueprints installed`);
+  return {
+    blueprintIds,
+    total: blueprintIds.length,
+    sourcePath
+  };
+}
+function resolveBlueprintsSource() {
+  const envPath = process.env[BLUEPRINTS_PATH_ENV];
+  if (envPath && isBlueprintsRepo(envPath)) {
+    return resolve(envPath);
+  }
+  const __filename = fileURLToPath(import.meta.url);
+  const cliRoot = resolve(dirname(__filename), "..");
+  if (isBlueprintsRepo(cliRoot)) {
+    return cliRoot;
+  }
+  const repoRoot = resolve(cliRoot, "..");
+  if (isBlueprintsRepo(repoRoot)) {
+    return repoRoot;
+  }
+  const cwd = process.cwd();
+  if (isBlueprintsRepo(cwd)) {
+    return cwd;
+  }
+  if (existsSync3(join3(BLUEPRINTS_DIR, "blueprints"))) {
+    return BLUEPRINTS_DIR;
+  }
+  return null;
+}
+function isBlueprintsRepo(dir) {
+  return existsSync3(join3(dir, "blueprints")) && existsSync3(join3(dir, "ENGINEERING.md"));
+}
+function discoverBlueprints(blueprintsDir) {
+  const ids = [];
+  if (!existsSync3(blueprintsDir)) return ids;
+  const tiers = ["discovery", "foundation", "features"];
+  for (const tier of tiers) {
+    const tierDir = join3(blueprintsDir, tier);
+    if (!existsSync3(tierDir)) continue;
+    for (const entry of readdirSync(tierDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        ids.push(entry.name);
+      }
+    }
+  }
+  return ids;
+}
+
+// src/steps/link.ts
+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
+} 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();
+  for (const tool of tools) {
+    if (tool === "claude-code") {
+      const result = linkCommands(
+        join4(BLUEPRINTS_DIR, CLAUDE_COMMANDS_DIR),
+        join4(targetDir, CLAUDE_COMMANDS_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),
+        "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),
+        "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 };
+}
+function linkCommands(sourceDir, targetDir, toolLabel) {
+  const s = spinner2();
+  s.start(`Linking commands for ${toolLabel}...`);
+  mkdirSync3(targetDir, { recursive: true });
+  let count = 0;
+  if (!existsSync4(sourceDir)) {
+    s.stop(`No commands 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)) {
+      if (lstatSync(target).isSymbolicLink()) {
+        unlinkSync2(target);
+      } else {
+        renameSync(target, `${target}.bak`);
+      }
+    }
+    symlinkSync(source, target);
+    count++;
+  }
+  s.stop(`${count} commands linked 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);
+      }
+      log3.success(`Updated ${filename} (refreshed blueprint catalog)`);
+      return true;
+    }
+    appendFileSync(filepath, block);
+  } else {
+    writeFileSync2(filepath, block.trimStart());
+  }
+  log3.success(`Updated ${filename}`);
+  return true;
+}
+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;
+  }
+  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 = [
+    `${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(commands, "Available commands");
+  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`));
+}
+
+// src/index.ts
+async function main() {
+  intro(`${pc2.bgCyan(pc2.black(" @withmata/blueprints "))} ${pc2.dim(`v${VERSION}`)}`);
+  const user = await checkAuth();
+  if (user) {
+    log5.success(`Logged in as ${user.email} (${user.tier} plan)`);
+  } else {
+    log5.info("Running in local mode");
+  }
+  const tools = await detectAndSelectTools(process.cwd());
+  const blueprints = await downloadBlueprints(user?.token);
+  const linked = await linkToProject(tools);
+  showSummary({
+    linked,
+    tools,
+    blueprintCount: blueprints.total
+  });
+  outro("Setup complete!");
+}
+main().catch((err) => {
+  log5.error(
+    err instanceof Error ? err.message : "An unexpected error occurred"
+  );
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@withmata/blueprints",
+  "version": "0.2.0",
+  "description": "Set up AI-powered project blueprints for Claude Code, OpenCode, and Cursor",
+  "type": "module",
+  "bin": {
+    "withmata-blueprints": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "blueprints",
+    ".claude/commands",
+    ".opencode/commands",
+    ".cursor/commands",
+    "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"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "picocolors": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/With-Mata/my-blueprints.git",
+    "directory": "cli"
+  },
+  "keywords": [
+    "blueprints",
+    "claude-code",
+    "opencode",
+    "scaffolding",
+    "ai-coding"
+  ],
+  "author": "WithMata",
+  "license": "MIT"
+}