godpowers 2.2.1 → 2.3.0

package/lib/atomic-write.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+
+function tempPathFor(filePath) {
+  const dir = path.dirname(filePath);
+  const base = path.basename(filePath);
+  return path.join(dir, `.${base}.${process.pid}.${Date.now()}.tmp`);
+}
+
+function validateContent(content, validate) {
+  if (typeof validate === 'function') validate(content);
+}
+
+function writeFileAtomic(filePath, content, opts = {}) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmp = tempPathFor(filePath);
+  try {
+    fs.writeFileSync(tmp, content);
+    validateContent(content, opts.validateContent);
+    if (typeof opts.validateFile === 'function') opts.validateFile(tmp);
+    fs.renameSync(tmp, filePath);
+    return filePath;
+  } catch (error) {
+    try {
+      fs.rmSync(tmp, { force: true });
+    } catch (_) {
+      // Best-effort cleanup. The original file is still untouched.
+    }
+    throw error;
+  }
+}
+
+async function writeFileAtomicAsync(filePath, content, opts = {}) {
+  await fsp.mkdir(path.dirname(filePath), { recursive: true });
+  const tmp = tempPathFor(filePath);
+  try {
+    await fsp.writeFile(tmp, content);
+    validateContent(content, opts.validateContent);
+    if (typeof opts.validateFile === 'function') await opts.validateFile(tmp);
+    await fsp.rename(tmp, filePath);
+    return filePath;
+  } catch (error) {
+    try {
+      await fsp.rm(tmp, { force: true });
+    } catch (_) {
+      // Best-effort cleanup. The original file is still untouched.
+    }
+    throw error;
+  }
+}
+
+function jsonContent(value) {
+  return JSON.stringify(value, null, 2) + '\n';
+}
+
+function writeJsonAtomic(filePath, value, opts = {}) {
+  const content = jsonContent(value);
+  return writeFileAtomic(filePath, content, {
+    ...opts,
+    validateContent: text => {
+      JSON.parse(text);
+      validateContent(text, opts.validateContent);
+    }
+  });
+}
+
+async function writeJsonAtomicAsync(filePath, value, opts = {}) {
+  const content = jsonContent(value);
+  return writeFileAtomicAsync(filePath, content, {
+    ...opts,
+    validateContent: text => {
+      JSON.parse(text);
+      validateContent(text, opts.validateContent);
+    }
+  });
+}
+
+module.exports = {
+  tempPathFor,
+  writeFileAtomic,
+  writeFileAtomicAsync,
+  writeJsonAtomic,
+  writeJsonAtomicAsync
+};

package/lib/checkpoint.js

@@ -49,6 +49,7 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
+const atomic = require('./atomic-write');
 
 const MAX_ACTIONS = 20;
 const MAX_FACTS = 10;
@@ -224,7 +225,7 @@ function write(projectRoot, state) {
     ''
   ].filter(line => line !== null).join('\n');
 
-  fs.writeFileSync(file, fm + body);
+  atomic.writeFileAtomic(file, fm + body);
   return file;
 }
 

package/lib/context-writer.js

@@ -99,7 +99,7 @@ function buildCanonicalContent(state, opts = {}) {
   lines.push('- `/god-next` - what to run next, with reason');
   lines.push('- `/god-mode` - run the full autonomous project run');
   lines.push('- `/god-sync` - refresh artifacts, context, and source-system sync-back');
-  lines.push('- `/god-migrate` - import or sync GSD, BMAD, or Superpowers context');
+  lines.push('- `/god-migrate` - import or sync legacy planning, BMAD, or Superpowers context');
   lines.push('- `/god-context refresh` - refresh AI-tool awareness for this project');
   lines.push('');
 

package/lib/executor-repair.js

@@ -0,0 +1,65 @@
+const STRATEGIES = Object.freeze({
+  RETRY: 'retry',
+  DECOMPOSE: 'decompose',
+  PRUNE: 'prune',
+  ESCALATE: 'escalate'
+});
+
+function classifyFailure(input = {}) {
+  const attempts = Number(input.attempts || 0);
+  const budget = Number(Object.prototype.hasOwnProperty.call(input, 'budget') ? input.budget : 2);
+  const error = String(input.error || '').toLowerCase();
+  const criteria = String(input.doneCriteria || '').toLowerCase();
+
+  if (attempts >= budget) {
+    return {
+      strategy: STRATEGIES.ESCALATE,
+      reason: 'repair budget exhausted'
+    };
+  }
+
+  if (/architecture|product decision|ambiguous|human/.test(error)) {
+    return {
+      strategy: STRATEGIES.ESCALATE,
+      reason: 'failure requires a human or architecture decision'
+    };
+  }
+
+  if (/not found|enoent|missing dependency|cannot find module|wrong path|permission|timeout|network|econn/.test(error)) {
+    return {
+      strategy: STRATEGIES.RETRY,
+      reason: 'failure looks environmental or mechanical'
+    };
+  }
+
+  if (/and|multiple|all of|end-to-end|full flow/.test(criteria) || /too broad|partial|only.*part/.test(error)) {
+    return {
+      strategy: STRATEGIES.DECOMPOSE,
+      reason: 'done criteria appears too broad for one verified step'
+    };
+  }
+
+  if (/out of scope|blocked by missing prerequisite|unsupported|cannot be implemented/.test(error)) {
+    return {
+      strategy: STRATEGIES.PRUNE,
+      reason: 'task appears infeasible in the current slice'
+    };
+  }
+
+  return {
+    strategy: STRATEGIES.RETRY,
+    reason: 'default to one focused retry before broader action'
+  };
+}
+
+function renderRepairLog(task, decision) {
+  const name = task || 'task';
+  const strategy = decision.strategy.toUpperCase();
+  return `[Executor Repair - ${strategy}] ${name}: ${decision.reason}`;
+}
+
+module.exports = {
+  STRATEGIES,
+  classifyFailure,
+  renderRepairLog
+};

package/lib/feature-awareness.js

@@ -21,7 +21,7 @@ const FEATURES = [
     id: 'planning-system-migration',
     since: '1.6.15',
     commands: ['/god-migrate', '/god-init'],
-    description: 'Detect and import GSD, BMAD, and Superpowers planning artifacts.'
+    description: 'Detect and import legacy planning, BMAD, and Superpowers planning artifacts.'
   },
   {
     id: 'source-system-sync-back',

package/lib/fs-async.js

@@ -1,5 +1,6 @@
 const fs = require('fs/promises');
 const path = require('path');
+const atomic = require('./atomic-write');
 
 async function exists(filePath) {
   try {
@@ -16,7 +17,7 @@ async function readJson(filePath) {
 
 async function writeJson(filePath, value) {
   await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await fs.writeFile(filePath, JSON.stringify(value, null, 2) + '\n');
+  await atomic.writeJsonAtomicAsync(filePath, value);
   return value;
 }
 

package/lib/install-profiles.js

@@ -0,0 +1,154 @@
+const COMMON = [
+  'god',
+  'god-help',
+  'god-version',
+  'god-next',
+  'god-status',
+  'god-progress',
+  'god-doctor',
+  'god-settings'
+];
+
+const PROFILE_SKILLS = {
+  core: [
+    ...COMMON,
+    'god-init',
+    'god-mode',
+    'god-build',
+    'god-review',
+    'god-sync',
+    'god-quick',
+    'god-fast'
+  ],
+  builder: [
+    ...COMMON,
+    'god-init',
+    'god-mode',
+    'god-discuss',
+    'god-explore',
+    'god-list-assumptions',
+    'god-prd',
+    'god-design',
+    'god-design-impact',
+    'god-arch',
+    'god-roadmap',
+    'god-stack',
+    'god-repo',
+    'god-build',
+    'god-add-tests',
+    'god-feature',
+    'god-story',
+    'god-stories',
+    'god-story-build',
+    'god-story-verify',
+    'god-story-close',
+    'god-review',
+    'god-test-runtime',
+    'god-sync',
+    'god-quick',
+    'god-fast'
+  ],
+  maintainer: [
+    ...COMMON,
+    'god-hygiene',
+    'god-update-deps',
+    'god-docs',
+    'god-repair',
+    'god-lint',
+    'god-standards',
+    'god-preflight',
+    'god-audit',
+    'god-agent-audit',
+    'god-context',
+    'god-context-scan',
+    'god-locate',
+    'god-scan',
+    'god-link',
+    'god-review-changes',
+    'god-reconcile',
+    'god-reconstruct',
+    'god-migrate',
+    'god-automation-status',
+    'god-automation-setup',
+    'god-extension-add',
+    'god-extension-list',
+    'god-extension-info',
+    'god-extension-remove',
+    'god-test-extension',
+    'god-budget',
+    'god-cost',
+    'god-cache-clear',
+    'god-logs',
+    'god-metrics',
+    'god-trace',
+    'god-export-otel',
+    'god-dogfood',
+    'god-quick',
+    'god-fast'
+  ],
+  suite: [
+    ...COMMON,
+    'god-suite-init',
+    'god-suite-status',
+    'god-suite-sync',
+    'god-suite-patch',
+    'god-suite-release',
+    'god-workstream',
+    'god-pr-branch',
+    'god-sync',
+    'god-reconcile',
+    'god-review',
+    'god-quick',
+    'god-fast'
+  ]
+};
+
+const PROFILE_DESCRIPTIONS = {
+  core: 'front door, status, init, build, review, sync, quick edits',
+  builder: 'core plus planning, design, stories, and runtime verification',
+  maintainer: 'core plus hygiene, deps, docs, repair, automation, and extensions',
+  suite: 'core plus multi-repo suite and workstream coordination',
+  full: 'all shipped slash commands'
+};
+
+function normalizeProfiles(value) {
+  if (!value) return ['full'];
+  const raw = String(value)
+    .split(',')
+    .map(part => part.trim().toLowerCase())
+    .filter(Boolean);
+  const profiles = raw.length > 0 ? raw : ['full'];
+  for (const profile of profiles) {
+    if (profile !== 'full' && !PROFILE_SKILLS[profile]) {
+      throw new Error(`Unknown install profile: ${profile}`);
+    }
+  }
+  if (profiles.includes('full')) return ['full'];
+  return [...new Set(profiles)];
+}
+
+function selectedSkillNames(profileValue, availableNames) {
+  const profiles = normalizeProfiles(profileValue);
+  if (profiles.includes('full')) return new Set(availableNames);
+  const selected = new Set();
+  for (const profile of profiles) {
+    for (const name of PROFILE_SKILLS[profile]) {
+      if (availableNames.includes(name)) selected.add(name);
+    }
+  }
+  return selected;
+}
+
+function describeProfiles(profileValue) {
+  return normalizeProfiles(profileValue)
+    .map(profile => `${profile}: ${PROFILE_DESCRIPTIONS[profile]}`)
+    .join('; ');
+}
+
+module.exports = {
+  PROFILE_SKILLS,
+  PROFILE_DESCRIPTIONS,
+  normalizeProfiles,
+  selectedSkillNames,
+  describeProfiles
+};

package/lib/installer-args.js

@@ -29,6 +29,7 @@ function parseArgs(argv, cwd = process.cwd()) {
     all: false,
     help: false,
     uninstall: false,
+    profile: 'full',
   };
 
   for (let i = 0; i < args.length; i++) {
@@ -62,6 +63,15 @@ function parseArgs(argv, cwd = process.cwd()) {
       case '--all':
         opts.all = true;
         break;
+      case '--minimal':
+        opts.profile = 'core';
+        break;
+      case '--profile':
+        if (args[i + 1]) {
+          opts.profile = args[i + 1];
+          i++;
+        }
+        break;
       case '-h':
       case '--help':
         opts.help = true;
@@ -83,6 +93,8 @@ function parseArgs(argv, cwd = process.cwd()) {
           opts.extensionAgent = arg.slice('--agent='.length);
         } else if (arg.startsWith('--workflow=')) {
           opts.extensionWorkflow = arg.slice('--workflow='.length);
+        } else if (arg.startsWith('--profile=')) {
+          opts.profile = arg.slice('--profile='.length);
         } else if (arg.startsWith('--') && RUNTIMES[arg.slice(2)]) {
           opts.runtimes.push(arg.slice(2));
         }

package/lib/installer-core.js

@@ -3,8 +3,10 @@ const path = require('path');
 
 const { ensureDir, copyRecursive, copyRuntimeBundle } = require('./installer-files');
 const { resolveRuntime } = require('./installer-runtimes');
+const { selectedSkillNames, normalizeProfiles } = require('./install-profiles');
+const identity = require('./package-identity');
 
-const VERSION = require('../package.json').version;
+const VERSION = identity.PACKAGE_VERSION;
 
 /**
  * @typedef {Object} InstallOptions
@@ -141,6 +143,15 @@ function removeSkillEntry(skillsDir, entry) {
   return false;
 }
 
+function pruneGodpowersSkills(skillsDir) {
+  let removed = 0;
+  if (!fs.existsSync(skillsDir)) return removed;
+  for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+    if (removeSkillEntry(skillsDir, entry)) removed++;
+  }
+  return removed;
+}
+
 function installForRuntime(runtimeKey, srcDir, opts = {}) {
   const runtime = resolveRuntime(runtimeKey, opts);
   if (!runtime) {
@@ -151,7 +162,7 @@ function installForRuntime(runtimeKey, srcDir, opts = {}) {
   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);
+  installSkills(srcDir, runtimeKey, runtime, opts);
   installAgents(srcDir, runtime);
   installMasterSkill(srcDir, runtimeKey, runtime);
   installDataDirs(srcDir, runtime);
@@ -159,18 +170,33 @@ function installForRuntime(runtimeKey, srcDir, opts = {}) {
 
   fs.writeFileSync(path.join(runtime.configDir, 'GODPOWERS_VERSION'), VERSION);
   success(`Wrote GODPOWERS_VERSION (${VERSION})`);
+  fs.writeFileSync(path.join(runtime.configDir, 'GODPOWERS_PROFILE'), normalizeProfiles(opts.profile).join(','));
+  success(`Wrote GODPOWERS_PROFILE (${normalizeProfiles(opts.profile).join(',')})`);
   return true;
 }
 
-function installSkills(srcDir, runtimeKey, runtime) {
+function availableSkillFiles(srcDir) {
+  const skillsSrc = path.join(srcDir, 'skills');
+  if (!fs.existsSync(skillsSrc)) return [];
+  return fs.readdirSync(skillsSrc)
+    .filter(file => file.endsWith('.md'))
+    .sort();
+}
+
+function installSkills(srcDir, runtimeKey, runtime, opts = {}) {
   const skillsSrc = path.join(srcDir, 'skills');
   const skillsDest = path.join(runtime.configDir, runtime.skillsDir);
   if (!fs.existsSync(skillsSrc)) return;
 
   ensureDir(skillsDest);
+  pruneGodpowersSkills(skillsDest);
+  const files = availableSkillFiles(srcDir);
+  const names = files.map(file => path.basename(file, '.md'));
+  const selected = selectedSkillNames(opts.profile, names);
   let count = 0;
-  for (const file of fs.readdirSync(skillsSrc)) {
-    if (file.endsWith('.md')) {
+  for (const file of files) {
+    const name = path.basename(file, '.md');
+    if (selected.has(name)) {
       installSkillFile(path.join(skillsSrc, file), skillsDest, runtimeKey);
       count++;
     }
@@ -327,8 +353,15 @@ function uninstallHooks(runtimeKey, runtime) {
 }
 
 function countInstalledSurface(srcDir) {
+  return countProfileSurface(srcDir, { profile: 'full' });
+}
+
+function countProfileSurface(srcDir, opts = {}) {
+  const files = availableSkillFiles(srcDir);
+  const names = files.map(file => path.basename(file, '.md'));
+  const selected = selectedSkillNames(opts.profile, names);
   return {
-    skills: fs.readdirSync(path.join(srcDir, 'skills')).filter(f => f.endsWith('.md')).length,
+    skills: selected.size,
     agents: fs.readdirSync(path.join(srcDir, 'agents')).filter(f => /^god-.*\.md$/.test(f)).length
   };
 }
@@ -336,10 +369,12 @@ function countInstalledSurface(srcDir) {
 module.exports = {
   installForRuntime,
   uninstallForRuntime,
-  countInstalledSurface,
+  countInstalledSurface: countProfileSurface,
   installSkillFile,
   parseAgentFrontmatter,
   stripFrontmatter,
   writeCodexAgentToml,
-  removeSkillEntry
+  removeSkillEntry,
+  pruneGodpowersSkills,
+  installSkills
 };

package/lib/linkage.js

@@ -23,6 +23,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const atomic = require('./atomic-write');
 
 const ID_PATTERNS = {
   prd: /^P-(MUST|SHOULD|COULD)-\d+$/,
@@ -77,7 +78,7 @@ function readMap(filePath) {
 }
 
 function writeMap(filePath, data) {
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
+  atomic.writeJsonAtomic(filePath, data);
 }
 
 function linkKey(artifactId, filePath) {

package/lib/package-identity.js

@@ -0,0 +1,38 @@
+const pkg = require('../package.json');
+
+const PACKAGE_NAME = pkg.name;
+const PACKAGE_VERSION = pkg.version;
+const REPOSITORY_URL = pkg.repository && pkg.repository.url
+  ? pkg.repository.url
+  : 'git+https://github.com/aihxp/godpowers.git';
+const HOMEPAGE_URL = pkg.homepage || 'https://github.com/aihxp/godpowers#readme';
+const BUGS_URL = pkg.bugs && pkg.bugs.url
+  ? pkg.bugs.url
+  : 'https://github.com/aihxp/godpowers/issues';
+const BIN_NAME = pkg.bin && Object.keys(pkg.bin)[0]
+  ? Object.keys(pkg.bin)[0]
+  : 'godpowers';
+
+function repoSlug() {
+  const url = REPOSITORY_URL
+    .replace(/^git\+/, '')
+    .replace(/^https:\/\/github\.com\//, '')
+    .replace(/^git@github\.com:/, '')
+    .replace(/\.git$/, '');
+  return url || 'aihxp/godpowers';
+}
+
+function npxCommand(version = 'latest') {
+  return `npx ${PACKAGE_NAME}@${version}`;
+}
+
+module.exports = {
+  PACKAGE_NAME,
+  PACKAGE_VERSION,
+  REPOSITORY_URL,
+  HOMEPAGE_URL,
+  BUGS_URL,
+  BIN_NAME,
+  repoSlug,
+  npxCommand
+};