godpowers 2.0.0 → 2.1.0

package/lib/installer-core.js

@@ -0,0 +1,345 @@
+const fs = require('fs');
+const path = require('path');
+
+const { ensureDir, copyRecursive, copyRuntimeBundle } = require('./installer-files');
+const { resolveRuntime } = require('./installer-runtimes');
+
+const VERSION = require('../package.json').version;
+
+/**
+ * @typedef {Object} InstallOptions
+ * @property {boolean} [local] Install relative to the current working directory.
+ * @property {boolean} [global] Install to the host runtime config directory.
+ */
+
+/**
+ * @typedef {Object} InstallSurface
+ * @property {number} skills Number of slash-command skill files.
+ * @property {number} agents Number of specialist agent files.
+ */
+
+function log(msg) {
+  console.log(`  ${msg}`);
+}
+
+function success(msg) {
+  console.log(`  \x1b[32m+\x1b[0m ${msg}`);
+}
+
+function error(msg) {
+  console.error(`  \x1b[31mx\x1b[0m ${msg}`);
+}
+
+function installSkillFile(srcFile, skillsDest, runtimeKey, targetName = null) {
+  const baseName = targetName || path.basename(srcFile, '.md');
+  if (runtimeKey === 'codex') {
+    const skillDir = path.join(skillsDest, baseName);
+    if (fs.existsSync(skillDir)) {
+      fs.rmSync(skillDir, { recursive: true, force: true });
+    }
+    ensureDir(skillDir);
+    fs.copyFileSync(srcFile, path.join(skillDir, 'SKILL.md'));
+    return;
+  }
+  fs.copyFileSync(srcFile, path.join(skillsDest, `${baseName}.md`));
+}
+
+function parseAgentFrontmatter(content) {
+  const fallback = { name: null, description: null };
+  if (!content.startsWith('---\n')) return fallback;
+
+  const end = content.indexOf('\n---', 4);
+  if (end === -1) return fallback;
+
+  const lines = content.slice(4, end).split('\n');
+  const parsed = { ...fallback };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const nameMatch = line.match(/^name:\s*(.+)\s*$/);
+    if (nameMatch) {
+      parsed.name = nameMatch[1].replace(/^["']|["']$/g, '');
+      continue;
+    }
+
+    if (line === 'description: |') {
+      const desc = [];
+      i++;
+      while (i < lines.length && /^ {2}/.test(lines[i])) {
+        desc.push(lines[i].slice(2));
+        i++;
+      }
+      i--;
+      parsed.description = desc.join('\n').trim();
+      continue;
+    }
+
+    const descMatch = line.match(/^description:\s*(.+)\s*$/);
+    if (descMatch) {
+      parsed.description = descMatch[1].replace(/^["']|["']$/g, '');
+    }
+  }
+
+  return parsed;
+}
+
+function stripFrontmatter(content) {
+  if (!content.startsWith('---\n')) return content.trim();
+  const end = content.indexOf('\n---', 4);
+  if (end === -1) return content.trim();
+  return content.slice(end + 4).trim();
+}
+
+function tomlString(value) {
+  return JSON.stringify(value || '');
+}
+
+function tomlLiteral(value) {
+  return `'''\n${(value || '').replace(/'''/g, "'''\\'''")}\n'''`;
+}
+
+function writeCodexAgentToml(srcFile, agentsDest) {
+  const content = fs.readFileSync(srcFile, 'utf8');
+  const frontmatter = parseAgentFrontmatter(content);
+  const name = frontmatter.name || path.basename(srcFile, '.md');
+  const description = frontmatter.description || `Godpowers specialist agent: ${name}.`;
+  const instructions = stripFrontmatter(content);
+  const toml = [
+    `name = ${tomlString(name)}`,
+    `description = ${tomlString(description)}`,
+    'sandbox_mode = "workspace-write"',
+    `developer_instructions = ${tomlLiteral(instructions)}`,
+    ''
+  ].join('\n');
+
+  fs.writeFileSync(path.join(agentsDest, `${name}.toml`), toml);
+}
+
+function installAgentFile(srcFile, agentsDest, runtime) {
+  fs.copyFileSync(srcFile, path.join(agentsDest, path.basename(srcFile)));
+  if (runtime.agentMetadata === 'toml') {
+    writeCodexAgentToml(srcFile, agentsDest);
+  }
+}
+
+function removeSkillEntry(skillsDir, entry) {
+  const entryPath = path.join(skillsDir, entry.name);
+  if (entry.isDirectory()) {
+    const skillFile = path.join(entryPath, 'SKILL.md');
+    if (entry.name.startsWith('god-') || entry.name === 'god' || entry.name === 'godpowers') {
+      if (fs.existsSync(skillFile)) {
+        fs.rmSync(entryPath, { recursive: true, force: true });
+        return true;
+      }
+    }
+    return false;
+  }
+  if (entry.name.startsWith('god-') || entry.name === 'god.md' || entry.name === 'godpowers.md') {
+    fs.unlinkSync(entryPath);
+    return true;
+  }
+  return false;
+}
+
+function installForRuntime(runtimeKey, srcDir, opts = {}) {
+  const runtime = resolveRuntime(runtimeKey, opts);
+  if (!runtime) {
+    error(`Unknown runtime: ${runtimeKey}`);
+    return false;
+  }
+
+  log(`\n  Installing for \x1b[36m${runtime.name}\x1b[0m to \x1b[36m${runtime.configDir}\x1b[0m\n`);
+  ensureDir(runtime.configDir);
+
+  installSkills(srcDir, runtimeKey, runtime);
+  installAgents(srcDir, runtime);
+  installMasterSkill(srcDir, runtimeKey, runtime);
+  installDataDirs(srcDir, runtime);
+  installHooks(srcDir, runtimeKey, runtime);
+
+  fs.writeFileSync(path.join(runtime.configDir, 'GODPOWERS_VERSION'), VERSION);
+  success(`Wrote GODPOWERS_VERSION (${VERSION})`);
+  return true;
+}
+
+function installSkills(srcDir, runtimeKey, runtime) {
+  const skillsSrc = path.join(srcDir, 'skills');
+  const skillsDest = path.join(runtime.configDir, runtime.skillsDir);
+  if (!fs.existsSync(skillsSrc)) return;
+
+  ensureDir(skillsDest);
+  let count = 0;
+  for (const file of fs.readdirSync(skillsSrc)) {
+    if (file.endsWith('.md')) {
+      installSkillFile(path.join(skillsSrc, file), skillsDest, runtimeKey);
+      count++;
+    }
+  }
+  const shape = runtimeKey === 'codex' ? 'Codex skill directories' : 'skills/';
+  success(`Installed ${count} slash commands to ${shape}`);
+}
+
+function installAgents(srcDir, runtime) {
+  const agentsSrc = path.join(srcDir, 'agents');
+  const agentsDest = path.join(runtime.configDir, 'agents');
+  if (!fs.existsSync(agentsSrc)) return;
+
+  ensureDir(agentsDest);
+  let count = 0;
+  for (const file of fs.readdirSync(agentsSrc)) {
+    if (/^god-.*\.md$/.test(file)) {
+      installAgentFile(path.join(agentsSrc, file), agentsDest, runtime);
+      count++;
+    }
+  }
+  const shape = runtime.agentMetadata === 'toml' ? 'agents/ with Codex metadata' : 'agents/';
+  success(`Installed ${count} specialist agents to ${shape}`);
+}
+
+function installMasterSkill(srcDir, runtimeKey, runtime) {
+  const masterSkill = path.join(srcDir, 'SKILL.md');
+  if (!fs.existsSync(masterSkill)) return;
+  const skillsDest = path.join(runtime.configDir, runtime.skillsDir);
+  installSkillFile(masterSkill, skillsDest, runtimeKey, 'godpowers');
+  success('Installed master SKILL.md as godpowers');
+}
+
+function installDataDirs(srcDir, runtime) {
+  const dataDirs = [
+    ['templates', 'godpowers-templates', 'Installed templates/'],
+    ['references', 'godpowers-references', 'Installed references/'],
+    ['workflows', 'godpowers-workflows', 'Installed workflows/'],
+    ['schema', 'godpowers-schema', 'Installed schema/'],
+    ['routing', 'godpowers-routing', 'Installed routing/']
+  ];
+
+  for (const [sourceName, destName, message] of dataDirs) {
+    const src = path.join(srcDir, sourceName);
+    if (fs.existsSync(src)) {
+      const dest = path.join(runtime.configDir, destName);
+      // Clean replace. These destinations are entirely Godpowers-owned (the
+      // uninstaller removes each one wholesale), so clearing first guarantees
+      // a version upgrade never leaves behind files that no longer ship.
+      fs.rmSync(dest, { recursive: true, force: true });
+      copyRecursive(src, dest);
+      success(message);
+    }
+  }
+
+  const bundleDest = path.join(runtime.configDir, 'godpowers-runtime');
+  fs.rmSync(bundleDest, { recursive: true, force: true });
+  copyRuntimeBundle(srcDir, bundleDest);
+  success('Installed runtime bundle/');
+}
+
+function installHooks(srcDir, runtimeKey, runtime) {
+  if (runtimeKey !== 'claude') return;
+  const hooksSrc = path.join(srcDir, 'hooks');
+  const hooksDest = path.join(runtime.configDir, 'hooks');
+  if (!fs.existsSync(hooksSrc)) return;
+
+  ensureDir(hooksDest);
+  for (const file of fs.readdirSync(hooksSrc)) {
+    const src = path.join(hooksSrc, file);
+    const dest = path.join(hooksDest, file);
+    fs.copyFileSync(src, dest);
+    try {
+      fs.chmodSync(dest, 0o755);
+    } catch (_) {
+      // Preserve install success when chmod is unavailable on the host.
+    }
+  }
+  success('Installed hooks/');
+}
+
+function uninstallForRuntime(runtimeKey, opts = {}) {
+  const runtime = resolveRuntime(runtimeKey, opts);
+  if (!runtime) {
+    error(`Unknown runtime: ${runtimeKey}`);
+    return false;
+  }
+
+  log(`\n  Uninstalling from \x1b[36m${runtime.name}\x1b[0m at \x1b[36m${runtime.configDir}\x1b[0m\n`);
+  uninstallSkills(runtime);
+  uninstallAgents(runtime);
+  uninstallDataDirs(runtime);
+  uninstallHooks(runtimeKey, runtime);
+
+  const versionFile = path.join(runtime.configDir, 'GODPOWERS_VERSION');
+  if (fs.existsSync(versionFile)) {
+    fs.unlinkSync(versionFile);
+  }
+  return true;
+}
+
+function uninstallSkills(runtime) {
+  const skillsDir = path.join(runtime.configDir, runtime.skillsDir);
+  let removed = 0;
+  if (!fs.existsSync(skillsDir)) return;
+  for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+    if (removeSkillEntry(skillsDir, entry)) {
+      removed++;
+    }
+  }
+  success(`Removed ${removed} god-* skill(s)`);
+}
+
+function uninstallAgents(runtime) {
+  const agentsDir = path.join(runtime.configDir, 'agents');
+  let removed = 0;
+  if (!fs.existsSync(agentsDir)) return;
+  for (const file of fs.readdirSync(agentsDir)) {
+    if (file.startsWith('god-')) {
+      fs.unlinkSync(path.join(agentsDir, file));
+      removed++;
+    }
+  }
+  success(`Removed ${removed} god-* agent(s)`);
+}
+
+function uninstallDataDirs(runtime) {
+  for (const dir of [
+    'godpowers-templates',
+    'godpowers-references',
+    'godpowers-workflows',
+    'godpowers-schema',
+    'godpowers-routing',
+    'godpowers-runtime'
+  ]) {
+    const full = path.join(runtime.configDir, dir);
+    if (fs.existsSync(full)) {
+      fs.rmSync(full, { recursive: true, force: true });
+      success(`Removed ${dir}/`);
+    }
+  }
+}
+
+function uninstallHooks(runtimeKey, runtime) {
+  if (runtimeKey !== 'claude') return;
+  const hooksDir = path.join(runtime.configDir, 'hooks');
+  for (const hook of ['session-start.sh', 'pre-tool-use.sh']) {
+    const hookPath = path.join(hooksDir, hook);
+    if (fs.existsSync(hookPath)) {
+      fs.unlinkSync(hookPath);
+      success(`Removed hooks/${hook}`);
+    }
+  }
+}
+
+function countInstalledSurface(srcDir) {
+  return {
+    skills: fs.readdirSync(path.join(srcDir, 'skills')).filter(f => f.endsWith('.md')).length,
+    agents: fs.readdirSync(path.join(srcDir, 'agents')).filter(f => /^god-.*\.md$/.test(f)).length
+  };
+}
+
+module.exports = {
+  installForRuntime,
+  uninstallForRuntime,
+  countInstalledSurface,
+  installSkillFile,
+  parseAgentFrontmatter,
+  stripFrontmatter,
+  writeCodexAgentToml,
+  removeSkillEntry
+};

package/lib/installer-files.js

@@ -0,0 +1,80 @@
+/**
+ * File helpers shared by the installer and installer tests.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function replaceExisting(dest) {
+  try {
+    const stat = fs.lstatSync(dest);
+    if (stat.isDirectory() && !stat.isSymbolicLink()) {
+      fs.rmSync(dest, { recursive: true, force: true });
+    } else {
+      fs.unlinkSync(dest);
+    }
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw e;
+  }
+}
+
+function copyRecursive(src, dest, root) {
+  // `root` bounds where a reproduced symlink is allowed to point. It defaults
+  // to the top-level source on the first call and is threaded through recursion.
+  if (root === undefined) root = path.resolve(src);
+  const rootResolved = path.resolve(root);
+  const stat = fs.lstatSync(src);
+
+  if (stat.isSymbolicLink()) {
+    const linkTarget = fs.readlinkSync(src);
+    const resolvedTarget = path.resolve(path.dirname(src), linkTarget);
+    // Only reproduce symlinks that stay within the source tree. A symlink
+    // pointing outside it (absolute path or `../` escape) would otherwise be
+    // planted into the user's runtime config pointing anywhere on disk, so we
+    // skip it rather than copy it verbatim.
+    const inRoot = resolvedTarget === rootResolved ||
+      resolvedTarget.startsWith(rootResolved + path.sep);
+    if (!inRoot) return;
+    ensureDir(path.dirname(dest));
+    replaceExisting(dest);
+    fs.symlinkSync(linkTarget, dest);
+    return;
+  }
+
+  if (stat.isDirectory()) {
+    ensureDir(dest);
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+      copyRecursive(path.join(src, entry.name), path.join(dest, entry.name), root);
+    }
+    return;
+  }
+
+  if (stat.isFile()) {
+    ensureDir(path.dirname(dest));
+    fs.copyFileSync(src, dest);
+    fs.chmodSync(dest, stat.mode);
+  }
+}
+
+function copyRuntimeBundle(srcDir, destDir) {
+  ensureDir(destDir);
+  for (const dir of ['lib', 'routing', 'workflows', 'schema', 'templates', 'references']) {
+    const src = path.join(srcDir, dir);
+    if (fs.existsSync(src)) {
+      copyRecursive(src, path.join(destDir, dir));
+    }
+  }
+  const packageJson = path.join(srcDir, 'package.json');
+  if (fs.existsSync(packageJson)) {
+    fs.copyFileSync(packageJson, path.join(destDir, 'package.json'));
+  }
+}
+
+module.exports = { ensureDir, copyRecursive, copyRuntimeBundle };

package/lib/installer-runtimes.js

@@ -0,0 +1,112 @@
+const path = require('path');
+const os = require('os');
+
+const RUNTIMES = {
+  claude: {
+    name: 'Claude Code',
+    configDir: path.join(os.homedir(), '.claude'),
+    skillsDir: 'skills',
+    configFile: null,
+  },
+  codex: {
+    name: 'Codex',
+    configDir: path.join(os.homedir(), '.codex'),
+    skillsDir: 'skills',
+    configFile: 'config.toml',
+    agentMetadata: 'toml',
+  },
+  cursor: {
+    name: 'Cursor',
+    configDir: path.join(os.homedir(), '.cursor'),
+    skillsDir: 'rules',
+    configFile: null,
+  },
+  windsurf: {
+    name: 'Windsurf',
+    configDir: path.join(os.homedir(), '.windsurf'),
+    skillsDir: 'rules',
+    configFile: null,
+  },
+  opencode: {
+    name: 'OpenCode',
+    configDir: path.join(os.homedir(), '.opencode'),
+    skillsDir: 'skills',
+    configFile: null,
+  },
+  gemini: {
+    name: 'Gemini CLI',
+    configDir: path.join(os.homedir(), '.gemini'),
+    skillsDir: 'skills',
+    configFile: null,
+  },
+  copilot: {
+    name: 'GitHub Copilot',
+    configDir: path.join(os.homedir(), '.copilot'),
+    skillsDir: 'skills',
+    configFile: null,
+  },
+  augment: {
+    name: 'Augment',
+    configDir: path.join(os.homedir(), '.augment'),
+    skillsDir: 'skills',
+    configFile: null,
+  },
+  trae: {
+    name: 'Trae',
+    configDir: path.join(os.homedir(), '.trae'),
+    skillsDir: 'skills',
+    configFile: null,
+  },
+  cline: {
+    name: 'Cline',
+    configDir: path.join(os.homedir(), '.cline'),
+    skillsDir: 'skills',
+    configFile: null,
+  },
+  kilo: {
+    name: 'Kilo',
+    configDir: path.join(os.homedir(), '.kilo'),
+    skillsDir: 'skills',
+    configFile: null,
+  },
+  antigravity: {
+    name: 'Antigravity',
+    configDir: path.join(os.homedir(), '.antigravity'),
+    skillsDir: 'skills',
+    configFile: null,
+  },
+  qwen: {
+    name: 'Qwen Code',
+    configDir: path.join(os.homedir(), '.qwen'),
+    skillsDir: 'skills',
+    configFile: null,
+  },
+  codebuddy: {
+    name: 'CodeBuddy',
+    configDir: path.join(os.homedir(), '.codebuddy'),
+    skillsDir: 'skills',
+    configFile: null,
+  },
+  pi: {
+    name: 'Pi',
+    configDir: path.join(os.homedir(), '.pi'),
+    skillsDir: 'skills',
+    configFile: null,
+  },
+};
+
+function resolveRuntime(runtimeKey, opts = {}) {
+  const runtime = RUNTIMES[runtimeKey];
+  if (!runtime) return null;
+  const resolved = { ...runtime };
+  if (opts.local && !opts.global) {
+    resolved.configDir = path.join(process.cwd(), path.basename(runtime.configDir));
+  }
+  return resolved;
+}
+
+module.exports = {
+  RUNTIMES,
+  resolveRuntime,
+  runtimeKeys: () => Object.keys(RUNTIMES)
+};