@valentia-ai-skills/framework 1.0.3 → 1.0.4

package/bin/cli.js

@@ -1,25 +1,31 @@
 #!/usr/bin/env node
 
 /**
- * ai-skills CLI
- * 
+ * ai-skills CLI — @valentia-ai-skills/framework
+ *
  * Usage:
- *   npx ai-skills setup          # First-time setup — detects your AI tools and installs skills
- *   npx ai-skills update         # Pull latest skills into your project
- *   npx ai-skills status         # Show which skills are installed and which tools are configured
- *   npx ai-skills list           # List all available skills
- *   npx ai-skills add <skill>    # Add a specific skill
- *   npx ai-skills remove <skill> # Remove a specific skill
- *   npx ai-skills doctor         # Check setup health
+ *   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 list               # List all locally available skills
+ *   npx ai-skills doctor             # Health check
  */
 
 const fs = require("fs");
 const path = require("path");
+const readline = require("readline");
+const https = require("https");
+const http = require("http");
 
 // ── Constants ──
 
-const SKILLS_SOURCE = path.join(__dirname, "..", "skills");
+const SKILLS_SOURCE = path.join(__dirname, "..", "skills"); // fallback local skills
 const PROJECT_ROOT = process.cwd();
+const CONFIG_PATH = path.join(PROJECT_ROOT, ".ai-skills.json");
+
+// UPDATE THIS with your actual Supabase project URL
+const SUPABASE_FUNCTION_URL =
+  process.env.AI_SKILLS_API_URL || "https://znshdhjquohrzvbnloki.supabase.co/functions/v1/lookup-team";
 
 const TOOL_CONFIGS = {
   "claude-code": {
@@ -27,7 +33,7 @@ const TOOL_CONFIGS = {
     skillsDir: ".claude/skills",
     rulesFile: null,
     detect: () => fs.existsSync(path.join(PROJECT_ROOT, ".claude")) || shellHas("claude"),
-    format: "skill-folder", // copies full SKILL.md folder structure
+    format: "skill-folder",
   },
   cursor: {
     name: "Cursor",
@@ -36,7 +42,7 @@ const TOOL_CONFIGS = {
     detect: () =>
       fs.existsSync(path.join(PROJECT_ROOT, ".cursor")) ||
       fs.existsSync(path.join(PROJECT_ROOT, ".cursorules")),
-    format: "rules-file", // merges into a single rules file
+    format: "rules-file",
   },
   copilot: {
     name: "GitHub Copilot",
@@ -54,362 +60,376 @@ const TOOL_CONFIGS = {
     detect: () => fs.existsSync(path.join(PROJECT_ROOT, ".windsurfrules")),
     format: "rules-file",
   },
-  generic: {
-    name: "Generic (.ai-rules)",
-    skillsDir: null,
-    rulesFile: ".ai-rules",
-    detect: () => true, // always available as fallback
-    format: "rules-file",
-  },
 };
 
-const COLORS = {
-  green: "\x1b[32m",
-  yellow: "\x1b[33m",
-  blue: "\x1b[34m",
-  red: "\x1b[31m",
-  dim: "\x1b[2m",
-  bold: "\x1b[1m",
-  reset: "\x1b[0m",
+const C = {
+  green: "\x1b[32m", yellow: "\x1b[33m", blue: "\x1b[34m",
+  red: "\x1b[31m", dim: "\x1b[2m", bold: "\x1b[1m", reset: "\x1b[0m",
 };
 
 // ── Helpers ──
 
-function c(color, text) {
-  return `${COLORS[color]}${text}${COLORS.reset}`;
-}
+function c(color, text) { return `${C[color]}${text}${C.reset}`; }
 
 function shellHas(cmd) {
-  try {
-    require("child_process").execSync(`which ${cmd} 2>/dev/null`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
+  try { require("child_process").execSync(`which ${cmd} 2>/dev/null`, { stdio: "ignore" }); return true; }
+  catch { return false; }
 }
 
-function getAllSkills() {
-  const skills = [];
-  if (!fs.existsSync(SKILLS_SOURCE)) return skills;
-
-  for (const category of ["global", "stack", "onboarding"]) {
-    const catDir = path.join(SKILLS_SOURCE, category);
-    if (!fs.existsSync(catDir)) continue;
+function mkdirp(dirPath) {
+  if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+}
 
-    if (category === "onboarding") {
-      if (fs.existsSync(path.join(catDir, "SKILL.md"))) {
-        skills.push({ name: "onboarding", category, path: catDir });
-      }
-      continue;
-    }
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
+  });
+}
 
-    for (const item of fs.readdirSync(catDir)) {
-      const itemPath = path.join(catDir, item);
-      if (fs.statSync(itemPath).isDirectory() && fs.existsSync(path.join(itemPath, "SKILL.md"))) {
-        skills.push({ name: item, category, path: itemPath });
+function fetchJSON(url, body) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const mod = parsed.protocol === "https:" ? https : http;
+    const postData = JSON.stringify(body);
+
+    const req = mod.request(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port,
+        path: parsed.pathname + parsed.search,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(postData),
+        },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(data);
+            if (res.statusCode >= 400) {
+              reject(new Error(json.error || `HTTP ${res.statusCode}`));
+            } else {
+              resolve(json);
+            }
+          } catch {
+            reject(new Error(`Invalid response: ${data.slice(0, 200)}`));
+          }
+        });
       }
-    }
-  }
-  return skills;
+    );
+    req.on("error", reject);
+    req.write(postData);
+    req.end();
+  });
 }
 
-function readSkillContent(skillPath) {
-  const skillMd = path.join(skillPath, "SKILL.md");
-  if (!fs.existsSync(skillMd)) return null;
-  return fs.readFileSync(skillMd, "utf-8");
+function loadConfig() {
+  if (fs.existsSync(CONFIG_PATH)) return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+  return null;
 }
 
-function extractSkillRules(content) {
-  // Remove YAML frontmatter
-  const withoutFrontmatter = content.replace(/^---[\s\S]*?---\n*/m, "");
-  return withoutFrontmatter.trim();
+function saveConfig(config) {
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
 }
 
-function mkdirp(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
+function detectTools() {
+  const detected = [];
+  for (const [key, config] of Object.entries(TOOL_CONFIGS)) {
+    if (config.detect()) detected.push(key);
   }
+  return detected;
 }
 
-function copyDir(src, dest) {
-  mkdirp(dest);
-  for (const item of fs.readdirSync(src)) {
-    const srcItem = path.join(src, item);
-    const destItem = path.join(dest, item);
-    if (item === "tests") continue; // skip test prompts in installed version
-    if (fs.statSync(srcItem).isDirectory()) {
-      copyDir(srcItem, destItem);
-    } else {
-      fs.copyFileSync(srcItem, destItem);
+function installSkillsForTool(toolKey, skills) {
+  const tool = TOOL_CONFIGS[toolKey];
+  if (!tool) return 0;
+
+  if (tool.format === "skill-folder") {
+    const skillsDir = path.join(PROJECT_ROOT, tool.skillsDir);
+    for (const skill of skills) {
+      const dest = path.join(skillsDir, skill.name);
+      mkdirp(dest);
+      fs.writeFileSync(path.join(dest, "SKILL.md"), skill.content);
     }
+    return skills.length;
   }
-}
 
-function detectTools() {
-  const detected = [];
-  for (const [key, config] of Object.entries(TOOL_CONFIGS)) {
-    if (key === "generic") continue;
-    if (config.detect()) {
-      detected.push(key);
+  if (tool.format === "rules-file") {
+    const rulesPath = path.join(PROJECT_ROOT, tool.rulesFile);
+    mkdirp(path.dirname(rulesPath));
+
+    let content = `# AI Development Skills Framework\n`;
+    content += `# Auto-generated by @valentia-ai-skills/framework\n`;
+    content += `# Do not edit manually — run 'npx ai-skills update' to refresh\n`;
+    content += `# Last updated: ${new Date().toISOString().split("T")[0]}\n\n`;
+
+    for (const skill of skills) {
+      // 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";
     }
+
+    fs.writeFileSync(rulesPath, content);
+    return skills.length;
   }
-  return detected;
+
+  return 0;
 }
 
-function loadProjectConfig() {
-  const configPath = path.join(PROJECT_ROOT, ".ai-skills.json");
-  if (fs.existsSync(configPath)) {
-    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+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 null;
+  return fm;
 }
 
-function saveProjectConfig(config) {
-  const configPath = path.join(PROJECT_ROOT, ".ai-skills.json");
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+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;
 }
 
 // ── Commands ──
 
-function cmdSetup() {
+async function cmdSetup() {
   console.log(c("blue", "\n━━━ AI Skills Framework — Setup ━━━\n"));
 
   // 1. Detect AI tools
   const tools = detectTools();
   if (tools.length === 0) {
-    console.log(c("yellow", "No AI coding tools detected in this project."));
-    console.log("Will create a generic .ai-rules file that works with any tool.\n");
+    console.log(c("yellow", "No AI coding tools detected. Will create a generic .ai-rules file.\n"));
     tools.push("generic");
   } else {
-    console.log(`Detected AI tools: ${tools.map((t) => c("green", TOOL_CONFIGS[t].name)).join(", ")}\n`);
+    console.log(`Detected: ${tools.map((t) => c("green", TOOL_CONFIGS[t]?.name || t)).join(", ")}\n`);
   }
 
-  // 2. Get all available skills
-  const allSkills = getAllSkills();
-  const globalSkills = allSkills.filter((s) => s.category === "global");
-  const stackSkills = allSkills.filter((s) => s.category === "stack");
+  // 2. Ask for email
+  const email = await ask(`${c("bold", "Enter your work email:")} `);
+  if (!email || !email.includes("@")) {
+    console.log(c("red", "Invalid email. Please try again."));
+    process.exit(1);
+  }
 
-  console.log(`Available skills: ${c("bold", allSkills.length)}`);
-  console.log(`  Global: ${globalSkills.map((s) => s.name).join(", ")}`);
-  console.log(`  Stack:  ${stackSkills.map((s) => s.name).join(", ")}\n`);
+  // 3. Lookup team from Supabase
+  console.log(c("dim", "\nLooking up your team..."));
 
-  // 3. Install for each detected tool
-  let installedCount = 0;
+  let response;
+  let skills;
+  let teamName = null;
+  let useRemote = true;
 
-  for (const toolKey of tools) {
-    const tool = TOOL_CONFIGS[toolKey];
-    console.log(c("yellow", `Setting up for ${tool.name}...`));
+  try {
+    response = await fetchJSON(SUPABASE_FUNCTION_URL, { email });
 
-    if (tool.format === "skill-folder") {
-      // Claude Code: copy individual SKILL.md folders
-      const skillsDir = path.join(PROJECT_ROOT, tool.skillsDir);
-      for (const skill of allSkills) {
-        const dest = path.join(skillsDir, skill.name);
-        copyDir(skill.path, dest);
-        console.log(`  ${c("green", "✓")} ${skill.name}`);
-        installedCount++;
+    if (response.team) {
+      teamName = response.team.name;
+      console.log(c("green", `\n✓ Team: ${teamName}`));
+      if (response.user) {
+        console.log(c("dim", `  Welcome, ${response.user.name} (${response.user.role})`));
       }
-    } else if (tool.format === "rules-file") {
-      // Cursor / Copilot / Windsurf / Generic: merge into single rules file
-      const rulesPath = path.join(PROJECT_ROOT, tool.rulesFile);
-      mkdirp(path.dirname(rulesPath));
-
-      let rulesContent = `# AI Development Skills Framework\n`;
-      rulesContent += `# Auto-generated by @valentia-ai-skills/framework\n`;
-      rulesContent += `# Do not edit manually — run 'npx ai-skills update' to refresh\n`;
-      rulesContent += `# Last updated: ${new Date().toISOString().split("T")[0]}\n\n`;
-
-      for (const skill of allSkills) {
-        const content = readSkillContent(skill.path);
-        if (content) {
-          const rules = extractSkillRules(content);
-          rulesContent += `\n${"=".repeat(60)}\n`;
-          rulesContent += `# SKILL: ${skill.name} (${skill.category})\n`;
-          rulesContent += `${"=".repeat(60)}\n\n`;
-          rulesContent += rules + "\n";
-        }
+      if (response.team.stack_tags?.length) {
+        console.log(c("dim", `  Stack: ${response.team.stack_tags.join(", ")}`));
       }
+    } else {
+      console.log(c("yellow", `\n⚠ ${response.message || "No team found for this email."}`));
+    }
 
-      fs.writeFileSync(rulesPath, rulesContent);
-      console.log(`  ${c("green", "✓")} Written to ${tool.rulesFile} (${allSkills.length} skills merged)`);
-      installedCount += allSkills.length;
+    skills = response.skills || [];
+    console.log(`  ${c("bold", skills.length)} skill(s) to install\n`);
+
+  } catch (err) {
+    console.log(c("yellow", `\n⚠ Could not reach skills server: ${err.message}`));
+    console.log(c("dim", "  Falling back to local skills from npm package...\n"));
+
+    skills = getLocalSkills();
+    useRemote = false;
+  }
+
+  if (skills.length === 0) {
+    console.log(c("red", "No skills available. Contact your Framework Admin."));
+    process.exit(1);
+  }
+
+  // 4. 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 skills) console.log(`  ${c("green", "✓")} ${s.name}`);
+    } else {
+      console.log(`  ${c("green", "✓")} ${tool.rulesFile} (${count} skills merged)`);
     }
     console.log("");
   }
 
-  // 4. Save project config
+  // 5. Save config
   const config = {
-    version: "1.0.0",
-    installedAt: new Date().toISOString(),
+    version: require(path.join(__dirname, "..", "package.json")).version,
+    email,
+    team: teamName,
+    source: useRemote ? "supabase" : "local",
     tools,
-    skills: allSkills.map((s) => ({ name: s.name, category: s.category })),
+    skills: skills.map((s) => ({ name: s.name, scope: s.scope, version: s.version })),
+    installedAt: new Date().toISOString(),
   };
-  saveProjectConfig(config);
+  saveConfig(config);
 
-  // 5. Summary
+  // 6. Summary
   console.log(c("blue", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
-  console.log(c("green", `✅ Setup complete!`));
-  console.log(`   ${allSkills.length} skills installed for ${tools.length} tool(s)\n`);
-  console.log(`Config saved to ${c("dim", ".ai-skills.json")}`);
-  console.log(`To update later: ${c("bold", "npx ai-skills update")}`);
-  console.log(`To check status:  ${c("bold", "npx ai-skills status")}\n`);
+  console.log(c("green", "✅ Setup complete!"));
+  console.log(`   ${skills.length} skills installed for ${tools.length} tool(s)`);
+  if (teamName) console.log(`   Team: ${teamName}`);
+  console.log(`\n   Config saved to ${c("dim", ".ai-skills.json")}`);
+  console.log(`   To update: ${c("bold", "npx ai-skills update")}\n`);
 }
 
-function cmdUpdate() {
+async function cmdUpdate() {
   console.log(c("blue", "\n━━━ AI Skills Framework — Update ━━━\n"));
 
-  const config = loadProjectConfig();
-  if (!config) {
+  const config = loadConfig();
+  if (!config || !config.email) {
     console.log(c("yellow", "No .ai-skills.json found. Run 'npx ai-skills setup' first."));
     process.exit(1);
   }
 
-  // Re-run setup with saved tool preferences
-  const tools = config.tools || detectTools();
-  const allSkills = getAllSkills();
+  console.log(c("dim", `Updating for ${config.email}...`));
+
+  let skills;
+  let teamName = config.team;
+
+  try {
+    const response = await fetchJSON(SUPABASE_FUNCTION_URL, { email: config.email });
+    skills = response.skills || [];
+    teamName = response.team?.name || config.team;
+
+    if (response.team) {
+      console.log(c("green", `✓ Team: ${teamName} (${skills.length} skills)`));
+    } else {
+      console.log(c("yellow", `⚠ ${response.message || "No team found."}`));
+    }
+  } catch (err) {
+    console.log(c("yellow", `⚠ Server unreachable: ${err.message}`));
+    console.log(c("dim", "  Using local fallback...\n"));
+    skills = getLocalSkills();
+  }
 
+  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}...`));
+    installSkillsForTool(toolKey, skills);
 
     if (tool.format === "skill-folder") {
-      const skillsDir = path.join(PROJECT_ROOT, tool.skillsDir);
-      for (const skill of allSkills) {
-        const dest = path.join(skillsDir, skill.name);
-        copyDir(skill.path, dest);
-        console.log(`  ${c("green", "✓")} ${skill.name}`);
-      }
-    } else if (tool.format === "rules-file") {
-      const rulesPath = path.join(PROJECT_ROOT, tool.rulesFile);
-      mkdirp(path.dirname(rulesPath));
-
-      let rulesContent = `# AI Development Skills Framework\n`;
-      rulesContent += `# Auto-generated by @valentia-ai-skills/framework\n`;
-      rulesContent += `# Do not edit manually — run 'npx ai-skills update' to refresh\n`;
-      rulesContent += `# Last updated: ${new Date().toISOString().split("T")[0]}\n\n`;
-
-      for (const skill of allSkills) {
-        const content = readSkillContent(skill.path);
-        if (content) {
-          const rules = extractSkillRules(content);
-          rulesContent += `\n${"=".repeat(60)}\n`;
-          rulesContent += `# SKILL: ${skill.name} (${skill.category})\n`;
-          rulesContent += `${"=".repeat(60)}\n\n`;
-          rulesContent += rules + "\n";
-        }
-      }
-
-      fs.writeFileSync(rulesPath, rulesContent);
+      for (const s of skills) console.log(`  ${c("green", "✓")} ${s.name}`);
+    } else {
       console.log(`  ${c("green", "✓")} ${tool.rulesFile} updated`);
     }
   }
 
-  // Update config
   config.updatedAt = new Date().toISOString();
-  config.skills = allSkills.map((s) => ({ name: s.name, category: s.category }));
-  saveProjectConfig(config);
+  config.team = teamName;
+  config.skills = skills.map((s) => ({ name: s.name, scope: s.scope, version: s.version }));
+  saveConfig(config);
 
-  console.log(c("green", `\n✅ Updated ${allSkills.length} skills!\n`));
+  console.log(c("green", `\n✅ Updated ${skills.length} skills!\n`));
 }
 
 function cmdStatus() {
   console.log(c("blue", "\n━━━ AI Skills Framework — Status ━━━\n"));
 
-  const config = loadProjectConfig();
-  const allSkills = getAllSkills();
-  const tools = detectTools();
-
-  // Package version
   const pkg = require(path.join(__dirname, "..", "package.json"));
-  console.log(`Package version: ${c("bold", pkg.version)}`);
-  console.log(`Skills available: ${c("bold", allSkills.length)}`);
+  const config = loadConfig();
+
+  console.log(`Package: ${c("bold", pkg.name)} v${pkg.version}`);
 
-  // Installed status
   if (config) {
-    console.log(`Installed: ${c("green", "Yes")} (${config.installedAt.split("T")[0]})`);
-    if (config.updatedAt) {
-      console.log(`Last updated: ${config.updatedAt.split("T")[0]}`);
+    console.log(`Email: ${c("bold", config.email)}`);
+    console.log(`Team: ${config.team ? c("green", config.team) : c("yellow", "none")}`);
+    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})`)}`);
     }
-    console.log(`Tools configured: ${config.tools.map((t) => TOOL_CONFIGS[t]?.name || t).join(", ")}`);
   } else {
     console.log(`Installed: ${c("red", "No")} — run 'npx ai-skills setup'`);
   }
 
-  // Detected tools
-  console.log(`\nDetected AI tools in this project:`);
-  for (const [key, toolConfig] of Object.entries(TOOL_CONFIGS)) {
-    if (key === "generic") continue;
-    const detected = toolConfig.detect();
-    console.log(`  ${detected ? c("green", "●") : c("dim", "○")} ${toolConfig.name}`);
-  }
-
-  // Skill inventory
-  console.log(`\nSkill inventory:`);
-  for (const skill of allSkills) {
-    const content = readSkillContent(skill.path);
-    const versionMatch = content?.match(/version:\s*["']?([^"'\n]+)/);
-    const version = versionMatch ? versionMatch[1].trim() : "?";
-    console.log(`  ${c("green", "✓")} ${skill.name} ${c("dim", `v${version}`)} ${c("dim", `(${skill.category})`)}`);
+  console.log(`\nDetected AI tools:`);
+  for (const [key, tool] of Object.entries(TOOL_CONFIGS)) {
+    console.log(`  ${tool.detect() ? c("green", "●") : c("dim", "○")} ${tool.name}`);
   }
   console.log("");
 }
 
 function cmdList() {
-  const allSkills = getAllSkills();
-  console.log(c("blue", "\n━━━ Available Skills ━━━\n"));
+  const skills = getLocalSkills();
+  console.log(c("blue", "\n━━━ Available Skills (local) ━━━\n"));
 
-  const categories = {};
-  for (const skill of allSkills) {
-    if (!categories[skill.category]) categories[skill.category] = [];
-    categories[skill.category].push(skill);
+  if (skills.length === 0) {
+    console.log("No local skills found in package.");
+    return;
   }
 
-  for (const [cat, skills] of Object.entries(categories)) {
-    console.log(c("yellow", `${cat.toUpperCase()}`));
-    for (const s of skills) {
-      const content = readSkillContent(s.path);
-      const descMatch = content?.match(/description:\s*>?\s*\n?\s*(.+)/);
-      const desc = descMatch ? descMatch[1].trim().slice(0, 70) + "..." : "";
-      console.log(`  ${s.name.padEnd(22)} ${c("dim", desc)}`);
-    }
-    console.log("");
+  for (const s of skills) {
+    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"));
 }
 
 function cmdDoctor() {
   console.log(c("blue", "\n━━━ AI Skills — Health Check ━━━\n"));
-
   let issues = 0;
-  const allSkills = getAllSkills();
-
-  // Check skills source exists
-  if (allSkills.length === 0) {
-    console.log(c("red", "✗ No skills found in package. Package may be corrupted."));
-    issues++;
-  } else {
-    console.log(c("green", `✓ ${allSkills.length} skills found in package`));
-  }
 
-  // Check project config
-  const config = loadProjectConfig();
+  // Check config
+  const config = loadConfig();
   if (!config) {
-    console.log(c("yellow", "⚠ No .ai-skills.json — run 'npx ai-skills setup'"));
+    console.log(c("red", "✗ No .ai-skills.json — run 'npx ai-skills setup'"));
     issues++;
   } else {
-    console.log(c("green", `✓ Project configured (${config.tools.length} tool(s))`));
+    console.log(c("green", `✓ Config found (${config.email}, team: ${config.team || "none"})`));
 
-    // Check each tool's files exist
-    for (const toolKey of config.tools) {
+    // Check tool files
+    for (const toolKey of config.tools || []) {
       const tool = TOOL_CONFIGS[toolKey];
       if (!tool) continue;
-
       if (tool.format === "skill-folder") {
         const dir = path.join(PROJECT_ROOT, tool.skillsDir);
         if (fs.existsSync(dir)) {
-          const count = fs.readdirSync(dir).filter(
-            (f) => fs.existsSync(path.join(dir, f, "SKILL.md"))
+          const count = fs.readdirSync(dir).filter((f) =>
+            fs.existsSync(path.join(dir, f, "SKILL.md"))
           ).length;
           console.log(c("green", `✓ ${tool.name}: ${count} skills in ${tool.skillsDir}/`));
         } else {
@@ -428,10 +448,30 @@ function cmdDoctor() {
     }
   }
 
-  console.log(issues === 0
-    ? c("green", "\n✅ Everything looks good!\n")
-    : c("yellow", `\n⚠ ${issues} issue(s) found. Run 'npx ai-skills setup' to fix.\n`)
-  );
+  // Check API connectivity
+  console.log(c("dim", "\nChecking API connectivity..."));
+  fetchJSON(SUPABASE_FUNCTION_URL, { email: "healthcheck@test.com" })
+    .then(() => {
+      console.log(c("green", "✓ Supabase Edge Function reachable"));
+      finish();
+    })
+    .catch((err) => {
+      if (SUPABASE_FUNCTION_URL.includes("YOUR_PROJECT")) {
+        console.log(c("yellow", "⚠ API URL not configured — update SUPABASE_FUNCTION_URL in bin/cli.js"));
+        issues++;
+      } else {
+        console.log(c("yellow", `⚠ API unreachable: ${err.message} (will use local fallback)`));
+      }
+      finish();
+    });
+
+  function finish() {
+    console.log(
+      issues === 0
+        ? c("green", "\n✅ Everything looks good!\n")
+        : c("yellow", `\n⚠ ${issues} issue(s) found.\n`)
+    );
+  }
 }
 
 // ── Main ──
@@ -439,44 +479,27 @@ function cmdDoctor() {
 const command = process.argv[2] || "setup";
 
 switch (command) {
-  case "setup":
-    cmdSetup();
-    break;
-  case "update":
-    cmdUpdate();
-    break;
-  case "status":
-    cmdStatus();
-    break;
-  case "list":
-    cmdList();
-    break;
-  case "doctor":
-    cmdDoctor();
-    break;
-  case "help":
-  case "--help":
-  case "-h":
+  case "setup": cmdSetup(); break;
+  case "update": cmdUpdate(); break;
+  case "status": cmdStatus(); break;
+  case "list": cmdList(); break;
+  case "doctor": cmdDoctor(); break;
+  case "help": case "--help": case "-h":
     console.log(`
-${c("blue", "AI Skills Framework")}
+${c("blue", "AI Skills Framework")} — @valentia-ai-skills/framework
 
 Usage:
-  npx ai-skills setup           Setup skills for detected AI tools
-  npx ai-skills update          Update skills to latest version
-  npx ai-skills status          Show installed skills and tools
-  npx ai-skills list            List all available skills
-  npx ai-skills doctor          Check setup health
-  npx ai-skills help            Show this help
-
-How it works:
-  1. Install:  npm install --save-dev @valentia-ai-skills/framework
-  2. Setup:    npx ai-skills setup
-  3. Code:     Your AI tools now follow your org's standards
-  4. Update:   npm update @valentia-ai-skills/framework && npx ai-skills update
-`);
-    break;
+  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 list     List locally bundled skills
+  npx ai-skills doctor   Health check (config + API + tools)
+
+Environment:
+  AI_SKILLS_API_URL      Override the Supabase Edge Function URL
+`); break;
   default:
     console.log(c("red", `Unknown command: ${command}`));
-    console.log("Run 'npx ai-skills help' for usage info.");
+    console.log("Run 'npx ai-skills help' for usage.");
     process.exit(1);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valentia-ai-skills/framework",
-  "version": "1.0.3",
-  "description": "AI development skills framework — centralized coding standards, security patterns, and SOPs for AI-assisted development. Works with Claude Code, Cursor, Copilot, Windsurf, and any AI coding tool.",
+  "version": "1.0.4",
+  "description": "AI development skills framework — centralized coding standards, security patterns, and SOPs for AI-assisted development. Works with Claude Code, Cursor, Copilot, Windsurf, and any AI coding tool.",
   "keywords": [
     "ai-skills",
     "claude-code",