npm - skillpacks - Versions diffs - 0.1.0 → 0.1.2 - Mend

skillpacks 0.1.0 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2094) hide show

package/scripts/audit-alignment-pages.mjs ADDED Viewed

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+// Read-only convention audit for active alignment/*.html pages, so direct
+// edits made without invoking a skill can be checked against
+// docs/alignment-page-convention.md. Archived pages under
+// docs/history/archive/ are out of scope. No write/fix mode: diagnostics
+// point at scripts/inject-tts.mjs or manual fixes.
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const argv = process.argv.slice(2);
+let rootOverride = null;
+for (let i = 0; i < argv.length; i += 1) {
+  if (argv[i] === "--root") {
+    rootOverride = argv[i + 1];
+    i += 1;
+    if (!rootOverride) {
+      console.error("--root requires a path argument");
+      process.exit(1);
+    }
+  }
+}
+const repoRoot = rootOverride ? resolve(rootOverride) : dirname(dirname(fileURLToPath(import.meta.url)));
+const alignmentDir = `${repoRoot}/alignment`;
+const CATEGORIES = new Set(["research", "product-design", "utility", "qa-meta", "ops-analysis"]);
+const TIERS = new Set(["document", "visual", "prototype"]);
+const KOKORO_TAG_RE = /<script\b[^>]*\bsrc="[^"]*alignment-tts-kokoro\.js"[^>]*><\/script>/;
+const INLINE_TTS_RE = /alignTTS|\/\/ --- Brief Me TTS ---/;
+const DATE_RE = /\b\d{4}-\d{2}-\d{2}\b/;
+const pages = existsSync(alignmentDir)
+  ? readdirSync(alignmentDir).filter((f) => f.endsWith(".html")).sort()
+  : [];
+// index.html is the central index, not an alignment page: it is exempt from
+// the per-page TTS and metadata checks but still held to viewport/embed rules.
+const activePages = pages.filter((f) => f !== "index.html");
+const ttsDiagnostics = [];
+const metadataDiagnostics = [];
+const viewportDiagnostics = [];
+const embedDiagnostics = [];
+const indexDiagnostics = [];
+function checkAttribute(htmlTag, rel, attribute, allowed) {
+  const match = htmlTag.match(new RegExp(`\\b${attribute}="([^"]*)"`));
+  if (!match) {
+    metadataDiagnostics.push(
+      `Missing ${attribute} on <html> in ${rel} — set one of: ${[...allowed].join(", ")}.`,
+    );
+  } else if (!allowed.has(match[1])) {
+    metadataDiagnostics.push(
+      `Invalid ${attribute} "${match[1]}" in ${rel} — must be one of: ${[...allowed].join(", ")}.`,
+    );
+  }
+}
+for (const file of pages) {
+  const rel = `alignment/${file}`;
+  const html = readFileSync(`${alignmentDir}/${file}`, "utf8");
+  if (!/<meta[^>]*\bname=["']viewport["']/.test(html)) {
+    viewportDiagnostics.push(
+      `Missing viewport meta in ${rel} — add <meta name="viewport" content="width=device-width, initial-scale=1"> to the head.`,
+    );
+  }
+  const embedTags = new Set();
+  for (const match of html.matchAll(/<(object|iframe|embed)\b/gi)) {
+    embedTags.add(`<${match[1].toLowerCase()}>`);
+  }
+  if (embedTags.size) {
+    embedDiagnostics.push(
+      `Embedded content in ${rel} — uses ${[...embedTags].sort().join(", ")}; the embed prohibition requires rendering content directly in the page.`,
+    );
+  }
+  if (file === "index.html") continue;
+  const kokoroTag = html.match(KOKORO_TAG_RE);
+  if (!kokoroTag) {
+    if (INLINE_TTS_RE.test(html)) {
+      ttsDiagnostics.push(
+        `Inline TTS in ${rel} — the Brief Me script must be the src tag, never inlined. Run node scripts/inject-tts.mjs --force ${rel} to replace it.`,
+      );
+    } else {
+      ttsDiagnostics.push(
+        `Missing TTS include in ${rel} — every alignment page needs <script src="../scripts/alignment-tts-kokoro.js"></script> before </body>. Run node scripts/inject-tts.mjs ${rel} to add it.`,
+      );
+    }
+  } else if (/\btype="module"/.test(kokoroTag[0])) {
+    ttsDiagnostics.push(
+      `Module TTS tag in ${rel} — type="module" scripts are blocked by CORS on file:// URLs. Run node scripts/inject-tts.mjs --force ${rel} to replace it.`,
+    );
+  } else if (INLINE_TTS_RE.test(html)) {
+    ttsDiagnostics.push(
+      `Leftover inline TTS in ${rel} beside the src tag. Run node scripts/inject-tts.mjs --force ${rel} to clean it up.`,
+    );
+  }
+  const htmlTag = html.match(/<html\b[^>]*>/);
+  if (!htmlTag) {
+    metadataDiagnostics.push(`Missing <html> element in ${rel} — cannot carry the required data attributes.`);
+  } else {
+    checkAttribute(htmlTag[0], rel, "data-alignment-category", CATEGORIES);
+    checkAttribute(htmlTag[0], rel, "data-visual-tier", TIERS);
+  }
+}
+// Index integrity: the central index must exist when active pages do, link
+// every active page exactly once (no duplicates, no dangling entries), and
+// every entry must carry a YYYY-MM-DD meta date near its link. The date is
+// searched between the entry's anchor and the entry boundary (the closing
+// </article> for card layouts, otherwise the next entry's anchor).
+let indexEntries = 0;
+const indexPath = `${alignmentDir}/index.html`;
+if (!existsSync(indexPath)) {
+  if (activePages.length) {
+    indexDiagnostics.push(
+      "Missing central index alignment/index.html — create it with a dated entry for every active alignment page.",
+    );
+  }
+} else {
+  const html = readFileSync(indexPath, "utf8");
+  const entries = [];
+  for (const match of html.matchAll(/<a\s[^>]*\bhref="([^"]+\.html)"[^>]*>/g)) {
+    const href = match[1];
+    if (/^[a-z][a-z0-9+.-]*:/i.test(href)) continue; // external links are not entries
+    const name = href.split("/").pop();
+    if (name === "index.html") continue;
+    entries.push({ name, pos: match.index });
+  }
+  const linkCounts = new Map();
+  for (const { name } of entries) linkCounts.set(name, (linkCounts.get(name) ?? 0) + 1);
+  indexEntries = linkCounts.size;
+  const activeSet = new Set(activePages);
+  for (const [name, count] of linkCounts) {
+    if (count > 1) {
+      indexDiagnostics.push(
+        `Duplicate index entry for alignment/${name} — linked ${count} times in alignment/index.html; keep one entry.`,
+      );
+    }
+    if (!activeSet.has(name)) {
+      indexDiagnostics.push(
+        `Dangling index entry alignment/${name} — page does not exist; remove the entry from alignment/index.html.`,
+      );
+    }
+  }
+  for (const page of activePages) {
+    if (!linkCounts.has(page)) {
+      indexDiagnostics.push(
+        `Unlinked page alignment/${page} — add a dated entry to alignment/index.html.`,
+      );
+    }
+  }
+  const undated = new Set();
+  for (let i = 0; i < entries.length; i += 1) {
+    const { name, pos } = entries[i];
+    if (undated.has(name)) continue;
+    const nextAnchor = entries[i + 1]?.pos ?? html.length;
+    const articleClose = html.indexOf("</article>", pos);
+    const end = articleClose === -1 ? nextAnchor : Math.min(nextAnchor, articleClose);
+    if (!DATE_RE.test(html.slice(pos, end))) {
+      undated.add(name);
+      indexDiagnostics.push(
+        `Undated index entry for alignment/${name} — add a YYYY-MM-DD meta date span after the link (e.g. <span class="meta">2026-06-09</span>).`,
+      );
+    }
+  }
+}
+console.log(`Active pages: ${activePages.length}`);
+console.log(`TTS include: ${activePages.length} pages, ${ttsDiagnostics.length ? "DRIFT" : "exact"}`);
+console.log(`Page metadata: ${activePages.length} pages, ${metadataDiagnostics.length ? "DRIFT" : "exact"}`);
+console.log(`Viewport meta: ${pages.length} pages, ${viewportDiagnostics.length ? "DRIFT" : "exact"}`);
+console.log(`Embed prohibition: ${pages.length} pages, ${embedDiagnostics.length ? "DRIFT" : "exact"}`);
+console.log(`Index integrity: ${indexEntries} entries, ${indexDiagnostics.length ? "DRIFT" : "exact"}`);
+const groups = [
+  ["TTS include drift:", ttsDiagnostics],
+  ["Page metadata drift:", metadataDiagnostics],
+  ["Viewport drift:", viewportDiagnostics],
+  ["Embed prohibition drift:", embedDiagnostics],
+  ["Index integrity drift:", indexDiagnostics],
+];
+let failed = false;
+for (const [title, diagnostics] of groups) {
+  if (!diagnostics.length) continue;
+  failed = true;
+  console.error("");
+  console.error(title);
+  for (const diagnostic of diagnostics) console.error(`  - ${diagnostic}`);
+}
+if (failed) process.exit(1);

package/scripts/inject-tts.mjs ADDED Viewed

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * Injects the alignment TTS module tag into existing alignment HTML pages.
+ * Idempotent — skips pages that already have the Kokoro TTS module.
+ *
+ * Usage: node scripts/inject-tts.mjs [--root <path>] [--dry-run] [--force] [alignment/specific-page.html]
+ *        Default: processes all alignment/*.html except index.html
+ *
+ * --force: replaces any existing TTS code (old inline IIFE or prior module tag)
+ */
+import { readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const argv = process.argv.slice(2);
+let rootOverride = null;
+const passthroughArgs = [];
+for (let i = 0; i < argv.length; i += 1) {
+  if (argv[i] === '--root') {
+    rootOverride = argv[i + 1];
+    i += 1;
+    if (!rootOverride) {
+      console.error('--root requires a path argument');
+      process.exit(1);
+    }
+    continue;
+  }
+  passthroughArgs.push(argv[i]);
+}
+const ROOT = rootOverride ? path.resolve(rootOverride) : path.resolve(__dirname, '..');
+const ALIGNMENT_DIR = path.join(ROOT, 'alignment');
+const dryRun = passthroughArgs.includes('--dry-run');
+const force = passthroughArgs.includes('--force');
+const specificFile = passthroughArgs.find(a => a.endsWith('.html'));
+const KOKORO_TAG = '<script src="../scripts/alignment-tts-kokoro.js"></script>';
+const scriptBlock = `\n${KOKORO_TAG}`;
+function stripOldTTS(html) {
+  // Remove old inline IIFE TTS block
+  const marker = '// --- Brief Me TTS ---';
+  const markerIdx = html.indexOf(marker);
+  if (markerIdx !== -1) {
+    const scriptStart = html.lastIndexOf('<script>', markerIdx);
+    const scriptEnd = html.indexOf('</script>', markerIdx);
+    if (scriptStart !== -1 && scriptEnd !== -1) {
+      html = html.slice(0, scriptStart) + html.slice(scriptEnd + '</script>'.length);
+    }
+  }
+  // Remove old Kokoro module tag if present
+  const kokoroTagRe = /<script[^>]*src="[^"]*alignment-tts-kokoro\.js"><\/script>\s*/g;
+  html = html.replace(kokoroTagRe, '');
+  return html;
+}
+function inject(filePath) {
+  const rel = path.relative(ROOT, filePath);
+  let html = readFileSync(filePath, 'utf8');
+  const hasKokoro = html.includes('alignment-tts-kokoro.js');
+  const hasOldTTS = html.includes('alignTTS');
+  if (hasKokoro && !force) {
+    console.log(`  skip (already has Kokoro TTS): ${rel}`);
+    return false;
+  }
+  if ((hasKokoro || hasOldTTS) && force) {
+    html = stripOldTTS(html);
+  } else if (hasOldTTS && !force) {
+    console.log(`  skip (has old TTS, use --force to replace): ${rel}`);
+    return false;
+  }
+  const insertPoint = html.lastIndexOf('</body>');
+  if (insertPoint === -1) {
+    console.log(`  skip (no </body>): ${rel}`);
+    return false;
+  }
+  html = html.slice(0, insertPoint) + scriptBlock + '\n' + html.slice(insertPoint);
+  if (dryRun) {
+    console.log(`  would inject: ${rel}`);
+  } else {
+    writeFileSync(filePath, html, 'utf8');
+    console.log(`  injected: ${rel}`);
+  }
+  return true;
+}
+let files;
+if (specificFile) {
+  const full = path.resolve(ROOT, specificFile);
+  files = [full];
+} else {
+  files = readdirSync(ALIGNMENT_DIR)
+    .filter(f => f.endsWith('.html') && f !== 'index.html')
+    .map(f => path.join(ALIGNMENT_DIR, f));
+}
+console.log(`${dryRun ? '[DRY RUN] ' : ''}Injecting Kokoro TTS into ${files.length} alignment page(s)...`);
+let count = 0;
+for (const f of files) {
+  if (inject(f)) count++;
+}
+console.log(`Done. ${dryRun ? 'Would inject' : 'Injected'}: ${count}, Skipped: ${files.length - count}`);

package/scripts/pack.sh CHANGED Viewed

@@ -207,12 +207,12 @@ normalize_pack() {
   pack="${pack#pack:}"
   case "$pack" in
     business|business_app|businessapp|product|saas|business-app)
-      echo "business-discovery"
+      echo "business-research"
       echo "customer-lifecycle"
       echo "business-growth"
       echo "business-ops"
       ;;
-    business-discovery|discovery|customer-discovery|customer_discovery) echo "business-discovery" ;;
+    business-research|business-discovery|discovery|research) echo "business-research" ;;
     customer-lifecycle|customer_lifecycle|lifecycle|journey|customer-journey|customer_journey|user-journey|user_journey|onboarding|conversion|transactions|transaction) echo "customer-lifecycle" ;;
     business-growth|growth|gtm-growth|gtm_growth) echo "business-growth" ;;
     business-ops|business_ops|ops|business-operations|business_operations) echo "business-ops" ;;
@@ -271,7 +271,7 @@ collect_pack_args() {
 project_type_for_pack() {
   case "$1" in
-    business-discovery|customer-lifecycle|business-growth|business-ops|business-app) echo "business-app" ;;
+    business-research|customer-lifecycle|business-growth|business-ops|business-app) echo "business-app" ;;
     game) echo "game" ;;
     devtool) echo "devtool" ;;
     creator-foundation|youtube-ops|creator-media|remotion) echo "creator-media" ;;
@@ -715,12 +715,12 @@ recommend() {
     echo "PoketoWork kanban packs are hibernated during the Poketo.work rebuild."
   elif [[ "$inferred_project_type" == "devtool" ]]; then
     echo "Recommended pack: devtool or a narrow business pack"
-    echo "Use devtool for developer-facing tools/libraries; use business-discovery, customer-lifecycle, business-growth, or business-ops for SaaS/business work."
+    echo "Use devtool for developer-facing tools/libraries; use business-research, customer-lifecycle, business-growth, or business-ops for SaaS/business work."
     echo "For a quick OSS experiment (ship in days, not weeks), use ord instead."
     echo "PoketoWork kanban packs are hibernated during the Poketo.work rebuild."
     echo "For behavior-preserving refactors and code-health workflows, also install code-quality."
   else
-    echo "Recommended pack: business-discovery"
+    echo "Recommended pack: business-research"
     echo "Add customer-lifecycle when the current phase needs journey, onboarding, conversion, transaction, retention, expansion, or lifecycle metrics work."
     echo "Add business-growth or business-ops only when the current phase needs them."
     echo "For a quick viral app experiment (ship in days, not weeks), use vard instead."
@@ -742,6 +742,36 @@ find_pack_for_skill() {
       fi
     done
   done
+  # Fuzzy suffix pass: look for *-$skill directories
+  local fuzzy_matches=()
+  local fuzzy_packs=()
+  for pack_dir in "$PACKS_DIR"/*/; do
+    [[ -d "$pack_dir" ]] || continue
+    pack="$(basename "$pack_dir")"
+    for tool in claude codex; do
+      for skill_dir in "$PACKS_DIR/$pack/$tool"/*-"$skill"/; do
+        [[ -d "$skill_dir" ]] || continue
+        local matched_skill
+        matched_skill="$(basename "$skill_dir")"
+        fuzzy_matches+=("$matched_skill")
+        fuzzy_packs+=("$pack")
+      done
+    done
+  done
+  if [[ ${#fuzzy_matches[@]} -eq 1 ]]; then
+    echo "Resolved '$skill' → '${fuzzy_matches[0]}' (${fuzzy_packs[0]})" >&2
+    echo "${fuzzy_packs[0]}"
+    return 0
+  elif [[ ${#fuzzy_matches[@]} -gt 1 ]]; then
+    echo "Ambiguous skill name '$skill'. Did you mean:" >&2
+    for i in "${!fuzzy_matches[@]}"; do
+      echo "  ${fuzzy_matches[$i]} (${fuzzy_packs[$i]})" >&2
+    done
+    return 1
+  fi
   return 1
 }
@@ -871,6 +901,12 @@ doctor() {
   local found=false any_stale=false
   local target line status rec cur rel
+  local refresh_cmd
+  if [[ -d "$REPO_ROOT/.git" ]]; then
+    refresh_cmd="$REPO_ROOT/scripts/pack.sh refresh"   # absolute → works from any cwd
+  else
+    refresh_cmd="npx skillpacks refresh"               # npx-bundle case (no checkout)
+  fi
   while IFS= read -r target; do
     [[ -n "$target" ]] || continue
     line="$(skill_install_status "$target")"
@@ -881,7 +917,7 @@ doctor() {
     case "$status" in
       ok)             printf '  ok       %s\n' "$rel" ;;
       pinned)         printf '  pinned   %s (frozen %s)\n' "$rel" "${rec:-?}" ;;
-      unknown)        printf '  unknown  %s — run refresh to enable drift tracking\n' "$rel" ;;
+      unknown)        printf '  unknown  %s — run `%s` to enable drift tracking\n' "$rel" "$refresh_cmd" ;;
       missing-source) printf '  missing  %s — canonical source no longer exists\n' "$rel" ;;
       stale)          printf '  STALE    %s (%s -> %s)\n' "$rel" "${rec:-?}" "${cur:-?}"; any_stale=true ;;
     esac
@@ -893,7 +929,7 @@ doctor() {
   if [[ "$any_stale" == true ]]; then
     echo ""
-    echo "Fix: scripts/pack.sh refresh"
+    echo "Fix: $refresh_cmd"
     return 1
   fi
   return 0

package/scripts/prepublish-auth-check.mjs ADDED Viewed

@@ -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/scripts/skill-links.sh CHANGED Viewed

@@ -5,10 +5,10 @@ SKILL_LINK_MARKER=".agentic-skills-managed"
 skill_source_owned_by_repo() {
   local source="$1"
   local repo_root="${REPO_ROOT:-${SCRIPT_DIR:-}}"
-  local global_root="${SCRIPT_DIR:-$repo_root}"
+  local base_root="${SCRIPT_DIR:-$repo_root}"
   [[ -n "$repo_root" ]] || return 1
   case "$source" in
-    "$global_root/global/claude/"*|"$global_root/global/codex/"*|"$repo_root/packs/"*)
+    "$base_root/base/claude/"*|"$base_root/base/codex/"*|"$repo_root/packs/"*)
       return 0
       ;;
     *)