skillpacks 0.1.0 → 0.1.1

package/scripts/prepublish-auth-check.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageJson = JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+const packageName = packageJson.name;
+const packageVersion = packageJson.version;
+const registry = process.env.npm_config_registry || "https://registry.npmjs.org/";
+const expectedPublisher = process.env.SKILLPACKS_NPM_PUBLISHER || "glexcorp";
+const isDryRun = String(process.env.npm_config_dry_run || "").toLowerCase() === "true";
+const npmTimeoutMs = Number(process.env.SKILLPACKS_NPM_PREFLIGHT_TIMEOUT_MS || 15000);
+
+function npm(args) {
+  return spawnSync("npm", [...args, "--registry", registry], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: npmTimeoutMs
+  });
+}
+
+function fail(message, result) {
+  const details = result
+    ? [
+        result.error && `error:\n${result.error.message}`,
+        result.stdout.trim() && `stdout:\n${result.stdout.trim()}`,
+        result.stderr.trim() && `stderr:\n${result.stderr.trim()}`
+      ]
+        .filter(Boolean)
+        .join("\n\n")
+    : "";
+
+  console.error(message);
+  if (details) {
+    console.error(`\n${details}`);
+  }
+  process.exit(1);
+}
+
+function parseMaintainerNames(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) {
+    return value
+      .map((entry) => {
+        if (typeof entry === "string") return entry.split(/\s+/)[0];
+        if (entry && typeof entry === "object") return entry.name;
+        return null;
+      })
+      .filter(Boolean);
+  }
+  if (typeof value === "object" && value.name) {
+    return [value.name];
+  }
+  return [];
+}
+
+if (isDryRun) {
+  console.error("Skipping npm auth preflight for publish dry-run.");
+  process.exit(0);
+}
+
+const whoami = npm(["whoami"]);
+if (whoami.error) {
+  fail(
+    [
+      `npm publish auth preflight failed for ${packageName}@${packageVersion}.`,
+      `npm whoami did not complete within ${npmTimeoutMs}ms. Check npm registry connectivity/auth, then retry.`
+    ].join("\n"),
+    whoami
+  );
+}
+if (whoami.status !== 0) {
+  fail(
+    [
+      `npm publish auth preflight failed for ${packageName}@${packageVersion}.`,
+      `Log in to ${registry} as ${expectedPublisher} before running a real publish.`,
+      "",
+      `  npm login --registry ${registry}`,
+      `  npm whoami --registry ${registry}`,
+      "",
+      "Without a valid publisher session, npm may fail later with a misleading PUT 404."
+    ].join("\n"),
+    whoami
+  );
+}
+
+const actualPublisher = whoami.stdout.trim();
+if (actualPublisher !== expectedPublisher) {
+  fail(
+    [
+      `npm publish auth preflight failed for ${packageName}@${packageVersion}.`,
+      `Logged in as ${actualPublisher}, but expected ${expectedPublisher}.`,
+      "If this release intentionally moved to another maintainer, set SKILLPACKS_NPM_PUBLISHER."
+    ].join("\n")
+  );
+}
+
+const maintainers = npm(["view", packageName, "maintainers", "--json"]);
+if (maintainers.status === 0) {
+  const maintainerNames = parseMaintainerNames(JSON.parse(maintainers.stdout));
+  if (!maintainerNames.includes(actualPublisher)) {
+    fail(
+      [
+        `npm publish auth preflight failed for ${packageName}@${packageVersion}.`,
+        `${actualPublisher} is authenticated, but is not listed as a ${packageName} maintainer.`,
+        `Current maintainers: ${maintainerNames.length ? maintainerNames.join(", ") : "(none)"}`
+      ].join("\n")
+    );
+  }
+} else if (!/E404|404/.test(`${maintainers.stdout}\n${maintainers.stderr}`)) {
+  fail(`Could not verify npm maintainers for ${packageName}.`, maintainers);
+}
+
+const publishedVersion = npm(["view", `${packageName}@${packageVersion}`, "version", "--json"]);
+if (publishedVersion.status === 0) {
+  fail(`${packageName}@${packageVersion} is already published to ${registry}.`);
+}
+if (!/E404|404/.test(`${publishedVersion.stdout}\n${publishedVersion.stderr}`)) {
+  fail(`Could not verify whether ${packageName}@${packageVersion} is already published.`, publishedVersion);
+}
+
+console.error(`npm publish auth preflight passed for ${packageName}@${packageVersion} as ${actualPublisher}.`);

package/src/cli/lifecycle.mjs

@@ -52,7 +52,7 @@ function resolvePackagedPath(relativePath) {
 function projectTypeForPack(pack) {
   if (
     [
-      'business-discovery',
+      'business-research',
       'customer-lifecycle',
       'business-growth',
       'business-ops',
@@ -85,6 +85,12 @@ function activePackNames(manifest) {
     .sort((a, b) => a.localeCompare(b));
 }
 
+function manifestPackageLabel(manifest) {
+  const name = manifest?.package?.name || 'skillpacks';
+  const version = manifest?.package?.version || 'unknown';
+  return `${name}@${version}`;
+}
+
 function availablePacksInline(manifest) {
   const names = activePackNames(manifest);
   if (names.length === 0) {
@@ -115,6 +121,12 @@ function packSkillEntries(manifest, packName, tool) {
   });
 }
 
+function baseSkillEntries(manifest, tool) {
+  return manifestSkills(manifest).filter((skill) => {
+    return skill.scope === 'global' && skill.platform === tool && skill.path;
+  });
+}
+
 function uniquePackSkillNames(manifest, packName) {
   return [
     ...new Set(
@@ -125,6 +137,16 @@ function uniquePackSkillNames(manifest, packName) {
   ].sort((a, b) => a.localeCompare(b));
 }
 
+function uniqueBaseSkillNames(manifest) {
+  return [
+    ...new Set(
+      manifestSkills(manifest)
+        .filter((skill) => skill.scope === 'global' && skill.name)
+        .map((skill) => skill.name)
+    )
+  ].sort((a, b) => a.localeCompare(b));
+}
+
 function findPackForSkill(manifest, skillName) {
   return manifestSkills(manifest).find((skill) => skill.name === skillName && skill.pack)?.pack || null;
 }
@@ -375,9 +397,9 @@ function linkSkill(projectRoot, tool, skillName, sourceDir, config) {
 
   if (syncSkillInstall(effective.source, target)) {
     if (effective.usingPinned) {
-      console.log(`Installed .${tool}/skills/${skillName} -> ${effective.source} (pinned ${effective.pinned})`);
+      console.log(`Installed .${tool}/skills/${skillName} (pinned ${effective.pinned})`);
     } else {
-      console.log(`Installed .${tool}/skills/${skillName} -> ${effective.source}`);
+      console.log(`Installed .${tool}/skills/${skillName}`);
     }
   }
 }
@@ -386,6 +408,10 @@ function enabledPacks(config) {
   return Array.isArray(config?.enabled_packs) ? config.enabled_packs : [];
 }
 
+function baseSkillsEnabled(config) {
+  return config?.base_skills === true;
+}
+
 function pinnedVersions(config) {
   return config?.pinned_versions && typeof config.pinned_versions === 'object'
     ? config.pinned_versions
@@ -410,6 +436,40 @@ function writePackProjectConfig(projectRoot, pack, packs) {
   writeProjectConfig(projectRoot, next);
 }
 
+function writeBaseProjectConfig(projectRoot) {
+  const existing = readProjectConfig(projectRoot);
+  const next = existing
+    ? { ...existing }
+    : {
+        project_type: inferProjectType(projectRoot),
+        enabled_packs: [],
+        skill_pack_version: 1
+      };
+
+  if (!next.project_type) {
+    next.project_type = inferProjectType(projectRoot);
+  }
+  if (!Array.isArray(next.enabled_packs)) {
+    next.enabled_packs = [];
+  }
+  next.base_skills = true;
+  next.skill_pack_version = 1;
+  writeProjectConfig(projectRoot, next);
+}
+
+function installBaseSkills(projectRoot, manifest, config = readProjectConfig(projectRoot)) {
+  const skillNames = uniqueBaseSkillNames(manifest);
+  if (skillNames.length === 0) {
+    throw new Error('No base skills found in the packaged manifest');
+  }
+
+  for (const tool of TOOLS) {
+    for (const skill of baseSkillEntries(manifest, tool)) {
+      linkSkill(projectRoot, tool, skill.name, skillSourceDir(skill), config);
+    }
+  }
+}
+
 function installPack(projectRoot, manifest, pack) {
   const hibernatedPack = canonicalHibernatedPack(pack);
   if (hibernatedPack) {
@@ -672,7 +732,7 @@ function relinkPinnedSkill(projectRoot, manifest, pack, skillName, version) {
     }
 
     if (syncSkillInstall(source, join(root, skillName))) {
-      console.log(`Pinned .${tool}/skills/${skillName} -> ${source}`);
+      console.log(`Pinned .${tool}/skills/${skillName} (${version})`);
     }
   }
 }
@@ -691,7 +751,7 @@ function relinkUnpinnedSkill(projectRoot, manifest, pack, skillName) {
     }
 
     if (syncSkillInstall(source, join(root, skillName))) {
-      console.log(`Unpinned .${tool}/skills/${skillName} -> ${source}`);
+      console.log(`Unpinned .${tool}/skills/${skillName} (latest)`);
     }
   }
 }
@@ -699,6 +759,12 @@ function relinkUnpinnedSkill(projectRoot, manifest, pack, skillName) {
 function expectedSkillNames(manifest, config) {
   const expected = new Set();
 
+  if (baseSkillsEnabled(config)) {
+    for (const skillName of uniqueBaseSkillNames(manifest)) {
+      expected.add(skillName);
+    }
+  }
+
   for (const pack of enabledPacks(config)) {
     for (const skillName of uniquePackSkillNames(manifest, pack)) {
       expected.add(skillName);
@@ -719,6 +785,17 @@ export function printSessionReloadNotice() {
   console.log('Codex: start a fresh Codex CLI session if the $ skill list does not show newly installed or removed project-local skills.');
 }
 
+export async function initProject({ manifest, projectRoot = process.cwd() }) {
+  return withProjectLock(projectRoot, 'init', async () => {
+    installBaseSkills(projectRoot, manifest);
+    writeBaseProjectConfig(projectRoot);
+    console.log('Updated .agents/project.json (base skills enabled)');
+    console.log(`Initialized project base skills to ${manifestPackageLabel(manifest)}.`);
+    printSessionReloadNotice();
+    return 0;
+  });
+}
+
 export async function installResolved({ manifest, projectRoot = process.cwd(), packs = [], skills = [] }) {
   return withProjectLock(projectRoot, `install ${[...packs, ...skills].join(' ')}`.trim(), async () => {
     for (const pack of packs) {
@@ -777,7 +854,7 @@ export function doctorProject({ projectRoot = process.cwd() } = {}) {
 
   if (anyStale) {
     console.log('');
-    console.log('Fix: scripts/pack.sh refresh');
+    console.log('Fix: npx skillpacks refresh (or scripts/pack.sh refresh from a source checkout)');
     return 1;
   }
 
@@ -908,17 +985,22 @@ export async function refreshProject({ manifest, projectRoot = process.cwd() })
     const config = readProjectConfig(projectRoot);
     const packs = enabledPacks(config);
     const skills = enabledSkillEntries(config).map(([skill]) => skill);
+    const base = baseSkillsEnabled(config);
 
-    if (packs.length === 0 && skills.length === 0) {
+    if (!base && packs.length === 0 && skills.length === 0) {
       throw new Error('No enabled packs or skills in .agents/project.json');
     }
 
+    if (base) {
+      installBaseSkills(projectRoot, manifest, config);
+    }
     for (const pack of packs) {
       installPack(projectRoot, manifest, pack);
     }
     for (const skill of skills) {
       installSingleSkill(projectRoot, manifest, skill);
     }
+    console.log(`Refreshed project skills to ${manifestPackageLabel(manifest)}.`);
     printSessionReloadNotice();
     return 0;
   });

package/src/cli/pack-normalization.mjs

@@ -7,11 +7,11 @@ const HIBERNATED_REACTIVATION_TEXT =
 const PACK_ALIAS_GROUPS = [
   {
     aliases: ['business', 'business_app', 'businessapp', 'product', 'saas', 'business-app'],
-    packs: ['business-discovery', 'customer-lifecycle', 'business-growth', 'business-ops']
+    packs: ['business-research', 'customer-lifecycle', 'business-growth', 'business-ops']
   },
   {
-    aliases: ['business-discovery', 'discovery', 'customer-discovery', 'customer_discovery'],
-    packs: ['business-discovery']
+    aliases: ['business-research', 'business-discovery', 'discovery', 'research'],
+    packs: ['business-research']
   },
   {
     aliases: [
@@ -320,6 +320,56 @@ function activePackNames(manifest) {
     .sort((a, b) => a.localeCompare(b));
 }
 
+function normalizePackTitle(title) {
+  return String(title || '').trim().replace(/\s+/g, ' ').toLowerCase();
+}
+
+function activePackTitleMap(manifest) {
+  const map = new Map();
+
+  for (const pack of manifest.packs || []) {
+    if (!pack.name || (pack.status !== undefined && pack.status !== 'active')) {
+      continue;
+    }
+
+    const title = normalizePackTitle(pack.title);
+    if (!title || map.has(title)) {
+      continue;
+    }
+    map.set(title, pack.name);
+  }
+
+  return map;
+}
+
+function packTitleToken(raw, activePackTitles) {
+  let token = String(raw).trim().replace(/,$/, '');
+  if (token.startsWith('pack:')) {
+    token = token.slice('pack:'.length);
+  }
+  if (!token || token === 'pack' || token === 'packs') {
+    return null;
+  }
+
+  const title = token.replace(/\s+/g, ' ').trim();
+  return activePackTitles.has(normalizePackTitle(title)) ? title : null;
+}
+
+function tokenizeInstallArgs(args, activePackTitles) {
+  const tokens = [];
+
+  for (const raw of args) {
+    const titleToken = packTitleToken(raw, activePackTitles);
+    if (titleToken) {
+      tokens.push(titleToken);
+      continue;
+    }
+    tokens.push(...tokenizePackArgs([raw]));
+  }
+
+  return tokens;
+}
+
 function availablePacksInline(manifest) {
   const names = activePackNames(manifest);
   if (names.length === 0) {
@@ -350,6 +400,33 @@ function skillPackMap(manifest) {
   return map;
 }
 
+function fuzzyMatchSkills(token, skillPacks) {
+  const suffix = [];
+  const prefix = [];
+  const substring = [];
+
+  for (const [skill, pack] of skillPacks) {
+    if (skill === token) continue;
+    if (skill.endsWith(`-${token}`)) {
+      suffix.push({ skill, pack });
+    } else if (skill.startsWith(`${token}-`)) {
+      prefix.push({ skill, pack });
+    } else if (skill.includes(token)) {
+      substring.push({ skill, pack });
+    }
+  }
+
+  if (suffix.length > 0) return suffix;
+  if (prefix.length > 0) return prefix;
+  if (substring.length > 0) return substring;
+  return [];
+}
+
+function fuzzyMatchError(token, matches) {
+  const lines = matches.map((m) => `  ${m.skill} (${m.pack})`).join('\n');
+  return new Error(`Ambiguous skill name '${token}'. Did you mean:\n${lines}`);
+}
+
 function enabledSkillPackMap(projectRoot) {
   const config = readProjectConfig(projectRoot);
   if (!config?.enabled_skills || typeof config.enabled_skills !== 'object') {
@@ -363,7 +440,7 @@ function allPacksExist(packs, activePacks) {
 }
 
 function unknownNameError(token, manifest) {
-  return new Error(`Unknown pack or skill '${token}'. Available packs: ${availablePacksInline(manifest)}`);
+  return new Error(`Unknown pack or skill '${token}'. Available packs: ${availablePacksInline(manifest)}\nRun 'npx skillpacks list' to see all available skills.`);
 }
 
 function hibernatedPackError(requested, pack) {
@@ -391,22 +468,27 @@ function hibernatedSkillError(skill, packs) {
 }
 
 function resolveInstallToken(token, context) {
-  const hibernatedPack = canonicalHibernatedPack(token);
-  if (hibernatedPack) {
-    throw hibernatedPackError(token, hibernatedPack);
+  if (context.skillPacks.has(token)) {
+    context.skills.push(token);
+    return;
   }
 
-  const normalizedPacks = normalizePack(token);
-  if (allPacksExist(normalizedPacks, context.activePacks)) {
-    context.packs.push(...normalizedPacks);
+  if (context.activePacks.has(token)) {
+    context.packs.push(token);
     return;
   }
 
-  if (context.skillPacks.has(token)) {
-    context.skills.push(token);
+  const titlePack = context.activePackTitles.get(normalizePackTitle(token));
+  if (titlePack) {
+    context.packs.push(titlePack);
     return;
   }
 
+  const hibernatedPack = canonicalHibernatedPack(token);
+  if (hibernatedPack) {
+    throw hibernatedPackError(token, hibernatedPack);
+  }
+
   const hibernatedSkillPacks = hibernatedPacksForSkill(token);
   if (hibernatedSkillPacks.length > 0) {
     throw hibernatedSkillError(token, hibernatedSkillPacks);
@@ -444,6 +526,16 @@ function resolveRemoveToken(token, context) {
     return;
   }
 
+  const fuzzyMatches = fuzzyMatchSkills(token, context.skillPacks);
+  if (fuzzyMatches.length === 1) {
+    console.error(`Resolved '${token}' → '${fuzzyMatches[0].skill}'`);
+    context.skills.push(fuzzyMatches[0].skill);
+    return;
+  }
+  if (fuzzyMatches.length > 1) {
+    throw fuzzyMatchError(token, fuzzyMatches);
+  }
+
   throw unknownNameError(token, context.manifest);
 }
 
@@ -458,6 +550,7 @@ export function resolvePackCommandArgs(command, args, options) {
   const context = {
     manifest: options.manifest,
     activePacks: new Set(activePackNames(options.manifest)),
+    activePackTitles: activePackTitleMap(options.manifest),
     skillPacks: skillPackMap(options.manifest),
     enabledSkillPacks: command === 'remove'
       ? enabledSkillPackMap(options.projectRoot || process.cwd())
@@ -466,7 +559,9 @@ export function resolvePackCommandArgs(command, args, options) {
     skills: []
   };
 
-  const tokens = tokenizePackArgs(args);
+  const tokens = command === 'install'
+    ? tokenizeInstallArgs(args, context.activePackTitles)
+    : tokenizePackArgs(args);
   for (const token of tokens) {
     if (command === 'install') {
       resolveInstallToken(token, context);

package/src/cli/run-pack-script.mjs

@@ -11,6 +11,7 @@ import {
 import { resolvePackCommandArgs } from './pack-normalization.mjs';
 import {
   doctorProject,
+  initProject,
   installResolved,
   pinSkill,
   pruneProject,
@@ -175,6 +176,7 @@ Commands:
   recommend                    Recommend packs from repository signals
   install <name...>            Enable packs or individual skills
   install-deck <deck> [--full] Enable packs selected by deck metadata
+  init                         Install base skills into this project
   remove <name...>             Remove packs or individual skills
   refresh                      Recreate local skill roots from project config
   doctor                       Report skill-install drift
@@ -249,6 +251,16 @@ export async function runSkillpacksCli(args) {
     return runCommand('bash', [packScriptPath, 'install', ...deckInstall.packs]);
   }
 
+  if (command === 'init') {
+    if (rest.length > 0) {
+      throw new Error('init does not accept arguments');
+    }
+    return initProject({
+      manifest: readManifest(),
+      projectRoot: process.cwd()
+    });
+  }
+
   if (!PACK_COMMANDS.has(command)) {
     usage();
     throw new Error(`unknown command '${command}'`);

package/src/cli/update-check.mjs

@@ -0,0 +1,77 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readFile, writeFile } from 'node:fs/promises';
+
+const CACHE_PATH = join(homedir(), '.skillpacks-update-check.json');
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const REGISTRY_URL = 'https://registry.npmjs.org/skillpacks/latest';
+
+async function fetchLatestVersion() {
+  const res = await fetch(REGISTRY_URL, {
+    headers: { accept: 'application/json' },
+    signal: AbortSignal.timeout(5000),
+  });
+  if (!res.ok) return null;
+  const data = await res.json();
+  return data.version || null;
+}
+
+async function readCache() {
+  try {
+    const raw = await readFile(CACHE_PATH, 'utf8');
+    const cache = JSON.parse(raw);
+    if (Date.now() - cache.checkedAt < CACHE_TTL_MS) {
+      return cache.latestVersion;
+    }
+  } catch {}
+  return null;
+}
+
+async function writeCache(latestVersion) {
+  try {
+    await writeFile(CACHE_PATH, JSON.stringify({ latestVersion, checkedAt: Date.now() }));
+  } catch {}
+}
+
+export function startUpdateCheck() {
+  return (async () => {
+    const cached = await readCache();
+    if (cached) return cached;
+    const latest = await fetchLatestVersion();
+    if (latest) await writeCache(latest);
+    return latest;
+  })().catch(() => null);
+}
+
+function compareVersions(a, b) {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const na = pa[i] || 0;
+    const nb = pb[i] || 0;
+    if (na < nb) return -1;
+    if (na > nb) return 1;
+  }
+  return 0;
+}
+
+export async function printUpdateNotice(checkPromise, currentVersion) {
+  try {
+    const latest = await checkPromise;
+    if (!latest || !currentVersion) return;
+    if (compareVersions(currentVersion, latest) >= 0) return;
+
+    const msg = `  Update available: ${currentVersion} → ${latest}`;
+    const run = '  Run: npx skillpacks@latest';
+    const width = Math.max(msg.length, run.length) + 2;
+    const pad = (s) => s + ' '.repeat(width - s.length);
+    const border = '─'.repeat(width);
+
+    process.stderr.write(
+      `\n╭${border}╮\n` +
+      `│${pad(msg)}│\n` +
+      `│${pad(run)}│\n` +
+      `╰${border}╯\n`
+    );
+  } catch {}
+}