claude-code-superkit 0.0.0-stage → 1.5.3

package/lib/superpowers.js

@@ -0,0 +1,99 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync, rmSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { execSync } from 'node:child_process';
+import { homedir, tmpdir } from 'node:os';
+import { info, warn, commandExists } from './utils.js';
+import { confirm } from './prompts.js';
+
+const CACHE_DIR = join(homedir(), '.claude', 'plugins', 'cache', 'claude-plugins-official', 'superpowers');
+const REGISTRY_PATH = join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
+
+export async function checkAndInstallSuperpowers(useDefaults = false) {
+  if (existsSync(CACHE_DIR)) {
+    const versions = readdirSync(CACHE_DIR).sort();
+    const latest = versions[versions.length - 1] || 'unknown';
+    info(`Superpowers plugin found (v${latest})`);
+    return;
+  }
+
+  console.log('');
+  warn('Superpowers plugin is NOT installed.');
+  console.log('');
+  console.log('  Superkit depends on superpowers for: brainstorming, TDD, debugging,');
+  console.log('  writing plans, verification, code review workflows.');
+  console.log('  Without it, these features will silently fail.');
+  console.log('');
+
+  const install = await confirm('Install superpowers automatically?', true, useDefaults);
+
+  if (!install) {
+    warn('Skipping superpowers. Some features will not work.');
+    warn('To install later: open Claude Code → /plugins → search \'superpowers\'');
+    return;
+  }
+
+  if (!commandExists('git')) {
+    warn('git not found — cannot clone superpowers. Install manually via /plugins.');
+    return;
+  }
+
+  console.log('  Cloning superpowers from GitHub...');
+  const tmpDir = join(tmpdir(), `superkit-sp-${Date.now()}`);
+
+  try {
+    execSync(`git clone --depth 1 https://github.com/obra/superpowers.git "${tmpDir}/superpowers"`, {
+      stdio: 'pipe'
+    });
+
+    let version = 'latest';
+    const manifestPath = join(tmpDir, 'superpowers', '.claude-plugin', 'plugin.json');
+    if (existsSync(manifestPath)) {
+      try {
+        version = JSON.parse(readFileSync(manifestPath, 'utf8')).version || 'latest';
+      } catch { /* use 'latest' */ }
+    }
+
+    const sha = execSync('git rev-parse HEAD', {
+      cwd: join(tmpDir, 'superpowers'),
+      stdio: 'pipe'
+    }).toString().trim();
+
+    const destDir = join(CACHE_DIR, version);
+    mkdirSync(destDir, { recursive: true });
+    cpSync(join(tmpDir, 'superpowers'), destDir, { recursive: true });
+
+    mkdirSync(dirname(REGISTRY_PATH), { recursive: true });
+
+    let registry;
+    if (existsSync(REGISTRY_PATH)) {
+      try {
+        registry = JSON.parse(readFileSync(REGISTRY_PATH, 'utf8'));
+      } catch {
+        registry = { version: 2, plugins: {} };
+      }
+    } else {
+      registry = { version: 2, plugins: {} };
+    }
+
+    const now = new Date().toISOString().replace(/\.\d{3}Z$/, '.000Z');
+    registry.plugins['superpowers@claude-plugins-official'] = [{
+      scope: 'user',
+      projectPath: '',
+      installPath: destDir,
+      version,
+      installedAt: now,
+      lastUpdated: now,
+      gitCommitSha: sha
+    }];
+
+    writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2) + '\n');
+    info(`Superpowers plugin installed (v${version})`);
+  } catch (err) {
+    warn(`Failed to clone superpowers: ${err.message}`);
+    console.log('  Install manually: Open Claude Code → /plugins → search \'superpowers\'');
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+
+  console.log('');
+}

package/lib/utils.js

@@ -0,0 +1,117 @@
+import { existsSync, readdirSync, mkdirSync, copyFileSync, readFileSync, statSync } from 'node:fs';
+import { join, dirname, extname, basename } from 'node:path';
+import { execSync } from 'node:child_process';
+
+// ── Colors ──────────────────────────────────────────────
+const supportsColor = process.stdout.isTTY;
+
+const GREEN = supportsColor ? '\x1b[32m' : '';
+const YELLOW = supportsColor ? '\x1b[33m' : '';
+const RED = supportsColor ? '\x1b[31m' : '';
+const BOLD = supportsColor ? '\x1b[1m' : '';
+const NC = supportsColor ? '\x1b[0m' : '';
+
+export function info(msg) {
+  console.log(`${GREEN}✓${NC} ${msg}`);
+}
+
+export function warn(msg) {
+  console.log(`${YELLOW}⚠${NC} ${msg}`);
+}
+
+export function fail(msg) {
+  console.error(`${RED}✗${NC} ${msg}`);
+  process.exit(1);
+}
+
+export function bold(msg) {
+  return `${BOLD}${msg}${NC}`;
+}
+
+// ── File helpers ────────────────────────────────────────
+
+export function countFiles(dir, ext) {
+  if (!existsSync(dir)) return 0;
+  return readdirSync(dir).filter(f => extname(f) === ext).length;
+}
+
+export function countSkills(dir) {
+  if (!existsSync(dir)) return 0;
+  let count = 0;
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      if (existsSync(join(full, 'SKILL.md'))) count++;
+    }
+  }
+  return count;
+}
+
+export function copyFile(src, dst, mode) {
+  if (mode === 'merge' && existsSync(dst)) return false;
+  mkdirSync(dirname(dst), { recursive: true });
+  copyFileSync(src, dst);
+  return true;
+}
+
+export function copyDir(srcDir, dstDir, mode, ext, exclude = []) {
+  if (!existsSync(srcDir)) return 0;
+  mkdirSync(dstDir, { recursive: true });
+  let count = 0;
+  for (const file of readdirSync(srcDir)) {
+    const srcPath = join(srcDir, file);
+    if (!statSync(srcPath).isFile()) continue;
+    if (ext && extname(file) !== ext) continue;
+    if (exclude.includes(file)) continue;
+    if (copyFile(srcPath, join(dstDir, file), mode)) count++;
+  }
+  return count;
+}
+
+export function copySkills(srcDir, dstDir, mode) {
+  if (!existsSync(srcDir)) return 0;
+  let count = 0;
+  for (const entry of readdirSync(srcDir)) {
+    const skillDir = join(srcDir, entry);
+    if (!statSync(skillDir).isDirectory()) continue;
+    const skillFile = join(skillDir, 'SKILL.md');
+    if (!existsSync(skillFile)) continue;
+    const dstSkillDir = join(dstDir, entry);
+    mkdirSync(dstSkillDir, { recursive: true });
+    if (copyFile(skillFile, join(dstSkillDir, 'SKILL.md'), mode)) count++;
+  }
+  return count;
+}
+
+// ── Git helpers ─────────────────────────────────────────
+
+export function isInsideGitRepo() {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getGitRoot() {
+  return execSync('git rev-parse --show-toplevel', { stdio: 'pipe' }).toString().trim();
+}
+
+export function commandExists(cmd) {
+  try {
+    execSync(`command -v ${cmd}`, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getVersion() {
+  const pkgPath = join(dirname(import.meta.url.replace('file://', '')), '..', 'package.json');
+  try {
+    return JSON.parse(readFileSync(pkgPath, 'utf8')).version;
+  } catch {
+    return 'unknown';
+  }
+}

package/lib/validator.js

@@ -0,0 +1,84 @@
+import { existsSync, readFileSync, readdirSync, chmodSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { info, warn } from './utils.js';
+
+function checkGitignoreHooks(projectDir) {
+  const gitignorePath = join(projectDir, '.gitignore');
+  if (!existsSync(gitignorePath)) return true;
+
+  const content = readFileSync(gitignorePath, 'utf8');
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === '.claude/scripts/' || trimmed === '.claude/scripts' || trimmed === '.claude/scripts/*') {
+      warn('  ❌ .gitignore blocks hook scripts: "' + trimmed + '"');
+      warn('     Remove this line — hooks MUST be tracked in git.');
+      warn('     Without this, other users get NO enforcement.');
+      return false;
+    }
+  }
+  return true;
+}
+
+export function validate(claudeDir, projectDir) {
+  let ok = true;
+
+  const settingsPath = join(claudeDir, 'settings.json');
+  if (existsSync(settingsPath)) {
+    try {
+      JSON.parse(readFileSync(settingsPath, 'utf8'));
+      info('Validation: settings.json is valid JSON');
+    } catch {
+      warn('Validation: settings.json is INVALID — hooks will not work!');
+      ok = false;
+    }
+  }
+
+  if (!checkGitignoreHooks(projectDir)) {
+    ok = false;
+  }
+
+  if (process.platform !== 'win32') {
+    const hooksDir = join(claudeDir, 'scripts', 'hooks');
+    if (existsSync(hooksDir)) {
+      let nonExec = 0;
+      for (const file of readdirSync(hooksDir)) {
+        if (!file.endsWith('.sh')) continue;
+        const filePath = join(hooksDir, file);
+        try {
+          const stat = statSync(filePath);
+          if (!(stat.mode & 0o111)) {
+            chmodSync(filePath, stat.mode | 0o111);
+            nonExec++;
+          }
+        } catch { /* skip */ }
+      }
+      if (nonExec > 0) {
+        warn(`Validation: fixed ${nonExec} non-executable hooks`);
+      } else {
+        info('Validation: all hooks are executable');
+      }
+    }
+  }
+
+  if (existsSync(join(projectDir, 'CLAUDE.md'))) {
+    info('Validation: CLAUDE.md is present');
+  } else {
+    warn('Validation: CLAUDE.md is missing');
+    ok = false;
+  }
+
+  const agentsDir = join(claudeDir, 'agents');
+  if (existsSync(agentsDir)) {
+    const count = readdirSync(agentsDir).filter(f => f.endsWith('.md')).length;
+    if (count > 0) {
+      info(`Validation: ${count} agents installed`);
+    } else {
+      warn('Validation: no agents found — installation may have failed');
+      ok = false;
+    }
+  }
+
+  return ok;
+}

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "claude-code-superkit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.5.3",
+  "description": "Production-tested agents (56), commands (16), hooks (42), skills (22), and rules (19) for Claude Code; 82 skills and 2 native hook handlers for Codex. Claude prompts hardened by Claude Fable 5; GPT role sources authored by Astra.",
+  "type": "module",
+  "bin": {
+    "claude-code-superkit": "./bin/cli.js",
+    "superkit": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "packages/core/",
+    "packages/stack-agents/",
+    "packages/stack-hooks/",
+    "packages/stack-rules/",
+    "packages/extras/",
+    "packages/frontend-3d/",
+    "packages/frontend-ui/",
+    "packages/gan/",
+    "packages/codex/"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "test:smoke": "node --test test/smoke.test.js test/codex-only.test.js"
+  },
+  "keywords": [
+    "claude-code",
+    "codex",
+    "ai-agents",
+    "cli",
+    "scaffolding",
+    "code-review",
+    "hooks",
+    "skills",
+    "opus"
+  ],
+  "author": "RaNDoM6913",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RaNDoM6913/claude-code-superkit.git"
+  },
+  "homepage": "https://github.com/RaNDoM6913/claude-code-superkit#readme",
+  "bugs": {
+    "url": "https://github.com/RaNDoM6913/claude-code-superkit/issues"
+  }
+}