@valentia-ai-skills/framework 1.0.13 → 2.0.1

package/bin/cli.js

@@ -4,11 +4,12 @@
  * ai-skills CLI — @valentia-ai-skills/framework
  *
  * Usage:
- *   npx ai-skills setup              # Enter email → lookup team → install team's skills
- *   npx ai-skills update             # Re-fetch skills from Supabase for your team
- *   npx ai-skills status             # Show installed skills and team info
+ *   npx ai-skills setup              # Enter email → lookup team → install full toolkit
+ *   npx ai-skills update             # Re-fetch toolkit from Supabase for your team
+ *   npx ai-skills status             # Show installed toolkit and team info
  *   npx ai-skills list               # List all locally available skills
  *   npx ai-skills doctor             # Health check
+ *   npx ai-skills analyze            # Analyze last commit against active skills
  */
 
 const fs = require("fs");
@@ -31,6 +32,111 @@ const ANALYZE_FUNCTION_URL =
 const SCAN_FUNCTION_URL =
   process.env.AI_SKILLS_SCAN_URL || "https://znshdhjquohrzvbnloki.supabase.co/functions/v1/scan-results";
 
+// ── Language Detection ──
+
+const LANGUAGE_DETECTORS = {
+  typescript: {
+    files: ["tsconfig.json", "tsconfig.base.json"],
+    packageDeps: ["typescript"],
+    extensions: [".ts", ".tsx"],
+  },
+  javascript: {
+    files: ["jsconfig.json"],
+    packageDeps: [],
+    extensions: [".js", ".jsx"],
+  },
+  python: {
+    files: ["requirements.txt", "Pipfile", "pyproject.toml", "setup.py", "setup.cfg"],
+    packageDeps: [],
+    extensions: [".py"],
+  },
+  golang: {
+    files: ["go.mod", "go.sum"],
+    packageDeps: [],
+    extensions: [".go"],
+  },
+  rust: {
+    files: ["Cargo.toml", "Cargo.lock"],
+    packageDeps: [],
+    extensions: [".rs"],
+  },
+  java: {
+    files: ["pom.xml", "build.gradle", "build.gradle.kts"],
+    packageDeps: [],
+    extensions: [".java"],
+  },
+  kotlin: {
+    files: ["build.gradle.kts"],
+    packageDeps: [],
+    extensions: [".kt", ".kts"],
+  },
+  swift: {
+    files: ["Package.swift", "*.xcodeproj"],
+    packageDeps: [],
+    extensions: [".swift"],
+  },
+  php: {
+    files: ["composer.json", "artisan"],
+    packageDeps: [],
+    extensions: [".php"],
+  },
+  csharp: {
+    files: ["*.csproj", "*.sln"],
+    packageDeps: [],
+    extensions: [".cs"],
+  },
+  cpp: {
+    files: ["CMakeLists.txt", "Makefile"],
+    packageDeps: [],
+    extensions: [".cpp", ".cc", ".h", ".hpp"],
+  },
+};
+
+function detectLanguages() {
+  const detected = [];
+
+  // Check package.json for TS dependency
+  let pkgDeps = {};
+  try {
+    const pkgPath = path.join(PROJECT_ROOT, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      pkgDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    }
+  } catch { /* ignore */ }
+
+  for (const [lang, detector] of Object.entries(LANGUAGE_DETECTORS)) {
+    // Check marker files
+    const hasFile = detector.files.some((f) => {
+      if (f.includes("*")) {
+        // Glob pattern — check if any matching file exists
+        try {
+          const dir = fs.readdirSync(PROJECT_ROOT);
+          const ext = f.replace("*", "");
+          return dir.some((d) => d.endsWith(ext));
+        } catch { return false; }
+      }
+      return fs.existsSync(path.join(PROJECT_ROOT, f));
+    });
+
+    // Check package.json dependencies
+    const hasDep = detector.packageDeps.some((dep) => dep in pkgDeps);
+
+    if (hasFile || hasDep) {
+      detected.push(lang);
+    }
+  }
+
+  // If package.json exists but no typescript detected, it's javascript
+  if (fs.existsSync(path.join(PROJECT_ROOT, "package.json")) && !detected.includes("typescript") && !detected.includes("javascript")) {
+    detected.push("javascript");
+  }
+
+  return detected;
+}
+
+// ── Tool Configs ──
+
 const TOOL_CONFIGS = {
   "claude-code": {
     name: "Claude Code",
@@ -69,6 +175,7 @@ const TOOL_CONFIGS = {
 const C = {
   green: "\x1b[32m", yellow: "\x1b[33m", blue: "\x1b[34m",
   red: "\x1b[31m", dim: "\x1b[2m", bold: "\x1b[1m", reset: "\x1b[0m",
+  cyan: "\x1b[36m", magenta: "\x1b[35m",
 };
 
 // ── Helpers ──
@@ -163,16 +270,47 @@ function filterSkillsForProject(skills) {
   const projectName = getProjectName();
   return skills.filter((skill) => {
     if (skill.scope !== "project") return true;
-    // Only install project skills matching this project
     return skill.project_name === projectName;
   });
 }
 
+function extractFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    if (!line.startsWith(" ") && line.includes(":")) {
+      const [key, ...rest] = line.split(":");
+      fm[key.trim()] = rest.join(":").trim().replace(/^["']|["']$/g, "");
+    }
+  }
+  return fm;
+}
+
+function getLocalSkills() {
+  const skills = [];
+  if (!fs.existsSync(SKILLS_SOURCE)) return skills;
+  for (const cat of ["global", "stack"]) {
+    const catDir = path.join(SKILLS_SOURCE, cat);
+    if (!fs.existsSync(catDir)) continue;
+    for (const item of fs.readdirSync(catDir)) {
+      const skillMd = path.join(catDir, item, "SKILL.md");
+      if (fs.existsSync(skillMd)) {
+        const content = fs.readFileSync(skillMd, "utf-8");
+        const fm = extractFrontmatter(content);
+        skills.push({ name: fm.name || item, scope: cat, stack: fm.stack || null, version: fm.version || "?", content });
+      }
+    }
+  }
+  return skills;
+}
+
+// ── Installation Functions ──
+
 function installSkillsForTool(toolKey, skills) {
   const tool = TOOL_CONFIGS[toolKey];
   if (!tool) return 0;
 
-  // Filter: only install project-scoped skills that match this project
   const filtered = filterSkillsForProject(skills);
 
   if (tool.format === "skill-folder") {
@@ -182,7 +320,6 @@ function installSkillsForTool(toolKey, skills) {
       mkdirp(dest);
       fs.writeFileSync(path.join(dest, "SKILL.md"), skill.content);
 
-      // Write reference files if the skill has any
       if (skill.references && typeof skill.references === "object") {
         for (const [filePath, fileContent] of Object.entries(skill.references)) {
           const refDest = path.join(dest, filePath);
@@ -204,14 +341,12 @@ function installSkillsForTool(toolKey, skills) {
     content += `# Last updated: ${new Date().toISOString().split("T")[0]}\n\n`;
 
     for (const skill of filtered) {
-      // Strip YAML frontmatter for rules files
       const body = skill.content.replace(/^---[\s\S]*?---\n*/m, "").trim();
       content += `\n${"=".repeat(60)}\n`;
       content += `# SKILL: ${skill.name} (${skill.scope})\n`;
       content += `${"=".repeat(60)}\n\n`;
       content += body + "\n";
 
-      // Inline reference files for rules-file format
       if (skill.references && typeof skill.references === "object") {
         for (const [refPath, refContent] of Object.entries(skill.references)) {
           content += `\n--- Reference: ${refPath} ---\n`;
@@ -227,35 +362,250 @@ function installSkillsForTool(toolKey, skills) {
   return 0;
 }
 
-function extractFrontmatter(content) {
-  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
-  if (!match) return {};
-  const fm = {};
-  for (const line of match[1].split("\n")) {
-    if (!line.startsWith(" ") && line.includes(":")) {
-      const [key, ...rest] = line.split(":");
-      fm[key.trim()] = rest.join(":").trim().replace(/^["']|["']$/g, "");
+function installAgentsForTool(toolKey, agents) {
+  const tool = TOOL_CONFIGS[toolKey];
+  if (!tool || !agents || agents.length === 0) return 0;
+
+  if (tool.format === "skill-folder") {
+    // Claude Code: individual agent .md files
+    const agentsDir = path.join(PROJECT_ROOT, ".claude", "agents");
+    mkdirp(agentsDir);
+    for (const agent of agents) {
+      const content = [
+        "---",
+        `name: ${agent.name}`,
+        `description: ${agent.display_name || agent.description}`,
+        agent.model_preference ? `model: ${agent.model_preference}` : null,
+        agent.allowed_tools ? `tools: ${JSON.stringify(agent.allowed_tools)}` : null,
+        agent.max_turns ? `max_turns: ${agent.max_turns}` : null,
+        "---",
+        "",
+        agent.instructions,
+      ].filter(Boolean).join("\n");
+      fs.writeFileSync(path.join(agentsDir, `${agent.name}.md`), content);
     }
+    return agents.length;
   }
-  return fm;
+
+  if (tool.format === "rules-file") {
+    // Other tools: merge agents into a rules file
+    const rulesDir = path.dirname(path.join(PROJECT_ROOT, tool.rulesFile));
+    const agentsFile = path.join(rulesDir, "ai-agents.mdc");
+    mkdirp(rulesDir);
+
+    let content = `# AI Agent Definitions\n`;
+    content += `# Auto-generated by @valentia-ai-skills/framework\n\n`;
+
+    for (const agent of agents) {
+      content += `\n${"=".repeat(60)}\n`;
+      content += `# AGENT: ${agent.name} (${agent.scope}) — ${agent.model_preference || "sonnet"}\n`;
+      content += `${"=".repeat(60)}\n\n`;
+      content += agent.instructions + "\n";
+    }
+
+    fs.writeFileSync(agentsFile, content);
+    return agents.length;
+  }
+
+  return 0;
 }
 
-function getLocalSkills() {
-  const skills = [];
-  if (!fs.existsSync(SKILLS_SOURCE)) return skills;
-  for (const cat of ["global", "stack"]) {
-    const catDir = path.join(SKILLS_SOURCE, cat);
-    if (!fs.existsSync(catDir)) continue;
-    for (const item of fs.readdirSync(catDir)) {
-      const skillMd = path.join(catDir, item, "SKILL.md");
-      if (fs.existsSync(skillMd)) {
-        const content = fs.readFileSync(skillMd, "utf-8");
-        const fm = extractFrontmatter(content);
-        skills.push({ name: fm.name || item, scope: cat, stack: fm.stack || null, version: fm.version || "?", content });
+function installCommandsForTool(toolKey, commands) {
+  const tool = TOOL_CONFIGS[toolKey];
+  if (!tool || !commands || commands.length === 0) return 0;
+
+  if (tool.format === "skill-folder") {
+    // Claude Code: individual command .md files
+    const commandsDir = path.join(PROJECT_ROOT, ".claude", "commands");
+    mkdirp(commandsDir);
+    for (const cmd of commands) {
+      const content = [
+        "---",
+        `name: ${cmd.name}`,
+        `description: ${cmd.display_name || cmd.description}`,
+        cmd.agent_ref ? `agent: ${cmd.agent_ref}` : null,
+        "---",
+        "",
+        cmd.instructions,
+      ].filter(Boolean).join("\n");
+      fs.writeFileSync(path.join(commandsDir, `${cmd.name}.md`), content);
+    }
+    return commands.length;
+  }
+
+  if (tool.format === "rules-file") {
+    // Other tools: merge commands into rules file
+    const rulesDir = path.dirname(path.join(PROJECT_ROOT, tool.rulesFile));
+    const commandsFile = path.join(rulesDir, "ai-commands.mdc");
+    mkdirp(rulesDir);
+
+    let content = `# AI Command Definitions\n`;
+    content += `# Auto-generated by @valentia-ai-skills/framework\n\n`;
+
+    for (const cmd of commands) {
+      content += `\n${"=".repeat(60)}\n`;
+      content += `# COMMAND: /${cmd.name} (${cmd.scope})\n`;
+      content += `${"=".repeat(60)}\n\n`;
+      content += cmd.instructions + "\n";
+    }
+
+    fs.writeFileSync(commandsFile, content);
+    return commands.length;
+  }
+
+  return 0;
+}
+
+function installHooksForTool(toolKey, hooks) {
+  const tool = TOOL_CONFIGS[toolKey];
+  if (!tool || !hooks || hooks.length === 0) return 0;
+
+  if (tool.format === "skill-folder") {
+    // Claude Code: write hook scripts + settings.local.json
+    const hooksScriptDir = path.join(PROJECT_ROOT, ".ai-skills", "hooks");
+    mkdirp(hooksScriptDir);
+
+    // Write individual hook scripts
+    for (const hook of hooks) {
+      if (hook.script_content) {
+        const scriptPath = path.join(hooksScriptDir, `${hook.name}.js`);
+        fs.writeFileSync(scriptPath, hook.script_content);
       }
     }
+
+    // Build Claude Code hooks config for settings.local.json
+    const hooksByEvent = {};
+    for (const hook of hooks) {
+      if (!hooksByEvent[hook.event]) hooksByEvent[hook.event] = [];
+      hooksByEvent[hook.event].push({
+        matcher: hook.tool_match || "*",
+        hooks: [
+          {
+            type: hook.hook_type || "command",
+            command: hook.command,
+            ...(hook.timeout_ms ? { timeout: hook.timeout_ms } : {}),
+          },
+        ],
+      });
+    }
+
+    // Read existing settings.local.json or create new
+    const settingsPath = path.join(PROJECT_ROOT, ".claude", "settings.local.json");
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+      try { settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8")); } catch { settings = {}; }
+    }
+
+    // Merge hooks into settings (preserve existing non-hook settings)
+    settings.hooks = hooksByEvent;
+
+    mkdirp(path.dirname(settingsPath));
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+
+    return hooks.length;
   }
-  return skills;
+
+  // Other tools don't support hooks in the same way — skip
+  return 0;
+}
+
+function installRulesForTool(toolKey, rules, detectedLanguages) {
+  const tool = TOOL_CONFIGS[toolKey];
+  if (!tool || !rules || rules.length === 0) return 0;
+
+  // Filter rules by detected languages (auto_detect rules only install if language found)
+  const filtered = rules.filter((rule) => {
+    if (rule.language === "all") return true; // Universal rules always install
+    if (!rule.auto_detect) return true; // Non-auto-detect rules always install
+    return detectedLanguages.includes(rule.language); // Auto-detect: only if language found
+  });
+
+  if (filtered.length === 0) return 0;
+
+  if (tool.format === "skill-folder") {
+    // Claude Code: individual rule .md files
+    const rulesDir = path.join(PROJECT_ROOT, ".claude", "rules");
+    mkdirp(rulesDir);
+    for (const rule of filtered) {
+      fs.writeFileSync(path.join(rulesDir, `${rule.name}.md`), rule.content);
+    }
+    return filtered.length;
+  }
+
+  if (tool.format === "rules-file") {
+    // Other tools: merge rules into a rules file
+    const rulesDir = path.dirname(path.join(PROJECT_ROOT, tool.rulesFile));
+    const rulesFile = path.join(rulesDir, "ai-rules.mdc");
+    mkdirp(rulesDir);
+
+    let content = `# AI Coding Rules\n`;
+    content += `# Auto-generated by @valentia-ai-skills/framework\n\n`;
+
+    for (const rule of filtered) {
+      content += `\n${"=".repeat(60)}\n`;
+      content += `# RULE: ${rule.name} (${rule.language})\n`;
+      content += `${"=".repeat(60)}\n\n`;
+      content += rule.content + "\n";
+    }
+
+    fs.writeFileSync(rulesFile, content);
+    return filtered.length;
+  }
+
+  return 0;
+}
+
+function installMcpConfigsForTool(toolKey, mcpConfigs) {
+  const tool = TOOL_CONFIGS[toolKey];
+  if (!tool || !mcpConfigs || mcpConfigs.length === 0) return 0;
+
+  if (tool.format === "skill-folder") {
+    // Claude Code: merge into .claude/mcp-servers.json
+    // NOTE: We write templates with {{PLACEHOLDER}} — user must fill in actual values
+    const mcpPath = path.join(PROJECT_ROOT, ".claude", "mcp-servers.json");
+    let existing = {};
+    if (fs.existsSync(mcpPath)) {
+      try { existing = JSON.parse(fs.readFileSync(mcpPath, "utf-8")); } catch { existing = {}; }
+    }
+
+    if (!existing.mcpServers) existing.mcpServers = {};
+
+    for (const mcp of mcpConfigs) {
+      // Only add if not already configured (don't overwrite user's actual values)
+      if (!existing.mcpServers[mcp.name]) {
+        existing.mcpServers[mcp.name] = mcp.config_template;
+      }
+    }
+
+    mkdirp(path.dirname(mcpPath));
+    fs.writeFileSync(mcpPath, JSON.stringify(existing, null, 2) + "\n");
+    return mcpConfigs.length;
+  }
+
+  // Other tools: write a reference file listing available MCP configs
+  if (tool.format === "rules-file") {
+    const rulesDir = path.dirname(path.join(PROJECT_ROOT, tool.rulesFile));
+    const mcpFile = path.join(rulesDir, "ai-mcp-configs.md");
+    mkdirp(rulesDir);
+
+    let content = `# Available MCP Server Configurations\n`;
+    content += `# These MCP servers are recommended for your team's toolkit\n\n`;
+
+    for (const mcp of mcpConfigs) {
+      content += `## ${mcp.display_name || mcp.name}\n`;
+      content += `${mcp.description}\n`;
+      content += `- Package: \`${mcp.package_name}\`\n`;
+      if (mcp.required_env_vars?.length) {
+        content += `- Required env vars: ${mcp.required_env_vars.join(", ")}\n`;
+      }
+      content += `\n`;
+    }
+
+    fs.writeFileSync(mcpFile, content);
+    return mcpConfigs.length;
+  }
+
+  return 0;
 }
 
 // ── Email + OTP Verification ──
@@ -290,11 +640,9 @@ async function requestOtpForEmail(emailInput) {
       throw new Error(response.error);
     }
 
-    // OTP sent successfully
     console.log(c("green", `\n✓ Found: ${response.user_name}`));
 
     if (response.fallback_code) {
-      // Email delivery not configured — show code in terminal
       console.log(c("yellow", `\n  Your verification code: ${c("bold", response.fallback_code)}\n`));
     } else {
       console.log(c("dim", `  A verification code has been sent to ${email}\n`));
@@ -340,22 +688,29 @@ async function cmdSetup() {
     console.log(c("yellow", "No AI coding tools detected. Will create a generic .ai-rules file.\n"));
     tools.push("generic");
   } else {
-    console.log(`Detected: ${tools.map((t) => c("green", TOOL_CONFIGS[t]?.name || t)).join(", ")}\n`);
+    console.log(`${c("bold", "AI Tools:")} ${tools.map((t) => c("green", TOOL_CONFIGS[t]?.name || t)).join(", ")}`);
+  }
+
+  // 2. Detect languages
+  const detectedLanguages = detectLanguages();
+  if (detectedLanguages.length > 0) {
+    console.log(`${c("bold", "Languages:")} ${detectedLanguages.map((l) => c("cyan", l)).join(", ")}`);
   }
+  console.log("");
 
-  // 2. Ask for email
+  // 3. Ask for email
   let email = await ask(`${c("bold", "Enter your work email:")} `);
 
-  let skills;
+  let response;
   let teamName = null;
 
   try {
-    // 3. Request OTP (with 1 retry for wrong email)
+    // 4. Request OTP
     const otpResult = await requestOtpForEmail(email);
     email = otpResult.email;
 
-    // 4. Verify OTP and get skills
-    const response = await verifyOtp(email);
+    // 5. Verify OTP and get full toolkit
+    response = await verifyOtp(email);
 
     if (response.team) {
       teamName = response.team.name;
@@ -369,60 +724,108 @@ async function cmdSetup() {
     } else if (response.message) {
       console.log(c("yellow", `⚠ ${response.message}`));
     }
-
-    skills = response.skills || [];
-
-    if (skills.length === 0) {
-      console.log(c("yellow", "\n⚠ No skills are enabled for your team. Contact your Team Lead."));
-      process.exit(1);
-    }
-
-    // Show skill counts with project context
-    const projectName = getProjectName();
-    const teamSkillCount = skills.filter((s) => s.scope !== "project").length;
-    const projectSkillCount = skills.filter((s) => s.scope === "project" && s.project_name === projectName).length;
-    const skippedProjectCount = skills.filter((s) => s.scope === "project" && s.project_name !== projectName).length;
-
-    console.log(`  ${c("bold", teamSkillCount)} team skill(s)`);
-    if (projectSkillCount > 0) {
-      console.log(`  ${c("bold", projectSkillCount)} project skill(s) for ${c("green", projectName)}`);
-    }
-    if (skippedProjectCount > 0) {
-      console.log(c("dim", `  ${skippedProjectCount} project skill(s) skipped (different project)`));
-    }
-    console.log("");
-
   } catch (err) {
     console.log(c("red", `\n✗ Could not complete verification: ${err.message}`));
     console.log(c("dim", "  Please check your internet connection and try again.\n"));
     process.exit(1);
   }
 
-  if (skills.length === 0) {
-    console.log(c("red", "No skills available. Contact your Framework Admin."));
+  // Extract all entity types from response
+  const skills = response.skills || [];
+  const agents = response.agents || [];
+  const commands = response.commands || [];
+  const hooks = response.hooks || [];
+  const rules = response.rules || [];
+  const mcpConfigs = response.mcp_configs || [];
+
+  const totalEntities = skills.length + agents.length + commands.length + hooks.length + rules.length + mcpConfigs.length;
+
+  if (totalEntities === 0) {
+    console.log(c("yellow", "\n⚠ No toolkit items are enabled for your team. Contact your Team Lead."));
     process.exit(1);
   }
 
-  // 5. Install for each tool (project skills are filtered by project name inside)
-  const filteredSkills = filterSkillsForProject(skills);
+  // Show toolkit summary
+  console.log(c("blue", "\n  Toolkit Summary:"));
+  if (skills.length > 0)     console.log(`    ${c("green", skills.length.toString().padStart(2))} skill(s)`);
+  if (agents.length > 0)     console.log(`    ${c("green", agents.length.toString().padStart(2))} agent(s)`);
+  if (commands.length > 0)   console.log(`    ${c("green", commands.length.toString().padStart(2))} command(s)`);
+  if (hooks.length > 0)      console.log(`    ${c("green", hooks.length.toString().padStart(2))} hook(s)`);
+  if (rules.length > 0)      console.log(`    ${c("green", rules.length.toString().padStart(2))} rule(s)`);
+  if (mcpConfigs.length > 0) console.log(`    ${c("green", mcpConfigs.length.toString().padStart(2))} MCP config(s)`);
+  console.log("");
+
+  // 6. Install for each tool
   for (const toolKey of tools) {
     const tool = TOOL_CONFIGS[toolKey];
     if (!tool) continue;
     console.log(c("yellow", `Installing for ${tool.name}...`));
-    const count = installSkillsForTool(toolKey, skills);
 
-    if (tool.format === "skill-folder") {
-      for (const s of filteredSkills) {
-        const label = s.scope === "project" ? `${s.name} ${c("dim", "(project)")}` : s.name;
-        console.log(`  ${c("green", "✓")} ${label}`);
+    // Skills
+    const skillCount = installSkillsForTool(toolKey, skills);
+    if (skillCount > 0) {
+      if (tool.format === "skill-folder") {
+        for (const s of filterSkillsForProject(skills)) {
+          console.log(`  ${c("green", "✓")} ${c("dim", "skill:")} ${s.name}`);
+        }
+      } else {
+        console.log(`  ${c("green", "✓")} ${skillCount} skills merged into ${tool.rulesFile}`);
+      }
+    }
+
+    // Agents
+    const agentCount = installAgentsForTool(toolKey, agents);
+    if (agentCount > 0) {
+      if (tool.format === "skill-folder") {
+        for (const a of agents) console.log(`  ${c("green", "✓")} ${c("dim", "agent:")} ${a.name}`);
+      } else {
+        console.log(`  ${c("green", "✓")} ${agentCount} agents merged`);
+      }
+    }
+
+    // Commands
+    const cmdCount = installCommandsForTool(toolKey, commands);
+    if (cmdCount > 0) {
+      if (tool.format === "skill-folder") {
+        for (const cmd of commands) console.log(`  ${c("green", "✓")} ${c("dim", "command:")} /${cmd.name}`);
+      } else {
+        console.log(`  ${c("green", "✓")} ${cmdCount} commands merged`);
+      }
+    }
+
+    // Hooks (Claude Code only)
+    const hookCount = installHooksForTool(toolKey, hooks);
+    if (hookCount > 0) {
+      for (const h of hooks) console.log(`  ${c("green", "✓")} ${c("dim", "hook:")} ${h.name} (${h.event})`);
+    }
+
+    // Rules (filtered by detected languages)
+    const ruleCount = installRulesForTool(toolKey, rules, detectedLanguages);
+    if (ruleCount > 0) {
+      if (tool.format === "skill-folder") {
+        const installed = rules.filter((r) => r.language === "all" || !r.auto_detect || detectedLanguages.includes(r.language));
+        for (const r of installed) console.log(`  ${c("green", "✓")} ${c("dim", "rule:")} ${r.name}`);
+      } else {
+        console.log(`  ${c("green", "✓")} ${ruleCount} rules merged`);
+      }
+    }
+
+    // MCP Configs
+    const mcpCount = installMcpConfigsForTool(toolKey, mcpConfigs);
+    if (mcpCount > 0) {
+      for (const m of mcpConfigs) {
+        const envNote = m.required_env_vars?.length ? c("yellow", ` (needs: ${m.required_env_vars.join(", ")})`) : "";
+        console.log(`  ${c("green", "✓")} ${c("dim", "mcp:")} ${m.name}${envNote}`);
       }
-    } else {
-      console.log(`  ${c("green", "✓")} ${tool.rulesFile} (${count} skills merged)`);
     }
+
     console.log("");
   }
 
-  // 6. Save config
+  // 7. Save config
+  const filteredSkills = filterSkillsForProject(skills);
+  const installedRules = rules.filter((r) => r.language === "all" || !r.auto_detect || detectedLanguages.includes(r.language));
+
   const config = {
     version: require(path.join(__dirname, "..", "package.json")).version,
     email,
@@ -431,13 +834,19 @@ async function cmdSetup() {
     source: "supabase",
     analyzeUrl: ANALYZE_FUNCTION_URL,
     scanUrl: SCAN_FUNCTION_URL,
+    detectedLanguages,
     tools,
     skills: filteredSkills.map((s) => ({ name: s.name, scope: s.scope, version: s.version, ...(s.project_name ? { project_name: s.project_name } : {}) })),
+    agents: agents.map((a) => ({ name: a.name, scope: a.scope, version: a.version })),
+    commands: commands.map((cmd) => ({ name: cmd.name, scope: cmd.scope, version: cmd.version })),
+    hooks: hooks.map((h) => ({ name: h.name, scope: h.scope, version: h.version })),
+    rules: installedRules.map((r) => ({ name: r.name, scope: r.scope, version: r.version, language: r.language })),
+    mcpConfigs: mcpConfigs.map((m) => ({ name: m.name, scope: m.scope, version: m.version })),
     installedAt: new Date().toISOString(),
   };
   saveConfig(config);
 
-  // 7. Install post-commit analysis hook
+  // 8. Install post-commit analysis hook
   try {
     const { installHook } = require(path.join(__dirname, "..", "hooks", "install-hook.js"));
     const hookResult = installHook(PROJECT_ROOT);
@@ -445,14 +854,15 @@ async function cmdSetup() {
       console.log(`${c("green", "✓")} Post-commit analysis hook installed`);
     }
   } catch {
-    // Hook installation is optional — don't fail setup
+    // Hook installation is optional
   }
 
-  // 8. Summary
+  // 9. Summary
   console.log(c("blue", "\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
-  console.log(c("green", "✅ Setup complete!"));
-  console.log(`   ${skills.length} skills installed for ${tools.length} tool(s)`);
+  console.log(c("green", "Setup complete!"));
+  console.log(`   ${totalEntities} items installed for ${tools.length} tool(s)`);
   if (teamName) console.log(`   Team: ${teamName}`);
+  if (detectedLanguages.length > 0) console.log(`   Languages: ${detectedLanguages.join(", ")}`);
   console.log(`\n   Config saved to ${c("dim", ".ai-skills.json")}`);
   console.log(`   To update: ${c("bold", "npx ai-skills update")}\n`);
 }
@@ -466,24 +876,20 @@ async function cmdUpdate() {
     process.exit(1);
   }
 
-  const email = config.email;
+  let email = config.email;
   console.log(c("dim", `Updating for ${email}...`));
 
-  let skills;
+  let response;
   let teamName = config.team;
 
   try {
-    // Request OTP for the saved email
     const otpResult = await requestOtpForEmail(email);
     email = otpResult.email;
-
-    // Verify OTP
-    const response = await verifyOtp(email);
-    skills = response.skills || [];
+    response = await verifyOtp(email);
     teamName = response.team?.name || config.team;
 
     if (response.team) {
-      console.log(c("green", `✓ Team: ${teamName} (${skills.length} skills)`));
+      console.log(c("green", `✓ Team: ${teamName}`));
     } else {
       console.log(c("yellow", `⚠ ${response.message || "No team found."}`));
     }
@@ -493,26 +899,55 @@ async function cmdUpdate() {
     process.exit(1);
   }
 
+  const skills = response.skills || [];
+  const agents = response.agents || [];
+  const commands = response.commands || [];
+  const hooks = response.hooks || [];
+  const rules = response.rules || [];
+  const mcpConfigs = response.mcp_configs || [];
+  const detectedLanguages = detectLanguages();
+
   const tools = config.tools || detectTools();
   for (const toolKey of tools) {
     const tool = TOOL_CONFIGS[toolKey];
     if (!tool) continue;
-    console.log(c("yellow", `Updating ${tool.name}...`));
+    console.log(c("yellow", `\nUpdating ${tool.name}...`));
+
     installSkillsForTool(toolKey, skills);
+    installAgentsForTool(toolKey, agents);
+    installCommandsForTool(toolKey, commands);
+    installHooksForTool(toolKey, hooks);
+    installRulesForTool(toolKey, rules, detectedLanguages);
+    installMcpConfigsForTool(toolKey, mcpConfigs);
 
     if (tool.format === "skill-folder") {
-      for (const s of skills) console.log(`  ${c("green", "✓")} ${s.name}`);
+      if (skills.length > 0) console.log(`  ${c("green", "✓")} ${skills.length} skills`);
+      if (agents.length > 0) console.log(`  ${c("green", "✓")} ${agents.length} agents`);
+      if (commands.length > 0) console.log(`  ${c("green", "✓")} ${commands.length} commands`);
+      if (hooks.length > 0) console.log(`  ${c("green", "✓")} ${hooks.length} hooks`);
+      const installedRules = rules.filter((r) => r.language === "all" || !r.auto_detect || detectedLanguages.includes(r.language));
+      if (installedRules.length > 0) console.log(`  ${c("green", "✓")} ${installedRules.length} rules`);
+      if (mcpConfigs.length > 0) console.log(`  ${c("green", "✓")} ${mcpConfigs.length} MCP configs`);
     } else {
       console.log(`  ${c("green", "✓")} ${tool.rulesFile} updated`);
     }
   }
 
+  const installedRules = rules.filter((r) => r.language === "all" || !r.auto_detect || detectedLanguages.includes(r.language));
+  const totalEntities = skills.length + agents.length + commands.length + hooks.length + installedRules.length + mcpConfigs.length;
+
   config.updatedAt = new Date().toISOString();
   config.team = teamName;
+  config.detectedLanguages = detectedLanguages;
   config.skills = skills.map((s) => ({ name: s.name, scope: s.scope, version: s.version }));
+  config.agents = agents.map((a) => ({ name: a.name, scope: a.scope, version: a.version }));
+  config.commands = commands.map((cmd) => ({ name: cmd.name, scope: cmd.scope, version: cmd.version }));
+  config.hooks = hooks.map((h) => ({ name: h.name, scope: h.scope, version: h.version }));
+  config.rules = installedRules.map((r) => ({ name: r.name, scope: r.scope, version: r.version, language: r.language }));
+  config.mcpConfigs = mcpConfigs.map((m) => ({ name: m.name, scope: m.scope, version: m.version }));
   saveConfig(config);
 
-  console.log(c("green", `\n✅ Updated ${skills.length} skills!\n`));
+  console.log(c("green", `\nUpdated! ${totalEntities} items across ${tools.length} tool(s).\n`));
 }
 
 function cmdStatus() {
@@ -526,13 +961,34 @@ function cmdStatus() {
   if (config) {
     console.log(`Email: ${c("bold", config.email)}`);
     console.log(`Team: ${config.team ? c("green", config.team) : c("yellow", "none")}`);
+    console.log(`Project: ${c("bold", config.project || getProjectName())}`);
     console.log(`Source: ${config.source === "supabase" ? c("green", "Supabase (live)") : c("yellow", "local fallback")}`);
     console.log(`Installed: ${config.installedAt?.split("T")[0]}`);
     if (config.updatedAt) console.log(`Updated: ${config.updatedAt.split("T")[0]}`);
     console.log(`Tools: ${config.tools?.map((t) => TOOL_CONFIGS[t]?.name || t).join(", ")}`);
-    console.log(`\nSkills (${config.skills?.length || 0}):`);
-    for (const s of config.skills || []) {
-      console.log(`  ${c("green", "✓")} ${s.name} ${c("dim", `v${s.version}`)} ${c("dim", `(${s.scope})`)}`);
+    if (config.detectedLanguages?.length) {
+      console.log(`Languages: ${config.detectedLanguages.join(", ")}`);
+    }
+
+    // Entity summary table
+    const entities = [
+      { label: "Skills", icon: "📝", items: config.skills },
+      { label: "Agents", icon: "🤖", items: config.agents },
+      { label: "Commands", icon: "⚡", items: config.commands },
+      { label: "Hooks", icon: "🪝", items: config.hooks },
+      { label: "Rules", icon: "📏", items: config.rules },
+      { label: "MCP Configs", icon: "🔌", items: config.mcpConfigs },
+    ];
+
+    console.log("");
+    for (const entity of entities) {
+      const items = entity.items || [];
+      if (items.length === 0) continue;
+      console.log(`${c("bold", entity.label)} (${items.length}):`);
+      for (const item of items) {
+        const extra = item.language ? ` ${c("dim", `[${item.language}]`)}` : "";
+        console.log(`  ${c("green", "✓")} ${item.name} ${c("dim", `v${item.version}`)} ${c("dim", `(${item.scope})`)}${extra}`);
+      }
     }
   } else {
     console.log(`Installed: ${c("red", "No")} — run 'npx ai-skills setup'`);
@@ -542,6 +998,15 @@ function cmdStatus() {
   for (const [key, tool] of Object.entries(TOOL_CONFIGS)) {
     console.log(`  ${tool.detect() ? c("green", "●") : c("dim", "○")} ${tool.name}`);
   }
+
+  const languages = detectLanguages();
+  if (languages.length > 0) {
+    console.log(`\nDetected languages:`);
+    for (const lang of languages) {
+      console.log(`  ${c("cyan", "●")} ${lang}`);
+    }
+  }
+
   console.log("");
 }
 
@@ -558,7 +1023,7 @@ function cmdList() {
     console.log(`  ${s.name.padEnd(22)} ${c("dim", `v${s.version}`)} ${c("dim", `(${s.scope})`)}`);
   }
   console.log(c("dim", `\n  ${skills.length} skills available`));
-  console.log(c("dim", "  Note: 'npx ai-skills setup' installs team-specific skills from Supabase\n"));
+  console.log(c("dim", "  Note: 'npx ai-skills setup' installs team-specific toolkit from Supabase\n"));
 }
 
 function cmdDoctor() {
@@ -573,6 +1038,18 @@ function cmdDoctor() {
   } else {
     console.log(c("green", `✓ Config found (${config.email}, team: ${config.team || "none"})`));
 
+    // Count entities
+    const entityCounts = [];
+    if (config.skills?.length) entityCounts.push(`${config.skills.length} skills`);
+    if (config.agents?.length) entityCounts.push(`${config.agents.length} agents`);
+    if (config.commands?.length) entityCounts.push(`${config.commands.length} commands`);
+    if (config.hooks?.length) entityCounts.push(`${config.hooks.length} hooks`);
+    if (config.rules?.length) entityCounts.push(`${config.rules.length} rules`);
+    if (config.mcpConfigs?.length) entityCounts.push(`${config.mcpConfigs.length} MCP configs`);
+    if (entityCounts.length > 0) {
+      console.log(c("green", `✓ Installed: ${entityCounts.join(", ")}`));
+    }
+
     // Check tool files
     for (const toolKey of config.tools || []) {
       const tool = TOOL_CONFIGS[toolKey];
@@ -588,6 +1065,50 @@ function cmdDoctor() {
           console.log(c("red", `✗ ${tool.name}: ${tool.skillsDir}/ missing`));
           issues++;
         }
+
+        // Check agents dir
+        const agentsDir = path.join(PROJECT_ROOT, ".claude", "agents");
+        if (fs.existsSync(agentsDir)) {
+          const agentCount = fs.readdirSync(agentsDir).filter((f) => f.endsWith(".md")).length;
+          console.log(c("green", `✓ ${tool.name}: ${agentCount} agents in .claude/agents/`));
+        }
+
+        // Check commands dir
+        const commandsDir = path.join(PROJECT_ROOT, ".claude", "commands");
+        if (fs.existsSync(commandsDir)) {
+          const cmdCount = fs.readdirSync(commandsDir).filter((f) => f.endsWith(".md")).length;
+          console.log(c("green", `✓ ${tool.name}: ${cmdCount} commands in .claude/commands/`));
+        }
+
+        // Check rules dir
+        const rulesDir = path.join(PROJECT_ROOT, ".claude", "rules");
+        if (fs.existsSync(rulesDir)) {
+          const ruleCount = fs.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).length;
+          console.log(c("green", `✓ ${tool.name}: ${ruleCount} rules in .claude/rules/`));
+        }
+
+        // Check hooks
+        const settingsPath = path.join(PROJECT_ROOT, ".claude", "settings.local.json");
+        if (fs.existsSync(settingsPath)) {
+          try {
+            const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+            if (settings.hooks) {
+              const hookCount = Object.values(settings.hooks).flat().length;
+              console.log(c("green", `✓ ${tool.name}: ${hookCount} hooks in settings.local.json`));
+            }
+          } catch { /* ignore */ }
+        }
+
+        // Check MCP configs
+        const mcpPath = path.join(PROJECT_ROOT, ".claude", "mcp-servers.json");
+        if (fs.existsSync(mcpPath)) {
+          try {
+            const mcp = JSON.parse(fs.readFileSync(mcpPath, "utf-8"));
+            const mcpCount = Object.keys(mcp.mcpServers || mcp).length;
+            console.log(c("green", `✓ ${tool.name}: ${mcpCount} MCP servers configured`));
+          } catch { /* ignore */ }
+        }
+
       } else if (tool.rulesFile) {
         const rulesPath = path.join(PROJECT_ROOT, tool.rulesFile);
         if (fs.existsSync(rulesPath)) {
@@ -620,7 +1141,7 @@ function cmdDoctor() {
   function finish() {
     console.log(
       issues === 0
-        ? c("green", "\n✅ Everything looks good!\n")
+        ? c("green", "\nEverything looks good!\n")
         : c("yellow", `\n⚠ ${issues} issue(s) found.\n`)
     );
   }
@@ -666,7 +1187,6 @@ async function cmdAnalyze() {
       commitMessage = require("child_process").execSync('git log -1 --format="%s"', execOpt).trim();
       filesChanged = require("child_process").execSync("git diff --name-only HEAD~1 HEAD", execOpt).trim().split("\n").filter(Boolean);
     } else {
-      // Analyze staged changes or last commit
       diff = require("child_process").execSync("git diff --cached", execOpt).trim();
       if (!diff) {
         diff = require("child_process").execSync("git diff HEAD~1 HEAD", execOpt).trim();
@@ -690,7 +1210,6 @@ async function cmdAnalyze() {
     process.exit(0);
   }
 
-  // Truncate diff if needed
   if (diff.length > 10000) {
     diff = diff.slice(0, 4000) + "\n\n[...truncated...]\n\n" + diff.slice(-4000);
   }
@@ -699,7 +1218,6 @@ async function cmdAnalyze() {
   console.log(c("dim", `Commit: ${commitHash?.slice(0, 8)} — ${commitMessage}`));
   console.log(c("dim", `Branch: ${branch}\n`));
 
-  // Get project name
   let projectName = null;
   try {
     const pkgPath = path.join(PROJECT_ROOT, "package.json");
@@ -726,7 +1244,6 @@ async function cmdAnalyze() {
       throw new Error(result.error);
     }
 
-    // Display results
     console.log(c("blue", "━━━ Analysis Results ━━━\n"));
     const score = result.overall_score || 0;
     const scoreColor = score >= 80 ? "green" : score >= 50 ? "yellow" : "red";
@@ -778,9 +1295,9 @@ switch (command) {
 ${c("blue", "AI Skills Framework")} — @valentia-ai-skills/framework
 
 Usage:
-  npx ai-skills setup    Enter email → fetch team's skills → install
-  npx ai-skills update   Re-fetch and update skills for your team
-  npx ai-skills status   Show installed skills, team, and tools
+  npx ai-skills setup    Enter email → fetch team's toolkit → install
+  npx ai-skills update   Re-fetch and update toolkit for your team
+  npx ai-skills status   Show installed toolkit, team, and tools
   npx ai-skills list     List locally bundled skills
   npx ai-skills analyze  Analyze last commit against active skills
   npx ai-skills doctor   Health check (config + API + tools)
@@ -788,6 +1305,8 @@ Usage:
 Flags:
   analyze --last         Analyze the most recent commit
 
+Toolkit includes: skills, agents, commands, hooks, rules, MCP configs.
+
 Environment:
   AI_SKILLS_API_URL      Override the Supabase Edge Function URL
 `); break;