@cleocode/caamp 0.1.0 → 0.3.0

package/dist/cli.js

@@ -24,6 +24,7 @@ import {
   listMcpServers,
   parseSource,
   readConfig,
+  readLockFile,
   recordMcpInstall,
   recordSkillInstall,
   removeMcpFromLock,
@@ -33,9 +34,11 @@ import {
   resolveConfigPath,
   scanDirectory,
   scanFile,
+  setQuiet,
+  setVerbose,
   toSarif,
   validateSkill
-} from "./chunk-63BH7QMR.js";
+} from "./chunk-PCWTRJV2.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -208,7 +211,7 @@ function registerSkillsInstall(parent) {
     let cleanup;
     let skillName;
     let sourceValue;
-    let sourceType = "github";
+    let sourceType;
     if (isMarketplaceScoped(source)) {
       console.log(pc2.dim(`Searching marketplace for ${source}...`));
       const client = new MarketplaceClient();
@@ -228,10 +231,12 @@ function registerSkillsInstall(parent) {
       cleanup = result.cleanup;
       skillName = skill.name;
       sourceValue = skill.githubUrl;
+      sourceType = parsed.type;
     } else {
       const parsed = parseSource(source);
       skillName = parsed.inferredName;
       sourceValue = parsed.value;
+      sourceType = parsed.type;
       if (parsed.type === "github" && parsed.owner && parsed.repo) {
         const result = await cloneRepo(parsed.owner, parsed.repo, parsed.ref, parsed.path);
         localPath = result.localPath;
@@ -399,6 +404,8 @@ function registerSkillsCheck(parent) {
       console.log(pc6.dim("No tracked skills."));
       return;
     }
+    console.log(pc6.dim(`Checking ${entries.length} skill(s) for updates...
+`));
     const results = [];
     for (const [name, entry] of entries) {
       const update = await checkSkillUpdate(name);
@@ -408,16 +415,37 @@ function registerSkillsCheck(parent) {
       console.log(JSON.stringify(results, null, 2));
       return;
     }
-    console.log(pc6.bold(`
-${entries.length} tracked skill(s):
-`));
+    let updatesAvailable = 0;
     for (const r of results) {
-      const status = r.hasUpdate ? pc6.yellow("update available") : pc6.green("up to date");
-      console.log(`  ${pc6.bold(r.name.padEnd(30))} ${status}`);
+      let statusLabel;
+      if (r.status === "update-available") {
+        statusLabel = pc6.yellow("update available");
+        updatesAvailable++;
+      } else if (r.status === "up-to-date") {
+        statusLabel = pc6.green("up to date");
+      } else {
+        statusLabel = pc6.dim("unknown");
+      }
+      console.log(`  ${pc6.bold(r.name.padEnd(30))} ${statusLabel}`);
+      if (r.currentVersion || r.latestVersion) {
+        const current = r.currentVersion ? r.currentVersion.slice(0, 12) : "?";
+        const latest = r.latestVersion ?? "?";
+        if (r.hasUpdate) {
+          console.log(`  ${pc6.dim("current:")} ${current}  ${pc6.dim("->")}  ${pc6.cyan(latest)}`);
+        } else {
+          console.log(`  ${pc6.dim("version:")} ${current}`);
+        }
+      }
       console.log(`  ${pc6.dim(`source: ${r.entry.source}`)}`);
       console.log(`  ${pc6.dim(`agents: ${r.entry.agents.join(", ")}`)}`);
       console.log();
     }
+    if (updatesAvailable > 0) {
+      console.log(pc6.yellow(`${updatesAvailable} update(s) available.`));
+      console.log(pc6.dim("Run `caamp skills update` to update all."));
+    } else {
+      console.log(pc6.green("All skills are up to date."));
+    }
   });
 }
 
@@ -432,9 +460,116 @@ function registerSkillsUpdate(parent) {
       return;
     }
     console.log(pc7.dim(`Checking ${entries.length} skill(s) for updates...`));
-    console.log(pc7.dim("All skills are up to date."));
-    console.log(pc7.dim("\nTo reinstall a specific skill:"));
-    console.log(pc7.dim("  caamp skills install <source>"));
+    const outdated = [];
+    for (const [name] of entries) {
+      const result = await checkSkillUpdate(name);
+      if (result.hasUpdate) {
+        outdated.push({
+          name,
+          currentVersion: result.currentVersion,
+          latestVersion: result.latestVersion
+        });
+      }
+    }
+    if (outdated.length === 0) {
+      console.log(pc7.green("\nAll skills are up to date."));
+      return;
+    }
+    console.log(pc7.yellow(`
+${outdated.length} skill(s) have updates available:
+`));
+    for (const skill of outdated) {
+      const current = skill.currentVersion?.slice(0, 12) ?? "?";
+      const latest = skill.latestVersion ?? "?";
+      console.log(`  ${pc7.bold(skill.name)}  ${pc7.dim(current)}  ${pc7.dim("->")}  ${pc7.cyan(latest)}`);
+    }
+    if (!opts.yes) {
+      const readline = await import("readline");
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise((resolve) => {
+        rl.question(pc7.dim("\nProceed with update? [y/N] "), resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+        console.log(pc7.dim("Update cancelled."));
+        return;
+      }
+    }
+    console.log();
+    let successCount = 0;
+    let failCount = 0;
+    for (const skill of outdated) {
+      const entry = tracked[skill.name];
+      if (!entry) continue;
+      console.log(pc7.dim(`Updating ${pc7.bold(skill.name)}...`));
+      try {
+        const parsed = parseSource(entry.source);
+        let localPath;
+        let cleanup;
+        if (parsed.type === "github" && parsed.owner && parsed.repo) {
+          const result = await cloneRepo(parsed.owner, parsed.repo, parsed.ref, parsed.path);
+          localPath = result.localPath;
+          cleanup = result.cleanup;
+        } else if (parsed.type === "gitlab" && parsed.owner && parsed.repo) {
+          const result = await cloneGitLabRepo(parsed.owner, parsed.repo, parsed.ref, parsed.path);
+          localPath = result.localPath;
+          cleanup = result.cleanup;
+        } else {
+          console.log(pc7.yellow(`  Skipped ${skill.name}: source type "${parsed.type}" does not support auto-update`));
+          continue;
+        }
+        try {
+          const providers = entry.agents.map((a) => getProvider(a)).filter((p) => p !== void 0);
+          if (providers.length === 0) {
+            console.log(pc7.yellow(`  Skipped ${skill.name}: no valid providers found`));
+            continue;
+          }
+          const installResult = await installSkill(
+            localPath,
+            skill.name,
+            providers,
+            entry.isGlobal,
+            entry.projectDir
+          );
+          if (installResult.success) {
+            await recordSkillInstall(
+              skill.name,
+              entry.scopedName,
+              entry.source,
+              entry.sourceType,
+              installResult.linkedAgents,
+              installResult.canonicalPath,
+              entry.isGlobal,
+              entry.projectDir,
+              skill.latestVersion
+            );
+            console.log(pc7.green(`  Updated ${pc7.bold(skill.name)}`));
+            successCount++;
+          } else {
+            console.log(pc7.red(`  Failed to update ${skill.name}: no agents linked`));
+            failCount++;
+          }
+          if (installResult.errors.length > 0) {
+            for (const err of installResult.errors) {
+              console.log(pc7.yellow(`    ${err}`));
+            }
+          }
+        } finally {
+          if (cleanup) await cleanup();
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(pc7.red(`  Failed to update ${skill.name}: ${msg}`));
+        failCount++;
+      }
+    }
+    console.log();
+    if (successCount > 0) {
+      console.log(pc7.green(`Updated ${successCount} skill(s).`));
+    }
+    if (failCount > 0) {
+      console.log(pc7.red(`Failed to update ${failCount} skill(s).`));
+    }
   });
 }
 
@@ -929,13 +1064,272 @@ ${provider.toolName} config (${configPath}):
   });
 }
 
+// src/commands/doctor.ts
+import pc19 from "picocolors";
+import { execFileSync } from "child_process";
+import { existsSync as existsSync5, readdirSync, lstatSync } from "fs";
+import { homedir } from "os";
+import { join as join6 } from "path";
+var CAAMP_VERSION = "0.2.0";
+function getNodeVersion() {
+  return process.version;
+}
+function getNpmVersion() {
+  try {
+    return execFileSync("npm", ["--version"], { stdio: "pipe", encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function checkEnvironment() {
+  const checks = [];
+  checks.push({ label: `Node.js ${getNodeVersion()}`, status: "pass" });
+  const npmVersion = getNpmVersion();
+  if (npmVersion) {
+    checks.push({ label: `npm ${npmVersion}`, status: "pass" });
+  } else {
+    checks.push({ label: "npm not found", status: "warn" });
+  }
+  checks.push({ label: `CAAMP v${CAAMP_VERSION}`, status: "pass" });
+  checks.push({ label: `${process.platform} ${process.arch}`, status: "pass" });
+  return { name: "Environment", checks };
+}
+function checkRegistry() {
+  const checks = [];
+  try {
+    const providers = getAllProviders();
+    const count = getProviderCount();
+    checks.push({ label: `${count} providers loaded`, status: "pass" });
+    const malformed = [];
+    for (const p of providers) {
+      if (!p.id || !p.toolName || !p.configKey || !p.configFormat) {
+        malformed.push(p.id || "(unknown)");
+      }
+    }
+    if (malformed.length === 0) {
+      checks.push({ label: "All entries valid", status: "pass" });
+    } else {
+      checks.push({
+        label: `${malformed.length} malformed entries`,
+        status: "fail",
+        detail: malformed.join(", ")
+      });
+    }
+  } catch (err) {
+    checks.push({
+      label: "Failed to load registry",
+      status: "fail",
+      detail: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return { name: "Registry", checks };
+}
+function checkInstalledProviders() {
+  const checks = [];
+  try {
+    const results = detectAllProviders();
+    const installed = results.filter((r) => r.installed);
+    checks.push({ label: `${installed.length} found`, status: "pass" });
+    for (const r of installed) {
+      const methods = r.methods.join(", ");
+      checks.push({ label: `${r.provider.toolName} (${methods})`, status: "pass" });
+    }
+  } catch (err) {
+    checks.push({
+      label: "Detection failed",
+      status: "fail",
+      detail: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return { name: "Installed Providers", checks };
+}
+function checkSkillSymlinks() {
+  const checks = [];
+  const canonicalDir = join6(homedir(), ".agents", "skills");
+  if (!existsSync5(canonicalDir)) {
+    checks.push({ label: "0 canonical skills", status: "pass" });
+    checks.push({ label: "No broken symlinks", status: "pass" });
+    return { name: "Skills", checks };
+  }
+  let canonicalCount = 0;
+  try {
+    const entries = readdirSync(canonicalDir);
+    canonicalCount = entries.length;
+    checks.push({ label: `${canonicalCount} canonical skills`, status: "pass" });
+  } catch {
+    checks.push({ label: "Cannot read skills directory", status: "warn" });
+    return { name: "Skills", checks };
+  }
+  const broken = [];
+  const providers = getAllProviders();
+  for (const provider of providers) {
+    const skillDir = provider.pathSkills;
+    if (!existsSync5(skillDir)) continue;
+    try {
+      const entries = readdirSync(skillDir);
+      for (const entry of entries) {
+        const fullPath = join6(skillDir, entry);
+        try {
+          const stat = lstatSync(fullPath);
+          if (stat.isSymbolicLink()) {
+            if (!existsSync5(fullPath)) {
+              broken.push(`${provider.id}/${entry}`);
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  if (broken.length === 0) {
+    checks.push({ label: "No broken symlinks", status: "pass" });
+  } else {
+    checks.push({
+      label: `${broken.length} broken symlinks`,
+      status: "warn",
+      detail: broken.join(", ")
+    });
+  }
+  return { name: "Skills", checks };
+}
+async function checkLockFile() {
+  const checks = [];
+  try {
+    const lock = await readLockFile();
+    checks.push({ label: "Lock file valid", status: "pass" });
+    let orphaned = 0;
+    for (const [name, entry] of Object.entries(lock.skills)) {
+      if (entry.canonicalPath && !existsSync5(entry.canonicalPath)) {
+        orphaned++;
+      }
+    }
+    if (orphaned === 0) {
+      checks.push({ label: `0 orphaned entries`, status: "pass" });
+    } else {
+      checks.push({
+        label: `${orphaned} orphaned skill entries`,
+        status: "warn",
+        detail: "Skills tracked in lock file but missing from disk"
+      });
+    }
+  } catch (err) {
+    checks.push({
+      label: "Failed to read lock file",
+      status: "fail",
+      detail: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return { name: "Lock File", checks };
+}
+async function checkConfigFiles() {
+  const checks = [];
+  const results = detectAllProviders();
+  const installed = results.filter((r) => r.installed);
+  for (const r of installed) {
+    const provider = r.provider;
+    const configPath = provider.configPathGlobal;
+    if (!existsSync5(configPath)) {
+      checks.push({
+        label: `${provider.id}: no config file found`,
+        status: "warn",
+        detail: configPath
+      });
+      continue;
+    }
+    try {
+      await readConfig(configPath, provider.configFormat);
+      const relPath = configPath.replace(homedir(), "~");
+      checks.push({
+        label: `${provider.id}: ${relPath} readable`,
+        status: "pass"
+      });
+    } catch (err) {
+      checks.push({
+        label: `${provider.id}: config parse error`,
+        status: "fail",
+        detail: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (installed.length === 0) {
+    checks.push({ label: "No installed providers to check", status: "pass" });
+  }
+  return { name: "Config Files", checks };
+}
+function formatSection(section) {
+  const lines = [];
+  lines.push(`  ${pc19.bold(section.name)}`);
+  for (const check of section.checks) {
+    const icon = check.status === "pass" ? pc19.green("\u2713") : check.status === "warn" ? pc19.yellow("\u26A0") : pc19.red("\u2717");
+    lines.push(`    ${icon} ${check.label}`);
+    if (check.detail) {
+      lines.push(`      ${pc19.dim(check.detail)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Diagnose configuration issues and health").option("--json", "Output as JSON").action(async (opts) => {
+    const sections = [];
+    sections.push(checkEnvironment());
+    sections.push(checkRegistry());
+    sections.push(checkInstalledProviders());
+    sections.push(checkSkillSymlinks());
+    sections.push(await checkLockFile());
+    sections.push(await checkConfigFiles());
+    let passed = 0;
+    let warnings = 0;
+    let errors = 0;
+    for (const section of sections) {
+      for (const check of section.checks) {
+        if (check.status === "pass") passed++;
+        else if (check.status === "warn") warnings++;
+        else errors++;
+      }
+    }
+    if (opts.json) {
+      const output = {
+        version: CAAMP_VERSION,
+        sections: sections.map((s) => ({
+          name: s.name,
+          checks: s.checks
+        })),
+        summary: { passed, warnings, errors }
+      };
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    console.log(pc19.bold("\ncaamp doctor\n"));
+    for (const section of sections) {
+      console.log(formatSection(section));
+      console.log();
+    }
+    const parts = [];
+    parts.push(pc19.green(`${passed} checks passed`));
+    if (warnings > 0) parts.push(pc19.yellow(`${warnings} warning${warnings !== 1 ? "s" : ""}`));
+    if (errors > 0) parts.push(pc19.red(`${errors} error${errors !== 1 ? "s" : ""}`));
+    console.log(`  ${pc19.bold("Summary")}: ${parts.join(", ")}`);
+    console.log();
+    if (errors > 0) {
+      process.exit(1);
+    }
+  });
+}
+
 // src/cli.ts
 var program = new Command();
-program.name("caamp").description("Central AI Agent Managed Packages - unified provider registry and package manager").version("0.1.0");
+program.name("caamp").description("Central AI Agent Managed Packages - unified provider registry and package manager").version("0.3.0").option("-v, --verbose", "Show debug output").option("-q, --quiet", "Suppress non-error output");
+program.hook("preAction", (thisCommand) => {
+  const opts = thisCommand.optsWithGlobals();
+  if (opts.verbose) setVerbose(true);
+  if (opts.quiet) setQuiet(true);
+});
 registerProvidersCommand(program);
 registerSkillsCommands(program);
 registerMcpCommands(program);
 registerInstructionsCommands(program);
 registerConfigCommand(program);
+registerDoctorCommand(program);
 program.parse();
 //# sourceMappingURL=cli.js.map