skillpacks 0.1.1 → 0.1.2

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

@@ -1,5 +1,5 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
@@ -17,6 +17,7 @@ import {
   pruneProject,
   refreshProject,
   removeResolved,
+  uninstallGlobal,
   unpinSkill
 } from './lifecycle.mjs';
 
@@ -25,8 +26,11 @@ const packageRoot = resolve(moduleDir, '..', '..');
 const checkoutRoot = resolve(packageRoot, '..', '..');
 const packageJsonPath = join(packageRoot, 'package.json');
 const packScriptPath = resolvePackagedPath('scripts/pack.sh');
-const initScriptPath = resolvePackagedPath('init.sh');
 const manifestPath = resolvePackagedPath('dist/skillpacks-manifest.json');
+const alignmentUpgradeScriptPath = resolvePackagedPath('scripts/upgrade-alignment-page.mjs');
+const alignmentAuditScriptPath = resolvePackagedPath('scripts/audit-alignment-pages.mjs');
+const alignmentInjectTtsScriptPath = resolvePackagedPath('scripts/inject-tts.mjs');
+const alignmentTtsAssetPath = resolvePackagedPath('scripts/alignment-tts-kokoro.js');
 
 function resolvePackagedPath(relativePath) {
   const packagedPath = join(packageRoot, relativePath);
@@ -112,6 +116,184 @@ function runCommand(command, args, options = {}) {
   });
 }
 
+function assertNoArgs(command, args) {
+  if (args.length > 0) {
+    throw new Error(`${command} does not accept arguments`);
+  }
+}
+
+function ensureAlignmentTtsAsset(projectRoot) {
+  if (!existsSync(alignmentTtsAssetPath)) {
+    throw new Error(
+      `alignment TTS asset not found at ${alignmentTtsAssetPath}. Reinstall skillpacks or use a source checkout that includes scripts/alignment-tts-kokoro.js.`
+    );
+  }
+
+  const target = join(projectRoot, 'scripts/alignment-tts-kokoro.js');
+  if (existsSync(target)) {
+    return;
+  }
+
+  mkdirSync(dirname(target), { recursive: true });
+  copyFileSync(alignmentTtsAssetPath, target);
+  console.log('Installed scripts/alignment-tts-kokoro.js for alignment page TTS.');
+}
+
+function alignmentHelp() {
+  console.log(`gskp alignment
+
+Usage:
+  gskp alignment bundles [--dry-run] [--check]
+  gskp alignment pages audit
+  gskp alignment pages inject-tts [--force] [--dry-run] [alignment/<page>.html]
+  gskp alignment verify
+
+Commands:
+  bundles                    Generate per-skill ALIGNMENT-PAGE.md bundles
+  bundles --dry-run          Preview generated bundle changes
+  bundles --check            Fail on generated-bundle drift without writing
+  pages audit                Audit active rendered alignment/*.html pages
+  pages inject-tts           Add the packaged Brief Me TTS script tag to pages
+  verify                     Run the focused alignment verification set when present`);
+}
+
+function validateArgs(command, args, options) {
+  const { allowedFlags = new Set(), maxPositionals = 0, positionalPattern = null } = options;
+  let positionals = 0;
+
+  for (const arg of args) {
+    if (arg.startsWith('-')) {
+      if (!allowedFlags.has(arg)) {
+        throw new Error(`${command}: unsupported flag '${arg}'`);
+      }
+      continue;
+    }
+
+    positionals += 1;
+    if (positionals > maxPositionals) {
+      throw new Error(`${command}: unexpected argument '${arg}'`);
+    }
+    if (positionalPattern && !positionalPattern.test(arg)) {
+      throw new Error(`${command}: expected an alignment HTML page path, got '${arg}'`);
+    }
+  }
+}
+
+export function resolveAlignmentCommand(args, options = {}) {
+  const projectRoot = resolve(options.projectRoot || process.cwd());
+  const [scope, ...rest] = args;
+
+  if (!scope || scope === 'help' || scope === '--help' || scope === '-h') {
+    return { kind: 'help' };
+  }
+
+  if (scope === 'bundles') {
+    validateArgs('alignment bundles', rest, {
+      allowedFlags: new Set(['--dry-run', '--check'])
+    });
+    if (rest.includes('--dry-run') && rest.includes('--check')) {
+      throw new Error('alignment bundles accepts either --dry-run or --check, not both');
+    }
+    return {
+      kind: 'run',
+      command: process.execPath,
+      args: [alignmentUpgradeScriptPath, '--root', projectRoot, ...rest]
+    };
+  }
+
+  if (scope === 'pages') {
+    const [pagesCommand, ...pagesRest] = rest;
+    if (!pagesCommand || pagesCommand === 'help' || pagesCommand === '--help' || pagesCommand === '-h') {
+      return { kind: 'help' };
+    }
+
+    if (pagesCommand === 'audit') {
+      assertNoArgs('alignment pages audit', pagesRest);
+      return {
+        kind: 'run',
+        command: process.execPath,
+        args: [alignmentAuditScriptPath, '--root', projectRoot]
+      };
+    }
+
+    if (pagesCommand === 'inject-tts') {
+      validateArgs('alignment pages inject-tts', pagesRest, {
+        allowedFlags: new Set(['--force', '--dry-run']),
+        maxPositionals: 1,
+        positionalPattern: /^alignment\/[^/].*\.html$/
+      });
+      return {
+        kind: 'run',
+        command: process.execPath,
+        args: [alignmentInjectTtsScriptPath, '--root', projectRoot, ...pagesRest],
+        ensureTtsAsset: !pagesRest.includes('--dry-run')
+      };
+    }
+
+    throw new Error(`alignment pages: unknown command '${pagesCommand}'`);
+  }
+
+  if (scope === 'verify') {
+    assertNoArgs('alignment verify', rest);
+    return {
+      kind: 'verify',
+      projectRoot,
+      command: 'pnpm',
+      args: [
+        '--dir',
+        'tests',
+        'exec',
+        'vitest',
+        'run',
+        '--project',
+        'layer1',
+        'layer1/upgrade-alignment-page-bespoke.test.ts',
+        'layer1/audit-alignment-pages.test.ts',
+        'layer1/alignment-gates.test.ts',
+        'layer1/alignment-tts-kokoro.test.ts'
+      ]
+    };
+  }
+
+  throw new Error(`alignment: unknown command '${scope}'`);
+}
+
+function targetHasAlignmentVerifyTests(projectRoot) {
+  const required = [
+    'tests/package.json',
+    'tests/layer1/upgrade-alignment-page-bespoke.test.ts',
+    'tests/layer1/audit-alignment-pages.test.ts',
+    'tests/layer1/alignment-gates.test.ts',
+    'tests/layer1/alignment-tts-kokoro.test.ts'
+  ];
+  return required.every((relativePath) => existsSync(join(projectRoot, relativePath)));
+}
+
+function runAlignment(args) {
+  const resolved = resolveAlignmentCommand(args, { projectRoot: process.cwd() });
+  if (resolved.kind === 'help') {
+    alignmentHelp();
+    return 0;
+  }
+
+  if (resolved.kind === 'verify') {
+    if (!targetHasAlignmentVerifyTests(resolved.projectRoot)) {
+      console.error(
+        'alignment verify requires this repository\'s focused alignment Vitest files under tests/layer1. This target repo does not include them.'
+      );
+      return 1;
+    }
+    requireCommand('pnpm', 'Install pnpm or run the source-checkout Vitest command directly.');
+    return runCommand(resolved.command, resolved.args);
+  }
+
+  requireCommand('node', 'Install Node.js before running gskp alignment commands.');
+  if (resolved.ensureTtsAsset) {
+    ensureAlignmentTtsAsset(process.cwd());
+  }
+  return runCommand(resolved.command, resolved.args);
+}
+
 function printManifestJson(args) {
   if (args.length !== 1 || args[0] !== '--json') {
     throw new Error('list --json does not accept additional arguments');
@@ -163,10 +345,10 @@ function resolveDeckInstall(args) {
 }
 
 function usage() {
-  console.log(`skillpacks ${packageVersion()}
+  console.log(`gskp ${packageVersion()}
 
 Usage:
-  skillpacks <command> [args...]
+  gskp <command> [args...]
 
 Commands:
   list                         List available packs
@@ -177,16 +359,25 @@ Commands:
   install <name...>            Enable packs or individual skills
   install-deck <deck> [--full] Enable packs selected by deck metadata
   init                         Install base skills into this project
+  uninstall-global             Remove legacy repo-managed base skills from ~/.claude and ~/.codex
   remove <name...>             Remove packs or individual skills
   refresh                      Recreate local skill roots from project config
   doctor                       Report skill-install drift
+  doctor --fix                 Clean generated skill-root drift
+  doctor --fix --agent-docs [--dry-run]
+                               Also migrate generated AGENTS.md/CLAUDE.md blocks
+  alignment bundles [--dry-run] [--check]
+                               Generate/check per-skill ALIGNMENT-PAGE.md bundles
+  alignment pages audit        Audit active rendered alignment/*.html pages
+  alignment pages inject-tts [--force] [alignment/<page>.html]
+                               Add the packaged Brief Me TTS script include
+  alignment verify             Run focused alignment tests when present
   prune [--dry-run]            Remove orphaned managed skill installs
   set-update-mode <mode>       Set skill update mode: warn, auto, or unset
   pin <skill> <version>        Pin a skill to an archived version
   unpin <skill>                Revert a pinned skill to latest
   set-mode <mode>              Set project agent mode
   which <skill>                Show which pack provides a skill
-  init-global [args...]        Install global core skills with packaged init.sh
 
 Project-local commands write to the current working directory.`);
 }
@@ -236,14 +427,14 @@ export async function runSkillpacksCli(args) {
     return setUpdateMode(rest[0]);
   }
 
-  if (command === 'init-global') {
-    requireCommand('bash', 'Install bash before running skillpacks.');
-    return runCommand('bash', [initScriptPath, ...rest]);
+  if (command === 'uninstall-global') {
+    assertNoArgs('uninstall-global', rest);
+    return uninstallGlobal();
   }
 
   if (command === 'install-deck') {
     const deckInstall = resolveDeckInstall(rest);
-    requireCommand('bash', 'Install bash before running skillpacks.');
+    requireCommand('bash', 'Install bash before running gskp.');
     requireCommand(
       'jq',
       'Install with: brew install jq (macOS) or apt install jq (Debian/Ubuntu).'
@@ -251,6 +442,10 @@ export async function runSkillpacksCli(args) {
     return runCommand('bash', [packScriptPath, 'install', ...deckInstall.packs]);
   }
 
+  if (command === 'alignment') {
+    return runAlignment(rest);
+  }
+
   if (command === 'init') {
     if (rest.length > 0) {
       throw new Error('init does not accept arguments');
@@ -300,7 +495,9 @@ export async function runSkillpacksCli(args) {
 
   if (command === 'doctor') {
     return doctorProject({
-      projectRoot: process.cwd()
+      manifest: readManifest(),
+      projectRoot: process.cwd(),
+      args: rest
     });
   }
 
@@ -329,7 +526,7 @@ export async function runSkillpacksCli(args) {
     });
   }
 
-  requireCommand('bash', 'Install bash before running skillpacks.');
+  requireCommand('bash', 'Install bash before running gskp.');
 
   return runCommand('bash', [packScriptPath, command, ...rest]);
 }

package/global/claude/init-agentic-skills/scripts/init-agentic-skills.sh

@@ -1,227 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
-DELEGATE_SCRIPT="init.sh"
-
-resolve_repo_root() {
-  local source_tree_root
-  if source_tree_root="$(cd "$SKILL_DIR/../../.." 2>/dev/null && pwd -P)"; then
-    if [ -f "$source_tree_root/$DELEGATE_SCRIPT" ]; then
-      printf '%s\n' "$source_tree_root"
-      return 0
-    fi
-  else
-    source_tree_root="<unresolved>"
-  fi
-
-  local managed_file="$SKILL_DIR/.agentic-skills-managed"
-  local managed_source=""
-  if [ -f "$managed_file" ]; then
-    while IFS= read -r line; do
-      case "$line" in
-        source=*)
-          managed_source="${line#source=}"
-          break
-          ;;
-      esac
-    done < "$managed_file"
-  fi
-
-  local provenance_root="<unresolved>"
-  if [ -n "$managed_source" ] && [ -d "$managed_source" ]; then
-    if provenance_root="$(cd "$managed_source/../../.." 2>/dev/null && pwd -P)"; then
-      if [ -f "$provenance_root/$DELEGATE_SCRIPT" ]; then
-        printf '%s\n' "$provenance_root"
-        return 0
-      fi
-    else
-      provenance_root="<unresolved>"
-    fi
-  fi
-
-  {
-    echo "ERROR: Unable to resolve agentic-skills repository root for init-agentic-skills launcher."
-    echo "Tried source-tree candidate: $source_tree_root"
-    echo "Tried managed-install provenance: $managed_file source=${managed_source:-<missing>} -> $provenance_root"
-    echo "Expected delegated script: $DELEGATE_SCRIPT"
-  } >&2
-  return 1
-}
-
-REPO_ROOT="$(resolve_repo_root)"
-
-PREFERENCES_FILE="$HOME/.agentic-skills/preferences.json"
-SETTINGS_FILE="$HOME/.claude/settings.json"
-DRIFT_HOOK_CMD="bash $REPO_ROOT/scripts/skill-drift-hook.sh"
-
-status() {
-  echo "agentic-skills checkout: $REPO_ROOT"
-  git -C "$REPO_ROOT" rev-parse --short HEAD 2>/dev/null | sed 's/^/local commit: /' || true
-  git -C "$REPO_ROOT" remote get-url origin 2>/dev/null | sed 's/^/remote URL: /' || echo "remote URL: unavailable"
-
-  if [ -f "$PREFERENCES_FILE" ]; then
-    python3 -c 'import json, pathlib, sys
-path = pathlib.Path(sys.argv[1])
-try:
-    value = json.loads(path.read_text()).get("sync", {}).get("github_freshness_check")
-except Exception:
-    value = None
-print("github freshness preference: " + (value if value in {"ask", "always", "never"} else "unset"))' "$PREFERENCES_FILE"
-  else
-    echo "github freshness preference: unset"
-  fi
-}
-
-doctor() {
-  # shellcheck source=/dev/null
-  source "$REPO_ROOT/scripts/skill-links.sh" || { echo "ERROR: unable to load skill-links.sh" >&2; return 1; }
-  echo "Global skill install drift (~/.claude/skills, ~/.codex/skills):"
-  local found=false any_stale=false target line status rec cur
-  while IFS= read -r target; do
-    [ -n "$target" ] || continue
-    line="$(skill_install_status "$target")"
-    IFS=$'\t' read -r status rec cur <<< "$line"
-    [ "$status" = "not-managed" ] && continue
-    found=true
-    case "$status" in
-      ok)             printf '  ok       %s\n' "$target" ;;
-      pinned)         printf '  pinned   %s (frozen %s)\n' "$target" "${rec:-?}" ;;
-      unknown)        printf '  unknown  %s — rerun init to enable drift tracking\n' "$target" ;;
-      missing-source) printf '  missing  %s — canonical source no longer exists\n' "$target" ;;
-      stale)          printf '  STALE    %s (%s -> %s)\n' "$target" "${rec:-?}" "${cur:-?}"; any_stale=true ;;
-    esac
-  done < <(find "$HOME/.claude/skills" "$HOME/.codex/skills" -mindepth 1 -maxdepth 1 \( -type l -o -type d \) -print 2>/dev/null | sort)
-  $found || echo "  (no managed global skill installs found)"
-  if $any_stale; then
-    echo ""
-    echo "Fix: /init-agentic-skills update  (re-copies global skills from this checkout)"
-    return 1
-  fi
-  return 0
-}
-
-set_pref() {
-  local key="$1" val="$2" jqval
-  case "$key" in
-    session_start_hook|auto_refresh) ;;
-    *) echo "ERROR: unknown preference '$key' (use session_start_hook or auto_refresh)" >&2; return 1 ;;
-  esac
-  case "$val" in
-    true) jqval=true ;;
-    false) jqval=false ;;
-    *) echo "ERROR: value must be true or false" >&2; return 1 ;;
-  esac
-  command -v jq >/dev/null 2>&1 || { echo "ERROR: jq is required to set preferences" >&2; return 1; }
-  mkdir -p "$(dirname "$PREFERENCES_FILE")"
-  [ -f "$PREFERENCES_FILE" ] || echo '{}' > "$PREFERENCES_FILE"
-  local tmp
-  tmp="$(jq --arg k "$key" --argjson v "$jqval" '.skills = ((.skills // {}) + {($k): $v})' "$PREFERENCES_FILE")" || { echo "ERROR: jq failed updating $PREFERENCES_FILE" >&2; return 1; }
-  [ -n "$tmp" ] || { echo "ERROR: jq produced empty output for $PREFERENCES_FILE" >&2; return 1; }
-  echo "$tmp" > "$PREFERENCES_FILE"
-  echo "Set skills.$key = $val in $PREFERENCES_FILE"
-}
-
-hook_enable() {
-  command -v jq >/dev/null 2>&1 || { echo "ERROR: jq is required to register the hook" >&2; return 1; }
-  mkdir -p "$(dirname "$SETTINGS_FILE")"
-  [ -f "$SETTINGS_FILE" ] || echo '{}' > "$SETTINGS_FILE"
-  local tmp
-  tmp="$(jq --arg cmd "$DRIFT_HOOK_CMD" '
-    .hooks = (.hooks // {})
-    | .hooks.SessionStart = (.hooks.SessionStart // [])
-    | if ([.hooks.SessionStart[]?.hooks[]? | select(.command == $cmd)] | length) > 0
-      then .
-      else .hooks.SessionStart += [ { "hooks": [ { "type": "command", "command": $cmd } ] } ]
-      end
-  ' "$SETTINGS_FILE")" || { echo "ERROR: jq failed updating $SETTINGS_FILE" >&2; return 1; }
-  [ -n "$tmp" ] || { echo "ERROR: jq produced empty output for $SETTINGS_FILE" >&2; return 1; }
-  echo "$tmp" > "$SETTINGS_FILE"
-  set_pref session_start_hook true
-  echo "Registered SessionStart drift hook in $SETTINGS_FILE"
-}
-
-hook_disable() {
-  set_pref session_start_hook false
-  command -v jq >/dev/null 2>&1 || { echo "ERROR: jq is required to remove the hook" >&2; return 1; }
-  [ -f "$SETTINGS_FILE" ] || { echo "No $SETTINGS_FILE; nothing to remove."; return 0; }
-  local tmp
-  tmp="$(jq --arg cmd "$DRIFT_HOOK_CMD" '
-    if .hooks.SessionStart then
-      .hooks.SessionStart = ([ .hooks.SessionStart[]
-        | .hooks = ([ .hooks[]? | select(.command != $cmd) ])
-        | select((.hooks | length) > 0) ])
-      | if (.hooks.SessionStart | length) == 0 then del(.hooks.SessionStart) else . end
-      | if (.hooks | length) == 0 then del(.hooks) else . end
-    else . end
-  ' "$SETTINGS_FILE")" || { echo "ERROR: jq failed updating $SETTINGS_FILE" >&2; return 1; }
-  [ -n "$tmp" ] || { echo "ERROR: jq produced empty output for $SETTINGS_FILE" >&2; return 1; }
-  echo "$tmp" > "$SETTINGS_FILE"
-  echo "Removed SessionStart drift hook from $SETTINGS_FILE"
-}
-
-show_prefs() {
-  if [ -f "$PREFERENCES_FILE" ] && command -v jq >/dev/null 2>&1; then
-    echo "session_start_hook: $(jq -r '.skills.session_start_hook // false' "$PREFERENCES_FILE")"
-    echo "auto_refresh:       $(jq -r '.skills.auto_refresh // false' "$PREFERENCES_FILE")"
-  else
-    echo "session_start_hook: false"
-    echo "auto_refresh:       false"
-  fi
-}
-
-confirm_update() {
-  if [ "${1:-}" = "--yes" ] || [ "${1:-}" = "-y" ]; then
-    return 0
-  fi
-  printf "Check GitHub, fast-forward this checkout if possible, and rerun init.sh? [y/N] "
-  read -r reply
-  case "$reply" in
-    y|Y|yes|YES) return 0 ;;
-    *) echo "Update cancelled."; return 1 ;;
-  esac
-}
-
-update_latest() {
-  confirm_update "${1:-}"
-  git -C "$REPO_ROOT" fetch origin
-  git -C "$REPO_ROOT" rev-parse --short HEAD | sed 's/^/local before: /'
-  git -C "$REPO_ROOT" rev-parse --short origin/HEAD | sed 's/^/origin HEAD: /'
-  git -C "$REPO_ROOT" merge --ff-only origin/HEAD
-  bash "$REPO_ROOT/$DELEGATE_SCRIPT"
-  echo "Refresh complete."
-  echo "Claude Code: run /reload-skills first; /clear starts a new empty-context conversation and can pick up the refreshed registry. Restart Claude Code if the top-level .claude/skills directory did not exist at session start or the skill is still invisible."
-  echo 'Codex: start a fresh Codex CLI session if the $ skill list remains stale.'
-}
-
-case "${1:-}" in
-  status)
-    status
-    ;;
-  doctor)
-    doctor
-    ;;
-  update|latest)
-    mode="$1"
-    shift
-    update_latest "${1:-}"
-    ;;
-  set-pref)
-    shift
-    set_pref "${1:-}" "${2:-}"
-    ;;
-  show-prefs)
-    show_prefs
-    ;;
-  hook)
-    shift
-    case "${1:-}" in
-      enable) hook_enable ;;
-      disable) hook_disable ;;
-      *) echo "Usage: init-agentic-skills.sh hook <enable|disable>" >&2; exit 2 ;;
-    esac
-    ;;
-  *)
-    exec bash "$REPO_ROOT/$DELEGATE_SCRIPT" "$@"
-    ;;
-esac

package/global/codex/init-agentic-skills/agents/openai.yaml

@@ -1,7 +0,0 @@
-interface:
-  display_name: "Init Agentic Skills"
-  short_description: "Initialize global Claude and Codex skills from this checkout"
-  default_prompt: "Use $init-agentic-skills to run the agentic-skills initializer, refresh global managed skill installs, and explain how to enable project-local packs."
-
-policy:
-  allow_implicit_invocation: true