@ez-cook/nano-peaces 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,665 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/constants.ts
+var VERSION = "0.1.0";
+var CONFIG_DIR = ".nano-peaces";
+var CONFIG_FILE = "config.json";
+var CONTEXT_FILE = "context.json";
+var AGENT_TYPES = ["antigravity", "claude-code", "cursor", "generic"];
+
+// src/commands/init.ts
+import * as p from "@clack/prompts";
+
+// src/fingerprint/detect.ts
+import fs from "fs";
+import path from "path";
+function readPackageJson(projectRoot) {
+  const pkgPath = path.join(projectRoot, "package.json");
+  if (!fs.existsSync(pkgPath)) return null;
+  return JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+}
+function getAllDeps(pkg) {
+  return [...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.devDependencies || {})];
+}
+function hasDep(deps, name) {
+  return deps.some((d) => d === name || d.startsWith(name.replace("*", "")));
+}
+function hasAnyDep(deps, names) {
+  return names.some((name) => hasDep(deps, name));
+}
+function fileExists(projectRoot, ...parts) {
+  return fs.existsSync(path.join(projectRoot, ...parts));
+}
+function detectFramework(deps) {
+  if (hasDep(deps, "next")) return "nextjs";
+  if (hasDep(deps, "astro")) return "astro";
+  if (hasDep(deps, "@remix-run/react") || hasDep(deps, "@remix-run/node")) return "remix";
+  if (hasDep(deps, "vite")) return "vite";
+  if (hasDep(deps, "react-scripts")) return "cra";
+  return "unknown";
+}
+function detectUILibraries(deps, projectRoot) {
+  const libs = [];
+  const hasShadcnSignals = hasAnyDep(deps, ["radix-ui", "@radix-ui/react-slot", "@radix-ui/react-dialog"]) && hasDep(deps, "tailwindcss");
+  const hasComponentsJson = fileExists(projectRoot, "components.json");
+  if (hasComponentsJson || hasShadcnSignals) {
+    libs.push("shadcn");
+  }
+  if (hasDep(deps, "@carbon/react")) libs.push("carbon");
+  if (hasDep(deps, "@mantine/core")) libs.push("mantine");
+  if (hasDep(deps, "@headlessui/react")) libs.push("headless-ui");
+  if (hasDep(deps, "daisyui")) libs.push("daisyui");
+  if (hasDep(deps, "@ark-ui/react")) libs.push("ark-ui");
+  return libs;
+}
+function detectStyling(deps) {
+  if (hasDep(deps, "tailwindcss")) return "tailwind";
+  if (hasDep(deps, "styled-components") || hasDep(deps, "@emotion/styled"))
+    return "styled-components";
+  if (hasDep(deps, "sass") || hasDep(deps, "node-sass")) return "sass";
+  return "unknown";
+}
+function detectLanguage(projectRoot) {
+  if (fileExists(projectRoot, "tsconfig.json")) return "typescript";
+  return "javascript";
+}
+function detectRouter(deps, projectRoot) {
+  if (hasDep(deps, "next")) {
+    if (fileExists(projectRoot, "app") || fileExists(projectRoot, "src", "app")) return "app-router";
+    if (fileExists(projectRoot, "pages") || fileExists(projectRoot, "src", "pages"))
+      return "pages-router";
+    return "app-router";
+  }
+  if (hasDep(deps, "@tanstack/react-router")) return "tanstack-router";
+  if (hasDep(deps, "react-router") || hasDep(deps, "react-router-dom")) return "react-router";
+  return "unknown";
+}
+function detectStateManagement(deps) {
+  const state = [];
+  if (hasDep(deps, "zustand")) state.push("zustand");
+  if (hasDep(deps, "jotai")) state.push("jotai");
+  if (hasDep(deps, "@reduxjs/toolkit") || hasDep(deps, "redux")) state.push("redux");
+  if (hasDep(deps, "recoil")) state.push("recoil");
+  if (hasDep(deps, "valtio")) state.push("valtio");
+  return state;
+}
+function detectFormLibrary(deps) {
+  if (hasDep(deps, "react-hook-form")) return "react-hook-form";
+  if (hasDep(deps, "formik")) return "formik";
+  return null;
+}
+function recommendSkills(fingerprint) {
+  const skills = [];
+  if (fingerprint.uiLibraries.includes("shadcn")) {
+    skills.push("shadcn-ui");
+  }
+  if (fingerprint.uiLibraries.includes("carbon")) {
+    skills.push("carbon-design");
+  }
+  if (fingerprint.uiLibraries.length > 1) {
+    skills.push("ui-selector");
+  }
+  return skills;
+}
+function createFingerprint(projectRoot) {
+  const pkg = readPackageJson(projectRoot);
+  if (!pkg) {
+    return {
+      framework: "unknown",
+      uiLibraries: [],
+      styling: "unknown",
+      language: detectLanguage(projectRoot),
+      router: "unknown",
+      stateManagement: [],
+      formLibrary: null,
+      recommendedSkills: []
+    };
+  }
+  const deps = getAllDeps(pkg);
+  const base = {
+    framework: detectFramework(deps),
+    uiLibraries: detectUILibraries(deps, projectRoot),
+    styling: detectStyling(deps),
+    language: detectLanguage(projectRoot),
+    router: detectRouter(deps, projectRoot),
+    stateManagement: detectStateManagement(deps),
+    formLibrary: detectFormLibrary(deps)
+  };
+  return {
+    ...base,
+    recommendedSkills: recommendSkills(base)
+  };
+}
+
+// src/adapters/antigravity.ts
+import path2 from "path";
+var AntigravityAdapter = class {
+  name = "antigravity";
+  getOutputDir(_projectRoot) {
+    return ".agent/skills";
+  }
+  transform(source) {
+    const outputs = [];
+    const baseDir = path2.join(".agent", "skills", source.id);
+    outputs.push({
+      path: path2.join(baseDir, "SKILL.md"),
+      content: source.skillMd
+    });
+    for (const [chunkPath, chunkContent] of source.chunks) {
+      outputs.push({
+        path: path2.join(baseDir, chunkPath),
+        content: chunkContent
+      });
+    }
+    const registryOutput = {
+      path: path2.join(".agent", "skills", "registry.json"),
+      content: JSON.stringify(
+        {
+          version: "0.1.0",
+          skills: [
+            {
+              id: source.registry.id,
+              description: source.registry.description,
+              skillPath: `${source.id}/SKILL.md`,
+              signals: source.registry.signals,
+              priority: source.registry.priority
+            }
+          ]
+        },
+        null,
+        2
+      )
+    };
+    outputs.push(registryOutput);
+    return outputs;
+  }
+  getInstructions() {
+    return [
+      "\u2713 Skills installed to .agent/skills/",
+      "",
+      "Antigravity will automatically detect and load these skills.",
+      "The agent reads registry.json first, then loads SKILL.md on match.",
+      "Deep chunks are loaded on-demand based on the Context Router table."
+    ].join("\n");
+  }
+};
+
+// src/adapters/claude-code.ts
+var ClaudeCodeAdapter = class {
+  name = "claude-code";
+  getOutputDir(_projectRoot) {
+    return ".";
+  }
+  transform(source) {
+    const sections = [];
+    sections.push(`## UI Skills: ${source.id}
+`);
+    sections.push(stripFrontmatter(source.skillMd));
+    for (const [chunkPath, chunkContent] of source.chunks) {
+      sections.push(`
+---
+
+<!-- ${chunkPath} -->
+`);
+      sections.push(chunkContent);
+    }
+    return [
+      {
+        path: "CLAUDE.md",
+        content: sections.join("\n")
+      }
+    ];
+  }
+  getInstructions() {
+    return [
+      "\u2713 Skills appended to CLAUDE.md",
+      "",
+      "Claude Code reads CLAUDE.md automatically on every interaction.",
+      "All skill content has been inlined into a single document."
+    ].join("\n");
+  }
+};
+function stripFrontmatter(md) {
+  const match = md.match(/^---\n[\s\S]*?\n---\n(.*)$/s);
+  return match ? match[1].trim() : md;
+}
+
+// src/adapters/cursor.ts
+var CursorAdapter = class {
+  name = "cursor";
+  getOutputDir(_projectRoot) {
+    return ".cursor/rules";
+  }
+  transform(source) {
+    const sections = [];
+    sections.push("---");
+    sections.push(`description: ${source.registry.description || source.id + " skill"}`);
+    sections.push(`globs: ${JSON.stringify(source.registry.signals.filePatterns || ["**/*.tsx"])}`);
+    sections.push("alwaysApply: false");
+    sections.push("---\n");
+    sections.push(stripFrontmatter2(source.skillMd));
+    for (const [, chunkContent] of source.chunks) {
+      sections.push(`
+---
+`);
+      sections.push(chunkContent);
+    }
+    return [
+      {
+        path: `.cursor/rules/${source.id}.mdc`,
+        content: sections.join("\n")
+      }
+    ];
+  }
+  getInstructions() {
+    return [
+      "\u2713 Skills installed to .cursor/rules/",
+      "",
+      "Cursor will load rules automatically based on glob patterns.",
+      "Rules activate when you work on matching files."
+    ].join("\n");
+  }
+};
+function stripFrontmatter2(md) {
+  const match = md.match(/^---\n[\s\S]*?\n---\n(.*)$/s);
+  return match ? match[1].trim() : md;
+}
+
+// src/adapters/generic.ts
+import path3 from "path";
+var GenericAdapter = class {
+  name = "generic";
+  getOutputDir(_projectRoot) {
+    return ".ai/skills";
+  }
+  transform(source) {
+    const outputs = [];
+    const baseDir = path3.join(".ai", "skills", source.id);
+    outputs.push({
+      path: path3.join(baseDir, "SKILL.md"),
+      content: source.skillMd
+    });
+    for (const [chunkPath, chunkContent] of source.chunks) {
+      outputs.push({
+        path: path3.join(baseDir, chunkPath),
+        content: chunkContent
+      });
+    }
+    outputs.push({
+      path: path3.join(".ai", "skills", "registry.json"),
+      content: JSON.stringify(
+        {
+          version: "0.1.0",
+          skills: [
+            {
+              id: source.registry.id,
+              description: source.registry.description,
+              skillPath: `${source.id}/SKILL.md`,
+              signals: source.registry.signals,
+              priority: source.registry.priority
+            }
+          ]
+        },
+        null,
+        2
+      )
+    });
+    return outputs;
+  }
+  getInstructions() {
+    return [
+      "\u2713 Skills installed to .ai/skills/",
+      "",
+      "Point your AI agent to .ai/skills/registry.json to discover skills.",
+      "Chunks are loaded on-demand based on the Context Router in SKILL.md."
+    ].join("\n");
+  }
+};
+
+// src/adapters/registry.ts
+var adapters = {
+  antigravity: () => new AntigravityAdapter(),
+  "claude-code": () => new ClaudeCodeAdapter(),
+  cursor: () => new CursorAdapter(),
+  generic: () => new GenericAdapter()
+};
+function getAdapter(agentType) {
+  const factory = adapters[agentType];
+  if (!factory) {
+    throw new Error(`Unknown agent type: ${agentType}`);
+  }
+  return factory();
+}
+
+// src/utils/skills.ts
+import fs2 from "fs";
+import path4 from "path";
+function getSkillsDir() {
+  let dir = path4.dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 10; i++) {
+    const candidate = path4.join(dir, "packages", "skills");
+    if (fs2.existsSync(candidate)) return candidate;
+    const sibling = path4.join(dir, "skills");
+    if (fs2.existsSync(sibling)) return sibling;
+    dir = path4.dirname(dir);
+  }
+  throw new Error("Could not locate skills directory. Is nano-peaces installed correctly?");
+}
+function loadRegistry() {
+  const skillsDir = getSkillsDir();
+  const registryPath = path4.join(skillsDir, "registry.json");
+  if (!fs2.existsSync(registryPath)) {
+    throw new Error(`Registry not found at ${registryPath}`);
+  }
+  return JSON.parse(fs2.readFileSync(registryPath, "utf-8"));
+}
+function loadSkillSource(skillId) {
+  const skillsDir = getSkillsDir();
+  const registry = loadRegistry();
+  const entry = registry.skills.find((s) => s.id === skillId);
+  if (!entry) {
+    throw new Error(`Skill "${skillId}" not found in registry.`);
+  }
+  const skillMdPath = path4.join(skillsDir, entry.skillPath);
+  if (!fs2.existsSync(skillMdPath)) {
+    throw new Error(`SKILL.md not found at ${skillMdPath}`);
+  }
+  const skillMd = fs2.readFileSync(skillMdPath, "utf-8");
+  const chunks = /* @__PURE__ */ new Map();
+  const skillDir = path4.join(skillsDir, skillId);
+  const chunksDir = path4.join(skillDir, "chunks");
+  if (fs2.existsSync(chunksDir)) {
+    loadChunksRecursive(chunksDir, "chunks", chunks);
+  }
+  return {
+    id: skillId,
+    skillMd,
+    chunks,
+    registry: entry
+  };
+}
+function loadChunksRecursive(dir, relativePath, chunks) {
+  const entries = fs2.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path4.join(dir, entry.name);
+    const relPath = path4.join(relativePath, entry.name);
+    if (entry.isDirectory()) {
+      loadChunksRecursive(fullPath, relPath, chunks);
+    } else if (entry.name.endsWith(".md")) {
+      chunks.set(relPath, fs2.readFileSync(fullPath, "utf-8"));
+    }
+  }
+}
+function getAvailableSkills() {
+  const registry = loadRegistry();
+  return registry.skills;
+}
+
+// src/utils/files.ts
+import fs3 from "fs";
+import path5 from "path";
+function writeSkillFiles(outputs, projectRoot) {
+  for (const output of outputs) {
+    const fullPath = path5.join(projectRoot, output.path);
+    fs3.mkdirSync(path5.dirname(fullPath), { recursive: true });
+    fs3.writeFileSync(fullPath, output.content, "utf-8");
+  }
+}
+function saveConfig(config, projectRoot) {
+  const configDir = path5.join(projectRoot, CONFIG_DIR);
+  fs3.mkdirSync(configDir, { recursive: true });
+  fs3.writeFileSync(path5.join(configDir, CONFIG_FILE), JSON.stringify(config, null, 2), "utf-8");
+}
+function loadConfig(projectRoot) {
+  const configPath = path5.join(projectRoot, CONFIG_DIR, CONFIG_FILE);
+  if (!fs3.existsSync(configPath)) return null;
+  return JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+}
+function saveContext(fingerprint, projectRoot) {
+  const configDir = path5.join(projectRoot, CONFIG_DIR);
+  fs3.mkdirSync(configDir, { recursive: true });
+  fs3.writeFileSync(
+    path5.join(configDir, CONTEXT_FILE),
+    JSON.stringify(fingerprint, null, 2),
+    "utf-8"
+  );
+}
+function updateGitignore(projectRoot, _agentDir) {
+  const gitignorePath = path5.join(projectRoot, ".gitignore");
+  const entriesToAdd = [CONFIG_DIR];
+  let content = "";
+  if (fs3.existsSync(gitignorePath)) {
+    content = fs3.readFileSync(gitignorePath, "utf-8");
+  }
+  const linesToAdd = [];
+  for (const entry of entriesToAdd) {
+    if (!content.includes(entry)) {
+      linesToAdd.push(entry);
+    }
+  }
+  if (linesToAdd.length > 0) {
+    const section = `
+# nano-peaces config
+${linesToAdd.join("\n")}
+`;
+    fs3.writeFileSync(gitignorePath, content.trimEnd() + "\n" + section, "utf-8");
+  }
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  p.intro("nano-peaces init");
+  const projectRoot = process.cwd();
+  const s = p.spinner();
+  s.start("Scanning project...");
+  const fingerprint = createFingerprint(projectRoot);
+  s.stop("Project scanned");
+  const detectedParts = [];
+  if (fingerprint.framework !== "unknown") detectedParts.push(fingerprint.framework);
+  if (fingerprint.language === "typescript") detectedParts.push("TypeScript");
+  if (fingerprint.styling !== "unknown") detectedParts.push(fingerprint.styling);
+  for (const lib of fingerprint.uiLibraries) detectedParts.push(lib);
+  if (detectedParts.length > 0) {
+    p.log.info(`Detected: ${detectedParts.join(" + ")}`);
+  } else {
+    p.log.warn("Could not detect project stack. Skills will still work.");
+  }
+  let agentType;
+  if (options.agent && AGENT_TYPES.includes(options.agent)) {
+    agentType = options.agent;
+  } else if (options.yes) {
+    agentType = "antigravity";
+    p.log.info(`Agent: ${agentType} (default)`);
+  } else {
+    const selected = await p.select({
+      message: "Which AI agent are you using?",
+      options: [
+        { value: "antigravity", label: "Antigravity", hint: ".agent/skills/" },
+        { value: "claude-code", label: "Claude Code", hint: "CLAUDE.md" },
+        { value: "cursor", label: "Cursor", hint: ".cursor/rules/" },
+        { value: "generic", label: "Generic", hint: ".ai/skills/" }
+      ]
+    });
+    if (p.isCancel(selected)) {
+      p.cancel("Init cancelled.");
+      process.exit(0);
+    }
+    agentType = selected;
+  }
+  const availableSkills = getAvailableSkills();
+  let selectedSkillIds;
+  if (options.yes) {
+    selectedSkillIds = fingerprint.recommendedSkills.length > 0 ? fingerprint.recommendedSkills.filter((id) => availableSkills.some((s2) => s2.id === id)) : availableSkills.map((s2) => s2.id);
+    p.log.info(`Skills: ${selectedSkillIds.join(", ")}`);
+  } else {
+    const skillOptions = availableSkills.map((skill) => ({
+      value: skill.id,
+      label: skill.id,
+      hint: skill.description || ""
+    }));
+    if (skillOptions.length === 0) {
+      p.log.error("No skills available. This might be an installation issue.");
+      process.exit(1);
+    }
+    if (skillOptions.length === 1) {
+      selectedSkillIds = [skillOptions[0].value];
+      p.log.info(`Skill: ${selectedSkillIds[0]}`);
+    } else {
+      const selected = await p.multiselect({
+        message: "Which skills do you want to install?",
+        options: skillOptions,
+        initialValues: fingerprint.recommendedSkills.filter(
+          (id) => availableSkills.some((s2) => s2.id === id)
+        ),
+        required: true
+      });
+      if (p.isCancel(selected)) {
+        p.cancel("Init cancelled.");
+        process.exit(0);
+      }
+      selectedSkillIds = selected;
+    }
+  }
+  const adapter = getAdapter(agentType);
+  s.start("Installing skills...");
+  for (const skillId of selectedSkillIds) {
+    try {
+      const source = loadSkillSource(skillId);
+      const outputs = adapter.transform(source);
+      writeSkillFiles(outputs, projectRoot);
+    } catch (err) {
+      s.stop(`Failed to install skill: ${skillId}`);
+      p.log.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  }
+  s.stop(`Installed ${selectedSkillIds.length} skill(s)`);
+  saveConfig(
+    {
+      agent: agentType,
+      skills: selectedSkillIds,
+      version: VERSION,
+      autoUpdate: false
+    },
+    projectRoot
+  );
+  saveContext(fingerprint, projectRoot);
+  updateGitignore(projectRoot, adapter.getOutputDir(projectRoot));
+  p.log.message(adapter.getInstructions());
+  p.outro("Done! Your AI agent now has UI superpowers.");
+}
+
+// src/commands/add.ts
+import * as p2 from "@clack/prompts";
+async function addCommand(skillId, options) {
+  p2.intro("nano-peaces add");
+  const projectRoot = process.cwd();
+  const config = loadConfig(projectRoot);
+  const availableSkills = getAvailableSkills();
+  let agentType;
+  if (options.agent && AGENT_TYPES.includes(options.agent)) {
+    agentType = options.agent;
+  } else if (config) {
+    agentType = config.agent;
+  } else {
+    p2.log.error("No config found. Run `nano-peaces init` first, or pass --agent.");
+    process.exit(1);
+  }
+  const adapter = getAdapter(agentType);
+  let skillIds;
+  if (options.all) {
+    const fingerprint = createFingerprint(projectRoot);
+    skillIds = fingerprint.recommendedSkills.length > 0 ? fingerprint.recommendedSkills.filter((id) => availableSkills.some((s2) => s2.id === id)) : availableSkills.map((s2) => s2.id);
+  } else if (skillId) {
+    if (!availableSkills.some((s2) => s2.id === skillId)) {
+      p2.log.error(`Skill "${skillId}" not found.`);
+      p2.log.info(`Available: ${availableSkills.map((s2) => s2.id).join(", ")}`);
+      process.exit(1);
+    }
+    skillIds = [skillId];
+  } else {
+    const selected = await p2.multiselect({
+      message: "Which skills do you want to add?",
+      options: availableSkills.map((s2) => ({
+        value: s2.id,
+        label: s2.id,
+        hint: s2.description || ""
+      })),
+      required: true
+    });
+    if (p2.isCancel(selected)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    skillIds = selected;
+  }
+  const s = p2.spinner();
+  s.start("Adding skills...");
+  for (const id of skillIds) {
+    try {
+      const source = loadSkillSource(id);
+      const outputs = adapter.transform(source);
+      writeSkillFiles(outputs, projectRoot);
+    } catch (err) {
+      s.stop(`Failed to add skill: ${id}`);
+      p2.log.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  }
+  s.stop(`Added ${skillIds.length} skill(s): ${skillIds.join(", ")}`);
+  if (config) {
+    const updatedSkills = [.../* @__PURE__ */ new Set([...config.skills, ...skillIds])];
+    saveConfig({ ...config, skills: updatedSkills }, projectRoot);
+  }
+  p2.outro("Done!");
+}
+
+// src/commands/list.ts
+import * as p3 from "@clack/prompts";
+async function listCommand() {
+  p3.intro("nano-peaces list");
+  const projectRoot = process.cwd();
+  const config = loadConfig(projectRoot);
+  const installedSkills = config?.skills ?? [];
+  const availableSkills = getAvailableSkills();
+  if (availableSkills.length === 0) {
+    p3.log.warn("No skills available in registry.");
+    p3.outro("Check your installation.");
+    return;
+  }
+  p3.log.info("Available skills:\n");
+  for (const skill of availableSkills) {
+    const isInstalled = installedSkills.includes(skill.id);
+    const status = isInstalled ? "\u25CF" : "\u25CB";
+    const tag = isInstalled ? " (installed)" : "";
+    const desc = skill.description ? `  ${skill.description}` : "";
+    p3.log.message(`  ${status}  ${skill.id}${tag}${desc}`);
+  }
+  p3.log.message("");
+  if (installedSkills.length > 0) {
+    p3.log.info(
+      `${installedSkills.length} installed, ${availableSkills.length - installedSkills.length} available`
+    );
+  }
+  p3.outro("Use `nano-peaces add <skill>` to install a skill.");
+}
+
+// src/commands/update.ts
+import * as p4 from "@clack/prompts";
+async function updateCommand() {
+  p4.intro("nano-peaces update");
+  p4.log.warn("Update command coming in v0.2.0");
+  p4.outro("Stay tuned!");
+}
+
+// src/index.ts
+var program = new Command();
+program.name("nano-peaces").description("The missing UI skills pack for AI agents").version(VERSION);
+program.command("init").description("Initialize nano-peaces in your project").option("-a, --agent <type>", "AI agent type (antigravity|claude-code|cursor|generic)").option("-y, --yes", "Skip prompts, use defaults").action(initCommand);
+program.command("add [skill-id]").description("Add a UI skill to your project").option("--all", "Add all recommended skills").option("-a, --agent <type>", "AI agent type (antigravity|claude-code|cursor|generic)").action(addCommand);
+program.command("list").description("List available UI skills").action(listCommand);
+program.command("update").description("Update installed skills to latest").action(updateCommand);
+program.parse();