@polymorphism-tech/morph-spec 4.8.1 → 4.8.4

package/docs/plans/2026-02-24-morph-init-impl.md

@@ -1,1269 +0,0 @@
-# morph-init Implementation Plan
-
-**Status:** COMPLETE
-
-> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
-
-**Goal:** Replace `morph-spec init` as user-facing entry point with a `/morph-init` skill that uses LLM analysis for robust project detection across any stack or layout, and auto-installs required Claude Code plugins.
-
-**Architecture:** Extract infrastructure setup from `init.js` into a headless `setup-infra.js` script. Add `install-plugin.js` to auto-install superpowers + context7 from GitHub. Create `global-install.js` postinstall to distribute the `morph-init` skill globally. Write the `morph-init` SKILL.md as the single user-facing entry point.
-
-**Key constraint:** The `morph-init` skill runs inside the *user's project*, not inside the morph-spec-framework repo. It cannot call `node src/scripts/...` directly. All script logic must be exposed as CLI subcommands (`morph-spec setup-infra`, `morph-spec install-plugin <name>`) so the skill can call them via the globally-installed `morph-spec` binary.
-
-**Tech Stack:** Node.js ESM, fs-extra, node:https, Commander.js, Claude Code skill format (YAML frontmatter + markdown)
-
-**Design doc:** `docs/plans/2026-02-24-morph-init-design.md`
-
----
-
-## Task 1: Create `src/scripts/setup-infra.js` + `morph-spec setup-infra` command
-
-Extract all infrastructure logic from `init.js` into a standalone headless module, then expose it as a CLI subcommand so the `morph-init` skill can call `morph-spec setup-infra` from any user project.
-
-**Files:**
-
-- Create: `src/scripts/setup-infra.js` — pure logic, exported function
-- Create: `src/commands/project/setup-infra-cmd.js` — thin CLI wrapper
-- Modify: `bin/morph-spec.js` — register `morph-spec setup-infra`
-- Create: `test/scripts/setup-infra.test.js`
-
-**Step 1: Write failing tests**
-
-```js
-// test/scripts/setup-infra.test.js
-import { test, describe, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { createTempDir, cleanupTempDir } from '../helpers/test-utils.js';
-import { setupInfra } from '../../src/scripts/setup-infra.js';
-
-describe('setup-infra', () => {
-  let tempDir;
-  beforeEach(() => { tempDir = createTempDir(); });
-  afterEach(() => { cleanupTempDir(tempDir); });
-
-  test('creates .morph/ directory structure', async () => {
-    await setupInfra(tempDir);
-    const dirs = ['config', 'framework', 'context', 'features', 'checkpoints', 'memory', 'archive'];
-    for (const d of dirs) {
-      assert.ok(existsSync(join(tempDir, '.morph', d)), `.morph/${d} must exist`);
-    }
-  });
-
-  test('writes minimal config.json with name and version only', async () => {
-    await setupInfra(tempDir);
-    const config = JSON.parse(readFileSync(join(tempDir, '.morph', 'config', 'config.json'), 'utf8'));
-    assert.ok(config.project.name, 'must have project.name');
-    assert.ok(config.frameworkVersion, 'must have frameworkVersion');
-    assert.strictEqual(config.project.stack, undefined, 'must NOT have stack — skill sets this');
-    assert.strictEqual(config.project.architecture, undefined, 'must NOT have architecture — skill sets this');
-  });
-
-  test('writes placeholder context/README.md', async () => {
-    await setupInfra(tempDir);
-    const readme = readFileSync(join(tempDir, '.morph', 'context', 'README.md'), 'utf8');
-    assert.ok(readme.includes('Project Context'), 'must have header');
-  });
-
-  test('installs .claude/skills/ directory', async () => {
-    await setupInfra(tempDir);
-    assert.ok(existsSync(join(tempDir, '.claude', 'skills')), '.claude/skills/ must exist');
-  });
-
-  test('installs .claude/agents/ directory', async () => {
-    await setupInfra(tempDir);
-    assert.ok(existsSync(join(tempDir, '.claude', 'agents')), '.claude/agents/ must exist');
-  });
-
-  test('installs .claude/rules/ directory', async () => {
-    await setupInfra(tempDir);
-    assert.ok(existsSync(join(tempDir, '.claude', 'rules')), '.claude/rules/ must exist');
-  });
-
-  test('copies framework files to .morph/framework/', async () => {
-    await setupInfra(tempDir);
-    assert.ok(existsSync(join(tempDir, '.morph', 'framework', 'agents.json')), 'agents.json must be copied');
-  });
-
-  test('updates .gitignore with .morph/state.json entry', async () => {
-    await setupInfra(tempDir);
-    // gitignore update is best-effort, only check if it runs without error
-  });
-
-  test('is idempotent — safe to run twice', async () => {
-    await setupInfra(tempDir);
-    await setupInfra(tempDir); // should not throw
-    assert.ok(existsSync(join(tempDir, '.morph', 'config', 'config.json')));
-  });
-});
-```
-
-**Step 2: Run tests to verify they fail**
-
-```bash
-cd "R:/Polymorphism Tech/repos/morph-spec-framework"
-node --test test/scripts/setup-infra.test.js
-```
-
-Expected: FAIL — `setup-infra.js` not found
-
-**Step 3: Implement `src/scripts/setup-infra.js`**
-
-Extract steps 1–10 from `src/commands/project/init.js` (lines 54–220 approximately). Key differences from init.js:
-
-- Export a `setupInfra(targetPath)` async function (no Commander, no spinner output in test mode)
-- Use `process.env.MORPH_QUIET` to suppress spinner in tests
-- config.json: write `{ framework, frameworkVersion, project: { name } }` only — no stack/architecture
-- context/README.md: write the same minimal placeholder as today
-- Reuse ALL existing imports from init.js: `installSkills`, `installAgents`, `installDomainAgents`, `installClaudeHooks`, `installGlobalStatusline`, `copyDirectory`, `copyFile`, etc.
-
-```js
-// src/scripts/setup-infra.js
-import { join } from 'path';
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-import fs from 'fs-extra';
-import ora from 'ora';
-import { logger } from '../utils/logger.js';
-import {
-  copyDirectory, copyFile, pathExists,
-  writeJson, ensureDir, writeFile, updateGitignore
-} from '../utils/file-copier.js';
-import { saveProjectMorphVersion, getInstalledCLIVersion } from '../utils/version-checker.js';
-import { installClaudeHooks, installGlobalStatusline } from '../utils/claude-settings-manager.js';
-import { installSkills } from '../utils/skills-installer.js';
-import { installAgents, installDomainAgents } from '../utils/agents-installer.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const FRAMEWORK_DIR = join(__dirname, '..', '..', 'framework');
-
-/**
- * Headless infrastructure setup — no prompts, no stack detection, no MCPs.
- * Called by /morph-init skill and by morph-spec init (delegated).
- * @param {string} targetPath - Project root
- */
-export async function setupInfra(targetPath) {
-  const quiet = process.env.MORPH_QUIET === '1';
-  const spinner = quiet ? { text: '', start() {}, stop() {}, succeed() {}, warn() {} } : ora('Installing MORPH-SPEC infrastructure...').start();
-
-  const morphPath = join(targetPath, '.morph');
-  const configDir = join(morphPath, 'config');
-  const frameworkDestDir = join(morphPath, 'framework');
-  const contextDir = join(morphPath, 'context');
-  const featuresDir = join(morphPath, 'features');
-  const claudeDest = join(targetPath, '.claude');
-  const dirName = targetPath.split(/[\\/]/).pop();
-
-  // 1. Copy CLAUDE.md
-  const claudeMdSrc = join(FRAMEWORK_DIR, 'CLAUDE.md');
-  const claudeMdDest = join(targetPath, 'CLAUDE.md');
-  if (await pathExists(claudeMdSrc)) {
-    if (await pathExists(claudeMdDest)) {
-      const existing = await fs.readFile(claudeMdDest, 'utf8');
-      if (!existing.includes('MORPH-SPEC')) {
-        await copyFile(claudeMdDest, `${claudeMdDest}.backup`);
-      }
-    }
-    await copyFile(claudeMdSrc, claudeMdDest);
-  }
-
-  // 2. Create .morph structure
-  for (const d of [configDir, frameworkDestDir, contextDir, featuresDir,
-    join(morphPath, 'checkpoints'), join(morphPath, 'memory'), join(morphPath, 'archive')]) {
-    await ensureDir(d);
-  }
-
-  // 3. Write minimal config.json (NO stack/architecture — skill fills these)
-  const configPath = join(configDir, 'config.json');
-  if (!(await pathExists(configPath))) {
-    await writeJson(configPath, {
-      framework: 'global',
-      frameworkVersion: getInstalledCLIVersion(),
-      project: { name: dirName }
-    });
-  }
-
-  // 4. Write placeholder context/README.md
-  const contextReadme = join(contextDir, 'README.md');
-  if (!(await pathExists(contextReadme))) {
-    await writeFile(contextReadme, `# ${dirName} — Project Context\n\nRun /morph-init to generate project context.\n`);
-  }
-
-  // 5. Copy framework templates
-  const templatesSrc = join(FRAMEWORK_DIR, 'templates');
-  if (await pathExists(templatesSrc)) {
-    await copyDirectory(templatesSrc, join(frameworkDestDir, 'templates'));
-  }
-
-  // 6. Copy framework standards
-  const standardsSrc = join(FRAMEWORK_DIR, 'standards');
-  if (await pathExists(standardsSrc)) {
-    await copyDirectory(standardsSrc, join(frameworkDestDir, 'standards'));
-  }
-
-  // 6c. Copy hooks
-  const hooksSrc = join(FRAMEWORK_DIR, 'hooks');
-  if (await pathExists(hooksSrc)) {
-    await copyDirectory(hooksSrc, join(frameworkDestDir, 'hooks'));
-  }
-
-  // 7. Copy agents.json
-  const agentsSrc = join(FRAMEWORK_DIR, 'agents.json');
-  if (await pathExists(agentsSrc)) {
-    await copyFile(agentsSrc, join(frameworkDestDir, 'agents.json'));
-  }
-
-  // 8. Copy commands
-  const commandsSrc = join(FRAMEWORK_DIR, 'commands');
-  if (await pathExists(commandsSrc)) {
-    await copyDirectory(commandsSrc, join(claudeDest, 'commands'));
-  }
-
-  // 9a. Install rules
-  const rulesSrc = join(FRAMEWORK_DIR, 'rules');
-  if (await pathExists(rulesSrc)) {
-    await copyDirectory(rulesSrc, join(claudeDest, 'rules'));
-  }
-
-  // 9b. Install skills, agents, domain agents, CLAUDE.md
-  await installSkills(targetPath);
-  await installAgents(targetPath, FRAMEWORK_DIR, { projectStack: null });
-  await installDomainAgents(targetPath, FRAMEWORK_DIR);
-  const runtimeClaudeMdSrc = join(FRAMEWORK_DIR, 'CLAUDE.md');
-  if (await pathExists(runtimeClaudeMdSrc)) {
-    await copyFile(runtimeClaudeMdSrc, join(claudeDest, 'CLAUDE.md'));
-  }
-
-  // 9c. Statusline (global, non-critical)
-  try {
-    await installGlobalStatusline(join(FRAMEWORK_DIR, 'hooks', 'claude-code'));
-  } catch { /* non-critical */ }
-
-  // 9d. Hooks
-  await installClaudeHooks(targetPath);
-
-  // 10. Version info
-  await saveProjectMorphVersion(targetPath);
-
-  // 11. .gitignore
-  await updateGitignore(targetPath);
-
-  spinner.succeed('MORPH-SPEC infrastructure installed.');
-  return { targetPath, dirName };
-}
-```
-
-**Step 4: Run tests**
-
-```bash
-node --test test/scripts/setup-infra.test.js
-```
-
-Expected: all tests PASS
-
-**Step 5: Create `src/commands/project/setup-infra-cmd.js` (thin CLI wrapper)**
-
-```js
-// src/commands/project/setup-infra-cmd.js
-import { setupInfra } from '../../scripts/setup-infra.js';
-import { logger } from '../../utils/logger.js';
-
-export async function setupInfraCommand(options) {
-  const targetPath = options.path || process.cwd();
-  try {
-    await setupInfra(targetPath);
-  } catch (err) {
-    logger.error(`setup-infra failed: ${err.message}`);
-    process.exit(1);
-  }
-}
-```
-
-**Step 6: Register in `bin/morph-spec.js`**
-
-Add import at top (with other project commands):
-```js
-import { setupInfraCommand } from '../src/commands/project/setup-infra-cmd.js';
-```
-
-Add command registration after the `init` block (line ~109):
-```js
-program
-  .command('setup-infra')
-  .description('Install MORPH-SPEC infrastructure (headless, no prompts). Called by /morph-init skill.')
-  .option('-p, --path <path>', 'Target path (default: current directory)')
-  .action(setupInfraCommand);
-```
-
-**Step 7: Verify CLI command works**
-
-```bash
-morph-spec setup-infra --help
-```
-Expected: shows description and `--path` option.
-
-**Step 8: Commit**
-
-```bash
-git add src/scripts/setup-infra.js src/commands/project/setup-infra-cmd.js bin/morph-spec.js test/scripts/setup-infra.test.js
-git commit -m "feat(cli): add setup-infra.js + morph-spec setup-infra command — headless infra extracted from init.js"
-```
-
----
-
-## Task 2: Create `src/scripts/install-plugin.js` + `morph-spec install-plugin` command
-
-Downloads a plugin from `anthropics/claude-plugins-official` GitHub, registers it in `~/.claude/plugins/installed_plugins.json`, and exposes the logic as a CLI subcommand callable from any user project.
-
-**Files:**
-
-- Create: `src/scripts/install-plugin.js` — pure logic
-- Create: `src/commands/project/install-plugin-cmd.js` — thin CLI wrapper
-- Modify: `bin/morph-spec.js` — register `morph-spec install-plugin <name>`
-- Create: `test/scripts/install-plugin.test.js`
-
-**Step 1: Write failing tests**
-
-```js
-// test/scripts/install-plugin.test.js
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  isPluginInstalled,
-  buildInstallEntry,
-  resolvePluginVersion
-} from '../../src/scripts/install-plugin.js';
-
-describe('install-plugin utils', () => {
-  test('isPluginInstalled returns true when plugin key exists', () => {
-    const plugins = {
-      'superpowers@claude-plugins-official': [{ scope: 'user', version: '4.3.1' }]
-    };
-    assert.strictEqual(isPluginInstalled(plugins, 'superpowers'), true);
-  });
-
-  test('isPluginInstalled returns false when plugin is absent', () => {
-    assert.strictEqual(isPluginInstalled({}, 'superpowers'), false);
-  });
-
-  test('buildInstallEntry returns valid entry shape', () => {
-    const entry = buildInstallEntry('superpowers', '/some/path', 'abc123', '4.3.1');
-    assert.strictEqual(entry.scope, 'user');
-    assert.strictEqual(entry.version, '4.3.1');
-    assert.strictEqual(entry.gitCommitSha, 'abc123');
-    assert.ok(entry.installedAt);
-    assert.ok(entry.lastUpdated);
-    assert.ok(entry.installPath.includes('superpowers'));
-  });
-
-  test('resolvePluginVersion returns sha string for known plugin', async () => {
-    // Uses real GitHub API — skip in offline CI
-    if (process.env.CI) return;
-    const { sha } = await resolvePluginVersion('context7');
-    assert.ok(typeof sha === 'string' && sha.length > 0, 'sha must be non-empty string');
-  });
-});
-```
-
-**Step 2: Run to verify failure**
-
-```bash
-node --test test/scripts/install-plugin.test.js
-```
-
-Expected: FAIL — module not found
-
-**Step 3: Implement `src/scripts/install-plugin.js`**
-
-```js
-// src/scripts/install-plugin.js
-import { join } from 'path';
-import { homedir } from 'os';
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
-import { mkdir, writeFile } from 'fs/promises';
-import https from 'node:https';
-
-const PLUGINS_DIR = join(homedir(), '.claude', 'plugins');
-const CACHE_DIR = join(PLUGINS_DIR, 'cache', 'claude-plugins-official');
-const INSTALLED_FILE = join(PLUGINS_DIR, 'installed_plugins.json');
-const GH_REPO = 'anthropics/claude-plugins-official';
-const GH_API = 'https://api.github.com';
-
-/** Fetch JSON from GitHub API */
-async function fetchGitHub(path) {
-  return new Promise((resolve, reject) => {
-    const opts = {
-      hostname: 'api.github.com',
-      path,
-      headers: { 'User-Agent': 'morph-spec', 'Accept': 'application/vnd.github.v3+json' }
-    };
-    https.get(opts, (res) => {
-      let data = '';
-      res.on('data', c => data += c);
-      res.on('end', () => {
-        try { resolve(JSON.parse(data)); }
-        catch (e) { reject(new Error(`GitHub API parse error: ${data.slice(0, 200)}`)); }
-      });
-    }).on('error', reject);
-  });
-}
-
-/** Download raw file from GitHub */
-async function downloadFile(downloadUrl) {
-  return new Promise((resolve, reject) => {
-    https.get(downloadUrl, { headers: { 'User-Agent': 'morph-spec' } }, (res) => {
-      // Follow redirects
-      if (res.statusCode === 302 || res.statusCode === 301) {
-        const url = new URL(res.headers.location);
-        https.get({ hostname: url.hostname, path: url.pathname + url.search,
-          headers: { 'User-Agent': 'morph-spec' } }, (res2) => {
-          const chunks = [];
-          res2.on('data', c => chunks.push(c));
-          res2.on('end', () => resolve(Buffer.concat(chunks)));
-        }).on('error', reject);
-        return;
-      }
-      const chunks = [];
-      res.on('data', c => chunks.push(c));
-      res.on('end', () => resolve(Buffer.concat(chunks)));
-    }).on('error', reject);
-  });
-}
-
-/** Read installed_plugins.json, return parsed object */
-function readInstalledPlugins() {
-  if (!existsSync(INSTALLED_FILE)) return { version: 2, plugins: {} };
-  try { return JSON.parse(readFileSync(INSTALLED_FILE, 'utf8')); }
-  catch { return { version: 2, plugins: {} }; }
-}
-
-/** Check if plugin is already installed */
-export function isPluginInstalled(plugins, name) {
-  return `${name}@claude-plugins-official` in plugins;
-}
-
-/** Resolve plugin version + commit SHA from GitHub */
-export async function resolvePluginVersion(pluginName) {
-  const commits = await fetchGitHub(`/repos/${GH_REPO}/commits?path=${pluginName}&per_page=1`);
-  if (!Array.isArray(commits) || commits.length === 0) {
-    throw new Error(`Could not resolve version for plugin: ${pluginName}`);
-  }
-  const sha = commits[0].sha;
-  const shortSha = sha.slice(0, 12);
-  return { sha, shortSha };
-}
-
-/** Build installed_plugins.json entry */
-export function buildInstallEntry(pluginName, installPath, gitCommitSha, version) {
-  const now = new Date().toISOString();
-  return { scope: 'user', installPath, version, installedAt: now, lastUpdated: now, gitCommitSha };
-}
-
-/** Download plugin directory recursively from GitHub */
-async function downloadPluginFiles(pluginName, sha, destDir) {
-  const tree = await fetchGitHub(`/repos/${GH_REPO}/git/trees/${sha}?recursive=1`);
-  if (!tree.tree) throw new Error('GitHub tree API returned unexpected shape');
-
-  const pluginFiles = tree.tree.filter(
-    f => f.path.startsWith(`${pluginName}/`) && f.type === 'blob'
-  );
-
-  if (pluginFiles.length === 0) {
-    throw new Error(`Plugin "${pluginName}" not found in repository`);
-  }
-
-  for (const file of pluginFiles) {
-    const relativePath = file.path.slice(pluginName.length + 1); // strip "pluginName/"
-    const destPath = join(destDir, relativePath);
-    const destParent = join(destPath, '..');
-    await mkdir(destParent, { recursive: true });
-
-    const content = await downloadFile(
-      `https://raw.githubusercontent.com/${GH_REPO}/${sha}/${file.path}`
-    );
-    await writeFile(destPath, content);
-  }
-}
-
-/**
- * Install a Claude Code plugin from GitHub.
- * @param {string} pluginName - e.g. "superpowers"
- * @returns {{ installed: boolean, version: string, alreadyInstalled: boolean }}
- */
-export async function installPlugin(pluginName) {
-  const data = readInstalledPlugins();
-
-  if (isPluginInstalled(data.plugins, pluginName)) {
-    return { installed: true, alreadyInstalled: true, version: 'existing' };
-  }
-
-  const { sha, shortSha } = await resolvePluginVersion(pluginName);
-  const installPath = join(CACHE_DIR, pluginName, shortSha);
-
-  await mkdir(installPath, { recursive: true });
-  await downloadPluginFiles(pluginName, sha, installPath);
-
-  const entry = buildInstallEntry(pluginName, installPath, sha, shortSha);
-  data.plugins[`${pluginName}@claude-plugins-official`] = [entry];
-
-  mkdirSync(PLUGINS_DIR, { recursive: true });
-  writeFileSync(INSTALLED_FILE, JSON.stringify(data, null, 2));
-
-  return { installed: true, alreadyInstalled: false, version: shortSha };
-}
-```
-
-**Step 4: Run tests**
-
-```bash
-node --test test/scripts/install-plugin.test.js
-```
-
-Expected: unit tests PASS (resolvePluginVersion skipped in CI)
-
-**Step 5: Create `src/commands/project/install-plugin-cmd.js` (thin CLI wrapper)**
-
-```js
-// src/commands/project/install-plugin-cmd.js
-import { installPlugin } from '../../scripts/install-plugin.js';
-import { logger } from '../../utils/logger.js';
-
-export async function installPluginCommand(pluginName, _options) {
-  if (!pluginName) {
-    logger.error('Plugin name required. Usage: morph-spec install-plugin <name>');
-    logger.dim('  Available: superpowers, context7');
-    process.exit(1);
-  }
-  try {
-    const result = await installPlugin(pluginName);
-    if (result.alreadyInstalled) {
-      logger.dim(`  ✓ ${pluginName} already installed (${result.version})`);
-    } else {
-      logger.success(`  ✓ ${pluginName} installed (${result.version})`);
-      logger.dim('  Restart Claude Code to activate.');
-    }
-  } catch (err) {
-    logger.error(`Failed to install plugin "${pluginName}": ${err.message}`);
-    logger.blank();
-    logger.warn('Manual installation:');
-    logger.dim('  1. Claude Code → Settings (Cmd/Ctrl+,) → Extensions');
-    logger.dim(`  2. Browse → search "${pluginName}" → Install`);
-    logger.dim('  3. Restart Claude Code');
-    process.exit(1);
-  }
-}
-```
-
-**Step 6: Register in `bin/morph-spec.js`**
-
-Add import at top (with other project commands):
-```js
-import { installPluginCommand } from '../src/commands/project/install-plugin-cmd.js';
-```
-
-Add command registration after `setup-infra` block:
-```js
-program
-  .command('install-plugin <name>')
-  .description('Install a Claude Code plugin (superpowers, context7). Called by /morph-init skill.')
-  .action(installPluginCommand);
-```
-
-**Step 7: Verify CLI command works**
-
-```bash
-morph-spec install-plugin --help
-morph-spec install-plugin superpowers
-```
-Expected: help shows `<name>` argument; install succeeds or prints manual guide on failure.
-
-**Step 8: Commit**
-
-```bash
-git add src/scripts/install-plugin.js src/commands/project/install-plugin-cmd.js bin/morph-spec.js test/scripts/install-plugin.test.js
-git commit -m "feat(cli): add install-plugin.js + morph-spec install-plugin command — auto-install CC plugins from GitHub"
-```
-
----
-
-## Task 3: Create `src/scripts/global-install.js` + package.json postinstall
-
-Copies `morph-init/SKILL.md` to `~/.claude/skills/morph-init/SKILL.md` on npm install.
-
-**Files:**
-
-- Create: `src/scripts/global-install.js`
-- Create: `test/scripts/global-install.test.js`
-- Modify: `package.json`
-
-**Step 1: Write failing tests**
-
-```js
-// test/scripts/global-install.test.js
-import { test, describe, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { createTempDir, cleanupTempDir } from '../helpers/test-utils.js';
-import { installGlobalSkill } from '../../src/scripts/global-install.js';
-
-describe('global-install', () => {
-  let tempGlobalDir;
-  beforeEach(() => { tempGlobalDir = createTempDir(); });
-  afterEach(() => { cleanupTempDir(tempGlobalDir); });
-
-  test('copies morph-init/SKILL.md to target global skills dir', async () => {
-    await installGlobalSkill(tempGlobalDir);
-    const skillPath = join(tempGlobalDir, 'skills', 'morph-init', 'SKILL.md');
-    assert.ok(existsSync(skillPath), 'morph-init/SKILL.md must be copied to global skills dir');
-  });
-
-  test('is idempotent — safe to run twice', async () => {
-    await installGlobalSkill(tempGlobalDir);
-    await installGlobalSkill(tempGlobalDir);
-    assert.ok(existsSync(join(tempGlobalDir, 'skills', 'morph-init', 'SKILL.md')));
-  });
-});
-```
-
-**Step 2: Run to verify failure**
-
-```bash
-node --test test/scripts/global-install.test.js
-```
-
-Expected: FAIL — module not found (and `morph-init/SKILL.md` doesn't exist yet — that's Task 4)
-
-**Step 3: Implement `src/scripts/global-install.js`**
-
-```js
-// src/scripts/global-install.js
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { homedir } from 'os';
-import { mkdir, copyFile, writeFile } from 'fs/promises';
-import { existsSync } from 'fs';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const FRAMEWORK_DIR = join(__dirname, '..', '..', 'framework');
-
-/**
- * Install morph-init skill to a target global Claude dir.
- * @param {string} claudeDir - defaults to ~/.claude/
- */
-export async function installGlobalSkill(claudeDir = join(homedir(), '.claude')) {
-  const src = join(FRAMEWORK_DIR, 'skills', 'level-0-meta', 'morph-init', 'SKILL.md');
-  const destDir = join(claudeDir, 'skills', 'morph-init');
-  const dest = join(destDir, 'SKILL.md');
-
-  if (!existsSync(src)) {
-    console.warn(`morph-init skill not found at ${src} — skipping global install`);
-    return;
-  }
-
-  await mkdir(destDir, { recursive: true });
-  await copyFile(src, dest);
-}
-
-// Entrypoint when run as postinstall script
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  installGlobalSkill()
-    .then(() => console.log('✓ morph-init skill installed to ~/.claude/skills/'))
-    .catch(e => console.warn('Could not install morph-init skill globally:', e.message));
-}
-```
-
-**Step 4: Add postinstall to `package.json`**
-
-In `package.json`, add to `"scripts"`:
-
-```json
-"postinstall": "node src/scripts/global-install.js"
-```
-
-**Step 5: Run tests** (after Task 4 creates the SKILL.md)
-
-```bash
-node --test test/scripts/global-install.test.js
-```
-
-Expected: PASS after Task 4
-
-**Step 6: Commit**
-
-```bash
-git add src/scripts/global-install.js test/scripts/global-install.test.js package.json
-git commit -m "feat(scripts): add global-install.js — postinstall copies morph-init skill to ~/.claude/skills/"
-```
-
----
-
-## Task 4: `framework/skills/level-0-meta/morph-init/SKILL.md`
-
-The main user-facing skill. Already created — verify it uses the correct CLI commands.
-
-**Key constraint:** All `morph-spec` CLI calls in the skill work in any user project because `morph-spec` is globally installed. Do NOT reference `node src/scripts/...` or any path relative to the framework repo.
-
-**Files:**
-
-- Verify: `framework/skills/level-0-meta/morph-init/SKILL.md` — already exists
-
-**Step 1: Verify correct CLI commands in SKILL.md**
-
-The skill must use:
-```bash
-morph-spec install-plugin superpowers   # ✓ CLI subcommand — works anywhere
-morph-spec install-plugin context7      # ✓ CLI subcommand — works anywhere
-morph-spec setup-infra                  # ✓ CLI subcommand — works anywhere
-```
-
-Not:
-```bash
-node {MORPH_ROOT}/src/scripts/...       # ✗ path only exists in framework repo
-npx morph-spec ...                      # ✗ may download wrong version
-```
-
-Read the file and confirm:
-```bash
-grep -n "morph-spec\|node.*scripts\|MORPH_ROOT" framework/skills/level-0-meta/morph-init/SKILL.md
-```
-Expected: only `morph-spec install-plugin` and `morph-spec setup-infra` patterns.
-
-**Step 2 (previously Step 1): The skill file content is**
-
-```markdown
----
-name: morph-init
-description: >
-  LLM-powered project initialization. Installs morph-spec infrastructure if
-  needed, auto-installs required plugins (superpowers, context7), analyzes any
-  project structure intelligently, generates rich context/README.md and
-  config.json, and configures MCPs. Use once per project after installing
-  @polymorphism-tech/morph-spec. Re-run with /morph-init refresh to update
-  context as the project evolves.
-argument-hint: "[refresh]"
-user-invocable: true
-allowed-tools: Read, Write, Edit, Bash, Glob, Grep
----
-
-# morph-init — LLM-Powered Project Initialization
-
-> Run once after `npm install @polymorphism-tech/morph-spec`.
-> Re-run as `/morph-init refresh` when your project evolves.
-
----
-
-## Step 0 — Required Plugins
-
-Check for required Claude Code plugins: **superpowers** and **context7**.
-
-```bash
-# Detect morph-spec package root
-node -e "const r=require.resolve('@polymorphism-tech/morph-spec/package.json'); console.log(require('path').dirname(r))"
-```
-
-Then check `~/.claude/plugins/installed_plugins.json` for:
-
-- `superpowers@claude-plugins-official`
-- `context7@claude-plugins-official`
-
-For each missing plugin, run:
-
-```bash
-node {MORPH_ROOT}/src/scripts/install-plugin.js {plugin-name}
-```
-
-**If auto-install succeeds:** `✓ {plugin} installed.`
-
-**If auto-install fails:** Show this and STOP:
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│  Plugin {plugin} requires manual installation:              │
-│                                                             │
-│  1. Claude Code → Settings (Cmd/Ctrl+,) → Extensions        │
-│  2. Browse → search "{plugin}" → Install                    │
-│  3. Restart Claude Code                                     │
-│  4. Re-run /morph-init                                      │
-└─────────────────────────────────────────────────────────────┘
-```
-
-Do not continue if either plugin is missing or failed to install.
-
----
-
-## Step 1 — Infrastructure
-
-Check if `.morph/` exists in the current directory.
-
-**If MISSING:**
-
-```bash
-npx morph-spec setup-infra
-```
-
-Output: `✓ Infrastructure installed`
-
-**If EXISTS and argument is "refresh":** Continue.
-
-**If EXISTS and no argument:**
-Ask: *"MORPH already initialized. Refresh context and config? (y/n)"*
-If `n` → STOP.
-
----
-
-## Step 2 — Analyze Project
-
-Gather evidence to build a stack map. Run these searches:
-
-
-| Tool                              | What to look for                                     |
-| --------------------------------- | ---------------------------------------------------- |
-| `Glob **/package.json`            | Detect next, supabase, clerk, stripe, shadcn in deps |
-| `Glob **/*.csproj`                | .NET projects at any depth                           |
-| `Glob **/next.config.{js,ts,mjs}` | Next.js in any subdirectory                          |
-| `Glob **/components.json`         | shadcn/ui                                            |
-| `Glob **/docker-compose*.yml`     | Container services                                   |
-| `Glob database/migrations/`**     | Supabase local dev                                   |
-| `Glob supabase/**`                | Supabase project config                              |
-| `Glob **/*.razor`                 | Blazor                                               |
-| `Read .env.example`               | Env vars reveal integrations                         |
-| `Read README.md`                  | Existing project description                         |
-| `Grep @supabase/supabase-js`      | Supabase dependency                                  |
-| `Grep clerk|auth0|nextauth`       | Auth provider                                        |
-| `Grep stripe|asaas`               | Payment provider                                     |
-
-
-Read each found `package.json` to extract dependency names.
-
-Build an **evidence map**:
-
-```
-stack: [detected stacks]
-integrations: [detected services]
-uiLibrary: [shadcn | fluent-ui | mudblazor | tailwind | null]
-monorepo: [true | false]
-frontendPath: [path if monorepo]
-backendPath: [path if monorepo]
-```
-
----
-
-## Step 3 — Ask Targeted Questions
-
-**Rule: only ask what cannot be inferred with ≥90% confidence from files.**
-
-Ask at most 3 questions, only those that apply:
-
-1. **(Always)** "Em uma frase: qual é o objetivo principal do **[ProjectName]**?" - use askUser tool and suggest 3 + one to user input
-2. **(If monorepo detected)** "Confirmo: frontend em `{frontendPath}`, backend em `{backendPath}`. Correto?"
-  — If no: "Como está organizado? Descreva brevemente."
-3. **(If Supabase detected)** "Supabase Cloud (managed) ou self-hosted?"
-
-Do **not** ask about technology confirmed by file evidence.
-
----
-
-## Step 4 — Generate `context/README.md`
-
-Write `.morph/context/README.md` using the evidence map and answers:
-
-```markdown
-# [ProjectName] — Project Context
-
-## Overview
-[Answer from question 1]
-
-## Tech Stack
-| Layer      | Technology | Location |
-|------------|-----------|----------|
-[One row per detected layer]
-
-## Architecture
-[monorepo / single-stack / etc — describe structure and responsibilities]
-
-## Key Integrations
-[service → purpose — detected via: evidence]
-
-## Agent Notes
-[Patterns detected from eslint/tsconfig/.editorconfig, important paths,
- conventions relevant to MORPH agents working on this project]
-```
-
----
-
-## Step 5 — Update `config.json`
-
-Read `.morph/config/config.json` and update `project` section:
-
-```json
-{
-  "framework": "global",
-  "frameworkVersion": "[current version]",
-  "project": {
-    "name": "[ProjectName]",
-    "description": "[answer from question 1]",
-    "stack": "[detected stacks joined with +]",
-    "architecture": "[monorepo | single-stack | detected pattern]",
-    "uiLibrary": "[detected or null]",
-    "integrations": ["[list of detected integrations]"],
-    "frontendPath": "[if monorepo]",
-    "backendPath": "[if monorepo]"
-  }
-}
-```
-
----
-
-## Step 6 — Configure MCPs
-
-For each detected integration with an available MCP:
-
-**Supabase:**
-
-> "Configure Supabase MCP now? I'll need `SUPABASE_URL` and `SERVICE_ROLE_KEY`."
-
-- YES: collect credentials → add to `.claude/settings.local.json` under `mcpServers`
-- NO: show snippet + `morph-spec mcp setup supabase`
-
-**GitHub:**
-
-> "Configure GitHub MCP? I'll need a `GITHUB_PERSONAL_ACCESS_TOKEN`."
-
-- YES/NO: same pattern
-
-Only ask about Figma, Docker, Azure if explicitly detected in `.env.example`.
-
----
-
-## Step 7 — Final Output
-
-Print summary:
-
-```
-✓ Plugins: superpowers ✓   context7 ✓
-✓ Infrastructure: .morph/ structure, hooks, agents, rules, skills
-✓ context/README.md generated
-✓ config.json updated
-  Stack: [stack]  |  Architecture: [architecture]
-  Integrations: [integrations]
-✓ MCPs: [configured]
-
-[If any plugins were newly installed:]
-○ Restart Claude Code to activate newly installed plugins.
-
-Next: /morph-proposal [feature-name]
-```
-
-```
-
-**Step 2: Verify file is valid**
-
-```bash
-# Verify YAML frontmatter parses correctly
-node -e "
-const fs = require('fs');
-const content = fs.readFileSync('framework/skills/level-0-meta/morph-init/SKILL.md', 'utf8');
-const match = content.match(/^---\n([\s\S]*?)\n---/);
-console.log(match ? 'YAML frontmatter present ✓' : 'MISSING frontmatter ✗');
-console.log('File size:', content.length, 'bytes');
-"
-```
-
-**Step 3: Update `skills-installer.js` to include morph-init**
-
-In `src/utils/skills-installer.js`, verify that `morph-init` is picked up from `level-0-meta/` — it should be included automatically if the installer scans all subdirectories. Confirm with:
-
-```bash
-node -e "
-import { installSkills } from './src/utils/skills-installer.js';
-" 2>/dev/null || node --input-type=module <<'EOF'
-import { createRequire } from 'module';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-// Just verify the SKILL.md exists at the right path
-import { existsSync } from 'fs';
-const p = 'framework/skills/level-0-meta/morph-init/SKILL.md';
-console.log(existsSync(p) ? `✓ ${p} exists` : `✗ ${p} MISSING`);
-EOF
-```
-
-**Step 4: Run global-install tests (from Task 3)**
-
-```bash
-node --test test/scripts/global-install.test.js
-```
-
-Expected: PASS now that SKILL.md exists
-
-**Step 5: Commit**
-
-```bash
-git add framework/skills/level-0-meta/morph-init/SKILL.md
-git commit -m "feat(skills): add morph-init skill — LLM-powered project initialization entry point"
-```
-
----
-
-## Task 5: Refactor `init.js` to delegate to `setup-infra.js`
-
-`init.js` keeps its interactive flow but delegates infrastructure work to `setupInfra()`. Remove duplicate code.
-
-**Files:**
-
-- Modify: `src/commands/project/init.js`
-- Review: `test/commands/init.test.js` (should still pass)
-
-**Step 1: Run existing init tests to establish baseline**
-
-```bash
-node --test test/commands/init.test.js
-```
-
-Note how many tests pass. Target: same count after refactor.
-
-**Step 2: Refactor `init.js`**
-
-Replace steps 1–10 in `init.js` (lines 54–220 approximately) with a single call:
-
-```js
-import { setupInfra } from '../../scripts/setup-infra.js';
-
-// Replace steps 1-10 with:
-spinner.stop();
-await setupInfra(targetPath);
-spinner.start('Continuing...');
-
-// Then keep: steps 11b (Claude config detection), 11c (stack detection → update config),
-//            11d (MCP setup), final output
-```
-
-The stack detection block (step 11c) still runs — it now UPDATES the config.json that `setupInfra` created. The key difference: `setupInfra` writes a minimal config first, then `init.js` enriches it.
-
-**Step 3: Run init tests**
-
-```bash
-node --test test/commands/init.test.js
-```
-
-Expected: same pass count as baseline
-
-**Step 4: Fix `structure-detector.js` — Next.js subdirectory patterns**
-
-In `src/lib/detectors/structure-detector.js`, change the `nextjs` patterns in `detectStack()`:
-
-```js
-// BEFORE (line 60-65):
-nextjs: [
-  'next.config.js',
-  'next.config.mjs',
-  'next.config.ts',
-  'pages/**/*.tsx',
-  'app/**/*.tsx'
-],
-
-// AFTER:
-nextjs: [
-  '**/next.config.js',
-  '**/next.config.mjs',
-  '**/next.config.ts',
-  'pages/**/*.tsx',
-  'app/**/*.tsx',
-  '**/pages/**/*.tsx',
-  '**/app/**/*.tsx'
-],
-```
-
-**Step 5: Verify ProspectPRO detection works**
-
-```bash
-node -e "
-import { detectStructure } from './src/lib/detectors/structure-detector.js';
-" 2>/dev/null || node --input-type=module <<'EOF'
-import { detectStructure } from './src/lib/detectors/structure-detector.js';
-const result = await detectStructure('R:/Polymorphism Tech/repos/ProspectPRO');
-console.log('Stack:', result.stack);        // expect: nextjs
-console.log('Architecture:', result.architecture);
-EOF
-```
-
-Expected: stack = `nextjs` (no longer `dotnet`)
-
-**Step 6: Commit**
-
-```bash
-git add src/commands/project/init.js src/lib/detectors/structure-detector.js
-git commit -m "refactor(init): delegate infrastructure to setup-infra.js; fix nextjs subdirectory detection"
-```
-
----
-
-## Task 6: Add plugin checks to `morph-spec doctor`
-
-**Files:**
-
-- Modify: `src/commands/project/doctor.js`
-- Modify: `test/commands/doctor.test.js`
-
-**Step 1: Write failing tests**
-
-In `test/commands/doctor.test.js`, add to the existing test suite:
-
-```js
-describe('doctor plugin checks', () => {
-  test('checkInstalledPlugins returns present for superpowers when in installed_plugins.json', async () => {
-    const { checkInstalledPlugins } = await import('../../src/commands/project/doctor.js');
-    const fakePlugins = {
-      'superpowers@claude-plugins-official': [{ scope: 'user', version: '4.3.1' }],
-      'context7@claude-plugins-official': [{ scope: 'user', version: 'abc123' }]
-    };
-    const result = checkInstalledPlugins(fakePlugins);
-    assert.strictEqual(result.superpowers, true);
-    assert.strictEqual(result.context7, true);
-  });
-
-  test('checkInstalledPlugins returns false for missing plugin', async () => {
-    const { checkInstalledPlugins } = await import('../../src/commands/project/doctor.js');
-    const result = checkInstalledPlugins({ 'superpowers@claude-plugins-official': [] });
-    assert.strictEqual(result.superpowers, true);
-    assert.strictEqual(result.context7, false);
-  });
-});
-```
-
-**Step 2: Run to verify failure**
-
-```bash
-node --test test/commands/doctor.test.js 2>&1 | tail -20
-```
-
-Expected: new tests FAIL — `checkInstalledPlugins` not exported
-
-**Step 3: Add `checkInstalledPlugins` and plugin check section to `doctor.js`**
-
-Add exported function:
-
-```js
-export function checkInstalledPlugins(pluginsData) {
-  const REQUIRED = ['superpowers', 'context7'];
-  return Object.fromEntries(
-    REQUIRED.map(name => [name, `${name}@claude-plugins-official` in pluginsData])
-  );
-}
-```
-
-In `doctorProjectCommand()` function, after the skills/agents checks block, add:
-
-```js
-// ── Claude Code Plugins ──────────────────────────────────────────────────
-console.log(chalk.cyan('\n  Claude Code Plugins (required)'));
-const pluginsFile = join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
-let pluginData = { plugins: {} };
-try {
-  pluginData = JSON.parse(await fs.readFile(pluginsFile, 'utf8'));
-} catch { /* file may not exist */ }
-const pluginStatus = checkInstalledPlugins(pluginData.plugins || {});
-check('superpowers plugin', pluginStatus.superpowers, false,
-  'Install via: Claude Code → Settings → Extensions → superpowers');
-check('context7 plugin', pluginStatus.context7, false,
-  'Install via: Claude Code → Settings → Extensions → context7. Or run /morph-init');
-```
-
-**Step 4: Run tests**
-
-```bash
-node --test test/commands/doctor.test.js
-```
-
-Expected: all tests PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/commands/project/doctor.js test/commands/doctor.test.js
-git commit -m "feat(doctor): add Claude Code plugin checks for superpowers and context7"
-```
-
----
-
-## Task 7: Full test suite + final validation
-
-**Step 1: Run full test suite**
-
-```bash
-cd "R:/Polymorphism Tech/repos/morph-spec-framework"
-node --test --test-concurrency=1 2>&1 | tail -20
-```
-
-Expected: all existing tests pass + new tests pass. Zero failures.
-
-**Step 2: Verify `morph-init` skill is picked up by skills-installer**
-
-```bash
-node --input-type=module <<'EOF'
-import { installSkills } from './src/utils/skills-installer.js';
-import { createTempDir, cleanupTempDir } from './test/helpers/test-utils.js';
-import { existsSync } from 'fs';
-import { join } from 'path';
-const tmp = createTempDir();
-await installSkills(tmp);
-const p = join(tmp, '.claude', 'skills', 'morph-init', 'SKILL.md');
-console.log(existsSync(p) ? '✓ morph-init installed by skills-installer' : '✗ MISSING');
-cleanupTempDir(tmp);
-EOF
-```
-
-**Step 3: Manual smoke test — simulate `/morph-init` on ProspectPRO**
-
-Open Claude Code in `R:/Polymorphism Tech/repos/ProspectPRO` and run:
-
-```
-/morph-init refresh
-```
-
-Verify:
-
-- Plugins detected as already installed (superpowers + context7)
-- `.morph/` infrastructure confirmed present
-- Project analyzed: detects nextjs + dotnet + supabase
-- 3 targeted questions asked (not more)
-- `.morph/context/README.md` contains rich content (no `(To be detected)`)
-- `.morph/config/config.json` has `stack: "nextjs+dotnet"`, `integrations: ["supabase", ...]`
-- MCP setup offered for Supabase
-
-**Step 4: Final commit**
-
-```bash
-git add .
-git commit -m "feat(morph-init): complete LLM-powered initialization system
-
-- setup-infra.js: headless infrastructure extracted from init.js
-- install-plugin.js: auto-install superpowers/context7 from GitHub
-- global-install.js: postinstall copies morph-init skill globally
-- morph-init/SKILL.md: single user-facing entry point
-- init.js: refactored to delegate to setup-infra
-- doctor.js: plugin presence checks
-- structure-detector.js: nextjs subdirectory detection fixed"
-```
-
----
-
-## Summary
-
-
-| Task | New Files / Changes | Tests |
-|------|--------------------|----|
-| 1 | `src/scripts/setup-infra.js` + `src/commands/project/setup-infra-cmd.js` + `bin/morph-spec.js` (`morph-spec setup-infra`) | `test/scripts/setup-infra.test.js` (9 tests) |
-| 2 | `src/scripts/install-plugin.js` + `src/commands/project/install-plugin-cmd.js` + `bin/morph-spec.js` (`morph-spec install-plugin <name>`) | `test/scripts/install-plugin.test.js` (4 tests) |
-| 3 | `src/scripts/global-install.js` + `package.json` postinstall | `test/scripts/global-install.test.js` (2 tests) |
-| 4 | `framework/skills/level-0-meta/morph-init/SKILL.md` (verify CLI commands) | Manual grep validation |
-| 5 | Refactor `init.js` + fix `structure-detector.js` | Existing `init.test.js` |
-| 6 | `doctor.js` plugin checks | 2 new tests in `doctor.test.js` |
-| 7 | Full suite + smoke test | All tests green |
-
-**CLI commands exposed by this feature:**
-- `morph-spec setup-infra` — headless infra setup, called by `/morph-init` skill
-- `morph-spec install-plugin <name>` — install superpowers/context7, called by `/morph-init` skill
-
-