@npeercy/skills 0.1.2 → 0.1.4

package/bin/skills.js

@@ -23,10 +23,10 @@ Setup:
 Discovery:
   search [query]                        Search skills (no query = browse all)
   info <skill>                          Skill details + versions
+  list [--verify] [--outdated] [--json] Show all local skills (managed + unmanaged)
 
 Install:
   install <skill>[@ver] [--agent <a>] [--dry-run]
-  list [--verify] [--outdated] [--json]
   update [<skill>]                      Update one or all
   uninstall <skill>
 
@@ -98,7 +98,15 @@ async function maybeWarnOutdated() {
 
 async function main() {
   const args = process.argv.slice(2);
-  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+
+  // `skills` by itself -> list all local skills (managed + unmanaged)
+  if (args.length === 0) {
+    await maybeWarnOutdated();
+    await cmdList({ verify: false, outdated: false, json: false });
+    return;
+  }
+
+  if (args[0] === '--help' || args[0] === '-h') {
     console.log(USAGE);
     return;
   }

package/lib/skills.js

@@ -95,23 +95,81 @@ async function promptForToken(serverUrl) {
   return token;
 }
 
-async function installBuiltins(agents) {
-  const st = loadState();
+async function promptYesNo(question, defaultYes = true) {
+  const suffix = defaultYes ? ' [Y/n] ' : ' [y/N] ';
+  const rl = createInterface({ input, output });
+  const ans = (await rl.question(question + suffix)).trim().toLowerCase();
+  rl.close();
+  if (!ans) return defaultYes;
+  return ['y', 'yes'].includes(ans);
+}
+
+function discoverUnmanaged(agents, st) {
+  const unmanaged = new Map(); // name -> { sources: [{agent,path,skillMdPath}] }
+  const managedLinks = new Set(Object.keys(st.installed).map(linkNameForSkill));
+
+  for (const [agentName, agentPath] of Object.entries(agents)) {
+    if (!existsSync(agentPath)) continue;
+    for (const entry of readdirSync(agentPath, { withFileTypes: true })) {
+      const full = join(agentPath, entry.name);
+
+      // Skip managed link names
+      if (managedLinks.has(entry.name)) continue;
+
+      // Skip if symlink points to managed store
+      try {
+        if (lstatSync(full).isSymbolicLink()) {
+          const target = readlinkSync(full);
+          if (target.includes('skill-sharer')) continue;
+        }
+      } catch {
+        // ignore stat errors
+      }
+
+      const skillMd = entry.isDirectory()
+        ? join(full, 'SKILL.md')
+        : (lstatSync(full).isSymbolicLink() ? join(resolve(readlinkSync(full)), 'SKILL.md') : null);
+
+      if (!skillMd || !existsSync(skillMd)) continue;
+
+      const key = entry.name;
+      if (!unmanaged.has(key)) unmanaged.set(key, { sources: [] });
+      unmanaged.get(key).sources.push({ agent: agentName, path: full, skillMdPath: skillMd });
+    }
+  }
+
+  return unmanaged;
+}
+
+function bundledBuiltins() {
+  const out = [];
   const builtinsRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'builtin-skills');
-  if (!existsSync(builtinsRoot)) return;
+  if (!existsSync(builtinsRoot)) return out;
 
-  const installed = [];
   for (const entry of readdirSync(builtinsRoot, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-
     const srcDir = join(builtinsRoot, entry.name);
     const skillMd = join(srcDir, 'SKILL.md');
     if (!existsSync(skillMd)) continue;
-
     const meta = parseFrontmatter(readFileSync(skillMd, 'utf8'));
     if (!meta) continue;
+    out.push({
+      id: `__builtin__/local/${meta.name}`,
+      name: meta.name,
+      srcDir,
+    });
+  }
+
+  return out;
+}
+
+async function installBuiltins(agents) {
+  const st = loadState();
 
-    const id = `__builtin__/local/${meta.name}`;
+  const installed = [];
+  for (const b of bundledBuiltins()) {
+    const srcDir = b.srcDir;
+    const id = b.id;
     const version = 'v1';
     const dest = managedPath(id, version);
     const files = collectFiles(srcDir);
@@ -149,7 +207,7 @@ async function installBuiltins(agents) {
       builtin: true,
     };
 
-    installed.push(meta.name);
+    installed.push(b.name);
   }
 
   saveState(st);
@@ -207,7 +265,7 @@ export async function cmdInit(args) {
 
   // Import existing skills
   if (!args.noImport) {
-    await cmdImport({ all: true, quiet: true });
+    await cmdImport({ all: true, quiet: false });
   }
 
   // Install built-ins
@@ -234,6 +292,29 @@ export async function cmdLogin(args) {
   cfg.org = me.org;
   saveConfig(cfg);
   console.log(`✓ Logged in as ${me.user} (org: ${me.org}, role: ${me.role})`);
+  console.log(`  Your publish namespace is: ${me.org}/${me.user}/<skillname>`);
+
+  // First-time setup guidance
+  const st = loadState();
+  const agents = detectAgents();
+  const unmanaged = discoverUnmanaged(agents, st);
+  const hasBuiltins = Object.keys(st.installed).some(id => id.startsWith('__builtin__/local/'));
+
+  if (!hasBuiltins || unmanaged.size > 0) {
+    console.log('\nSetup not complete yet.');
+    if (!hasBuiltins) console.log('  - Built-in skills are not installed yet.');
+    if (unmanaged.size > 0) console.log(`  - Found ${unmanaged.size} unmanaged local skill(s).`);
+
+    const doSetup = await promptYesNo('Run guided setup now? (recommended)', true);
+    if (doSetup) {
+      await cmdInit({ server: cfg.server, token: cfg.token, noImport: false });
+      return;
+    }
+
+    console.log('\nNext steps:');
+    if (!hasBuiltins) console.log('  skills init --no-import');
+    if (unmanaged.size > 0) console.log('  skills import');
+  }
 }
 
 export async function cmdLogout() {
@@ -342,12 +423,13 @@ export async function cmdInstall(args) {
   console.log('Installed.');
 }
 
-export async function cmdList(args) {
-  const cfg = loadConfig();
+export async function cmdList(args = {}) {
   const st = loadState();
   const agents = detectAgents();
 
   const rows = [];
+
+  // Managed installs (skill-sharer state)
   for (const [id, rec] of Object.entries(st.installed).sort()) {
     let status = 'ok';
     if (args.verify) {
@@ -360,15 +442,54 @@ export async function cmdList(args) {
         const { org, user, name } = splitSkillId(id);
         const data = await api.info(org, user, name);
         latest = data.latest_version || rec.version;
-      } catch { /* offline */ }
+      } catch {
+        // offline / not in registry
+      }
     }
 
     const outdated = latest !== rec.version;
     if (args.outdated && !outdated) continue;
     if (outdated && status === 'ok') status = 'outdated';
 
-    rows.push({ id, version: rec.version, latest, agents: rec.agents.join(','), status });
-  }
+    rows.push({
+      id,
+      version: rec.version,
+      latest,
+      agents: (rec.agents || []).join(','),
+      status,
+      managed: true,
+    });
+  }
+
+  // Bundled built-ins (show even if not installed yet)
+  const installedIds = new Set(Object.keys(st.installed));
+  for (const b of bundledBuiltins()) {
+    if (installedIds.has(b.id)) continue;
+    rows.push({
+      id: b.id,
+      version: '-',
+      latest: 'v1',
+      agents: '-',
+      status: 'bundled',
+      managed: false,
+    });
+  }
+
+  // Unmanaged installs (present in agent dirs but not in skill-sharer state)
+  const unmanaged = discoverUnmanaged(agents, st);
+  for (const [name, info] of unmanaged.entries()) {
+    const agentList = [...new Set(info.sources.map(s => s.agent))].sort().join(',');
+    rows.push({
+      id: `(unmanaged) ${name}`,
+      version: '-',
+      latest: '-',
+      agents: agentList,
+      status: 'unmanaged',
+      managed: false,
+    });
+  }
+
+  rows.sort((a, b) => a.id.localeCompare(b.id));
 
   if (args.json) {
     console.log(JSON.stringify(rows, null, 2));
@@ -376,7 +497,7 @@ export async function cmdList(args) {
   }
 
   if (rows.length === 0) {
-    console.log('No installed skills.');
+    console.log('No skills found in managed store or agent directories.');
     return;
   }
 
@@ -384,6 +505,11 @@ export async function cmdList(args) {
   for (const r of rows) {
     console.log(r.id.padEnd(56) + r.version.padEnd(10) + r.latest.padEnd(10) + r.agents.padEnd(20) + r.status);
   }
+
+  const unmanagedCount = rows.filter(r => r.status === 'unmanaged').length;
+  if (unmanagedCount > 0) {
+    console.log(`\nFound ${unmanagedCount} unmanaged skill(s). Run: skills import`);
+  }
 }
 
 function verifyInstall(id, rec, agents) {
@@ -536,33 +662,7 @@ export async function cmdImport(args) {
   const agents = detectAgents();
 
   // Find unmanaged skills in agent dirs
-  const unmanaged = new Map(); // name -> { sources: [{agent, path}] }
-  const managedLinks = new Set(Object.keys(st.installed).map(linkNameForSkill));
-
-  for (const [agentName, agentPath] of Object.entries(agents)) {
-    if (!existsSync(agentPath)) continue;
-    for (const entry of readdirSync(agentPath, { withFileTypes: true })) {
-      const full = join(agentPath, entry.name);
-      // Skip managed symlinks
-      if (managedLinks.has(entry.name)) continue;
-      // Skip if it's a symlink pointing into our managed store
-      try {
-        if (lstatSync(full).isSymbolicLink()) {
-          const target = readlinkSync(full);
-          if (target.includes('skill-sharer')) continue;
-        }
-      } catch { /* ok */ }
-
-      // Check if it has SKILL.md
-      const skillMd = entry.isDirectory() ? join(full, 'SKILL.md') :
-        (lstatSync(full).isSymbolicLink() ? join(resolve(readlinkSync(full)), 'SKILL.md') : null);
-      if (!skillMd || !existsSync(skillMd)) continue;
-
-      const name = entry.name;
-      if (!unmanaged.has(name)) unmanaged.set(name, { sources: [] });
-      unmanaged.get(name).sources.push({ agent: agentName, path: full, skillMdPath: skillMd });
-    }
-  }
+  const unmanaged = discoverUnmanaged(agents, st);
 
   if (args.path) {
     const p = resolve(args.path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@npeercy/skills",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "CLI-first skill marketplace for coding agents",
   "type": "module",
   "bin": {