@adityaaria/spark 6.0.15 → 6.0.17

package/src/installer/adapters/cursor-staging.js

@@ -1,42 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const CURSOR_PLUGIN_DIR = path.join('.cursor', 'plugins', 'spark');
-const COPY_PATHS = [
-  '.cursor-plugin',
-  'assets',
-  path.join('hooks', 'hooks-cursor.json'),
-  path.join('hooks', 'run-hook.cmd'),
-  path.join('hooks', 'session-start'),
-  'skills',
-];
-
-export function installCursorPlugin({ packageRoot, env = process.env, dryRun = false }) {
-  const homeDir = env.HOME || env.USERPROFILE || os.homedir();
-  const targetRoot = path.join(homeDir, CURSOR_PLUGIN_DIR);
-
-  if (!dryRun) {
-    fs.mkdirSync(targetRoot, { recursive: true });
-
-    for (const relativePath of COPY_PATHS) {
-      const sourcePath = path.join(packageRoot, relativePath);
-      const targetPath = path.join(targetRoot, relativePath);
-      const stat = fs.statSync(sourcePath);
-
-      if (stat.isDirectory()) {
-        fs.cpSync(sourcePath, targetPath, { recursive: true });
-        continue;
-      }
-
-      fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-      fs.copyFileSync(sourcePath, targetPath);
-      fs.chmodSync(targetPath, stat.mode);
-    }
-  }
-
-  return {
-    targetRoot,
-    relativeTargetRoot: `~/${CURSOR_PLUGIN_DIR}`,
-  };
-}

package/src/installer/adapters/extension-style.js

@@ -1,93 +0,0 @@
-import { createAdapter } from './common.js';
-import { installOpenCodePlugin } from './opencode-staging.js';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../..');
-
-export function createOpenCodeAdapter() {
-  return createAdapter({
-    id: 'opencode',
-    label: 'OpenCode',
-    kind: 'extension',
-    envKeys: ['OPENCODE_CONFIG_DIR'],
-    binaryNames: ['opencode'],
-    configPaths: ['opencode.json'],
-    bootstrap: 'using-spark -> .opencode/plugins/spark.js -> message transform bootstrap',
-    installHint: '.opencode/plugins/spark.js + .opencode/INSTALL.md',
-    verifyHint: 'Restart OpenCode, then confirm spark loads in a fresh session.',
-    successMessage: 'Installed SPARK for OpenCode.',
-    automatedSteps: [
-      'Install the SPARK package into the OpenCode config directory.',
-      'Register the spark plugin entry inside the OpenCode plugins directory.',
-      'Restart OpenCode to load the plugin and skills.',
-    ],
-    customInstall({ env, dryRun }) {
-      return installOpenCodePlugin({ packageRoot, env, dryRun });
-    },
-  });
-}
-
-export function createPiAdapter() {
-  return createAdapter({
-    id: 'pi',
-    label: 'Pi',
-    kind: 'extension',
-    envKeys: ['PI_HOME'],
-    binaryNames: ['pi'],
-    bootstrap: 'using-spark -> .pi/extensions/spark.ts -> session_start/session_compact bootstrap',
-    installHint: '.pi/extensions/spark.ts + package.json pi fields',
-    verifyHint: 'Run a fresh Pi session and confirm using-spark loads at session start.',
-    command: {
-      file: 'pi',
-      args: ['install', 'git:github.com/adityaaria/SPARK'],
-    },
-  });
-}
-
-export function createGeminiAdapter() {
-  return createAdapter({
-    id: 'gemini',
-    label: 'Gemini CLI',
-    kind: 'context-file',
-    packageRoot,
-    envKeys: ['GEMINI_HOME', 'GOOGLE_GEMINI_CLI'],
-    binaryNames: ['gemini'],
-    configPaths: ['GEMINI.md', 'gemini-extension.json'],
-    bootstrap: 'using-spark -> gemini-extension.json -> GEMINI.md context file',
-    installHint: 'gemini-extension.json + GEMINI.md + references/gemini-tools.md',
-    verifyHint: 'Run a fresh Gemini CLI session and confirm using-spark loads at session start.',
-    successMessage: 'Installed SPARK for Gemini CLI.',
-    automatedSteps: [
-      'Install the SPARK extension into Gemini CLI.',
-      'Start a fresh Gemini CLI session to confirm using-spark loads at startup.',
-    ],
-    command: {
-      file: 'gemini',
-      args: ['extensions', 'install', 'https://github.com/adityaaria/SPARK'],
-    },
-  });
-}
-
-export function createAntigravityAdapter() {
-  return createAdapter({
-    id: 'antigravity',
-    label: 'Antigravity',
-    kind: 'context-file',
-    packageRoot,
-    envKeys: ['ANTIGRAVITY_PLUGIN_ROOT'],
-    binaryNames: ['agy'],
-    bootstrap: 'using-spark -> agy plugin install -> contextFileName bootstrap',
-    installHint: 'skills/using-spark/references/antigravity-tools.md + plugin install flow',
-    verifyHint: 'Run a fresh Antigravity session and confirm using-spark loads from the plugin install.',
-    successMessage: 'Installed SPARK for Antigravity.',
-    automatedSteps: [
-      'Install the SPARK plugin into Antigravity.',
-      'Start a fresh Antigravity session to confirm using-spark loads before coding.',
-    ],
-    command: {
-      file: 'agy',
-      args: ['plugin', 'install', 'https://github.com/adityaaria/SPARK'],
-    },
-  });
-}

package/src/installer/adapters/opencode-staging.js

@@ -1,61 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const PACKAGE_DIR = 'spark';
-const SPARK_PLUGIN_FILE = path.join(PACKAGE_DIR, '.opencode', 'plugins', 'spark.js');
-
-export function installOpenCodePlugin({ packageRoot, env = process.env, dryRun = false }) {
-  const homeDir = env.HOME || env.USERPROFILE || os.homedir();
-  const configDir = env.OPENCODE_CONFIG_DIR
-    ? resolveHomeAwarePath(env.OPENCODE_CONFIG_DIR, homeDir)
-    : path.join(homeDir, '.config', 'opencode');
-
-  const sparkRoot = path.join(configDir, PACKAGE_DIR);
-  const pluginFile = path.join(configDir, SPARK_PLUGIN_FILE);
-  const registeredPlugin = path.join(configDir, 'plugins', 'spark.js');
-
-  if (!dryRun) {
-    fs.mkdirSync(sparkRoot, { recursive: true });
-    fs.cpSync(path.join(packageRoot, 'skills'), path.join(sparkRoot, 'skills'), { recursive: true });
-
-    fs.mkdirSync(path.dirname(pluginFile), { recursive: true });
-    fs.copyFileSync(path.join(packageRoot, '.opencode', 'plugins', 'spark.js'), pluginFile);
-
-    fs.mkdirSync(path.dirname(registeredPlugin), { recursive: true });
-    safeReplace(registeredPlugin);
-    fs.symlinkSync(pluginFile, registeredPlugin);
-  }
-
-  return {
-    targetRoot: sparkRoot,
-    relativeTargetRoot: simplifyHomePath(sparkRoot, homeDir),
-    pluginFile: simplifyHomePath(pluginFile, homeDir),
-    registeredPlugin: simplifyHomePath(registeredPlugin, homeDir),
-  };
-}
-
-function resolveHomeAwarePath(target, homeDir) {
-  if (target === '~') {
-    return homeDir;
-  }
-  if (target.startsWith('~/')) {
-    return path.join(homeDir, target.slice(2));
-  }
-  return path.resolve(target);
-}
-
-function simplifyHomePath(target, homeDir) {
-  if (target.startsWith(`${homeDir}${path.sep}`)) {
-    return `~/${path.relative(homeDir, target).split(path.sep).join('/')}`;
-  }
-  return target;
-}
-
-function safeReplace(target) {
-  try {
-    fs.rmSync(target, { force: true });
-  } catch {
-    // Ignore missing targets.
-  }
-}

package/src/installer/adapters/shell-hook.js

@@ -1,138 +0,0 @@
-import { createAdapter } from './common.js';
-import { stageClaudePlugin } from './claude-staging.js';
-import { stageCodexPlugin } from './codex-staging.js';
-import { installCursorPlugin } from './cursor-staging.js';
-import { installVsCodePlugin } from './vscode-staging.js';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../..');
-
-export function createClaudeCodeAdapter() {
-  return createAdapter({
-    id: 'claude',
-    label: 'Claude Code',
-    kind: 'shell-hook',
-    envKeys: ['CLAUDE_PLUGIN_ROOT'],
-    binaryNames: ['claude'],
-    bootstrap: 'shell hook -> hooks/session-start -> using-spark',
-    installHint: '.claude-plugin/plugin.json + hooks/hooks.json + hooks/session-start',
-    verifyHint: 'Run a fresh Claude Code session and confirm using-spark loads before coding.',
-    successMessage: 'Installed SPARK for Claude Code.',
-    commands: [
-      {
-        file: 'claude',
-        args: ['plugin', 'marketplace', 'add', '{relativeMarketplaceRoot}'],
-      },
-      {
-        file: 'claude',
-        args: ['plugin', 'install', 'spark@{marketplaceName}'],
-      },
-    ],
-    automatedSteps: [
-      'Stage a local Claude Code marketplace at .spark/claude-marketplace.',
-      'Register the local marketplace with Claude Code.',
-      'Install the spark plugin from that marketplace.',
-    ],
-    customInstall({ cwd, dryRun }) {
-      return stageClaudePlugin({ cwd, packageRoot, dryRun });
-    },
-  });
-}
-
-export function createCodexAdapter() {
-  return createAdapter({
-    id: 'codex',
-    label: 'Codex CLI',
-    kind: 'shell-hook',
-    envKeys: ['CLAUDE_PLUGIN_ROOT'],
-    binaryNames: ['codex'],
-    bootstrap: 'shell hook -> hooks/session-start-codex -> using-spark',
-    installHint: '.codex-plugin/plugin.json + hooks/hooks-codex.json + hooks/session-start-codex',
-    verifyHint: 'Run a fresh Codex session and confirm using-spark loads before coding.',
-    successMessage: 'Installed SPARK for Codex CLI.',
-    commands: [
-      {
-        file: 'codex',
-        args: ['plugin', 'marketplace', 'add', '{relativeMarketplaceRoot}'],
-      },
-      {
-        file: 'codex',
-        args: ['plugin', 'add', 'spark@{marketplaceName}'],
-      },
-    ],
-    automatedSteps: [
-      'Stage a local Codex marketplace at .spark/codex-marketplace.',
-      'Register the local marketplace with Codex.',
-      'Install the spark plugin from that marketplace.',
-    ],
-    customInstall({ cwd, dryRun }) {
-      return stageCodexPlugin({ cwd, packageRoot, dryRun });
-    },
-  });
-}
-
-export function createVsCodeAdapter() {
-  return createAdapter({
-    id: 'vscode',
-    label: 'VS Code',
-    kind: 'shell-hook',
-    bootstrap: 'workspace plugin bundle -> VS Code chat.pluginLocations -> hooks/session-start -> using-spark',
-    installHint: 'A standard plugin bundle is staged locally and registered through .vscode/settings.json chat.pluginLocations.',
-    verifyHint: 'Open a fresh VS Code agent session and confirm using-spark loads before coding.',
-    successMessage: 'SPARK is ready in VS Code.',
-    automatedSteps: [
-      'Prepare a local VS Code plugin bundle at .spark/vscode-plugin.',
-      'Register that bundle in .vscode/settings.json via chat.pluginLocations.',
-      'Start a fresh VS Code agent session so using-spark loads before coding.',
-    ],
-    customInstall({ cwd, dryRun }) {
-      return installVsCodePlugin({ cwd, packageRoot, dryRun });
-    },
-  });
-}
-
-export function createCursorAdapter() {
-  return createAdapter({
-    id: 'cursor',
-    label: 'Cursor',
-    kind: 'shell-hook',
-    envKeys: ['CURSOR_PLUGIN_ROOT'],
-    binaryNames: ['cursor'],
-    bootstrap: 'shell hook -> hooks/session-start -> using-spark',
-    installHint: '.cursor-plugin/plugin.json + hooks/hooks-cursor.json + hooks/session-start',
-    verifyHint: 'Restart Cursor fully, then confirm using-spark loads in a fresh Agent session.',
-    successMessage: 'Installed SPARK for Cursor.',
-    automatedSteps: [
-      'Copy the SPARK plugin into ~/.cursor/plugins/spark.',
-      'Restart Cursor fully to load the new plugin.',
-      'Start a fresh Cursor Agent session and confirm using-spark loads before coding.',
-    ],
-    customInstall({ env, dryRun }) {
-      return installCursorPlugin({ packageRoot, env, dryRun });
-    },
-  });
-}
-
-export function createCopilotAdapter() {
-  return createAdapter({
-    id: 'copilot',
-    label: 'Copilot CLI',
-    kind: 'shell-hook',
-    envKeys: ['COPILOT_CLI'],
-    binaryNames: ['copilot'],
-    bootstrap: 'shell hook -> hooks/session-start -> using-spark',
-    installHint: 'skills/using-spark/references/copilot-tools.md + hooks/session-start',
-    verifyHint: 'Run a fresh Copilot CLI session and confirm using-spark loads before coding.',
-    commands: [
-      {
-        file: 'copilot',
-        args: ['plugin', 'marketplace', 'add', 'adityaaria/SPARK-marketplace'],
-      },
-      {
-        file: 'copilot',
-        args: ['plugin', 'install', 'spark@spark-marketplace'],
-      },
-    ],
-  });
-}

package/src/installer/adapters/vscode-staging.js

@@ -1,75 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-const VSCODE_PLUGIN_DIR = path.join('.spark', 'vscode-plugin');
-const SETTINGS_PATH = path.join('.vscode', 'settings.json');
-const COPY_PATHS = [
-  { src: '.claude-plugin', dest: '.vscode-plugin' },
-  { src: 'assets', dest: 'assets' },
-  { src: path.join('hooks', 'hooks.json'), dest: path.join('hooks', 'hooks.json') },
-  { src: path.join('hooks', 'run-hook.cmd'), dest: path.join('hooks', 'run-hook.cmd') },
-  { src: path.join('hooks', 'session-start'), dest: path.join('hooks', 'session-start') },
-  { src: 'skills', dest: 'skills' },
-];
-
-export function installVsCodePlugin({ cwd = process.cwd(), packageRoot, dryRun = false }) {
-  const targetRoot = path.join(cwd, VSCODE_PLUGIN_DIR);
-  const settingsPath = path.join(cwd, SETTINGS_PATH);
-
-  if (!dryRun) {
-    fs.mkdirSync(targetRoot, { recursive: true });
-
-    for (const mapping of COPY_PATHS) {
-      const sourcePath = path.join(packageRoot, mapping.src);
-      const targetPath = path.join(targetRoot, mapping.dest);
-      const stat = fs.statSync(sourcePath);
-
-      if (stat.isDirectory()) {
-        fs.cpSync(sourcePath, targetPath, { recursive: true });
-        continue;
-      }
-
-      fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-      fs.copyFileSync(sourcePath, targetPath);
-      fs.chmodSync(targetPath, stat.mode);
-    }
-
-    const targetPluginJsonPath = path.join(targetRoot, '.vscode-plugin', 'plugin.json');
-    if (fs.existsSync(targetPluginJsonPath)) {
-      const pluginData = JSON.parse(fs.readFileSync(targetPluginJsonPath, 'utf8'));
-      pluginData.description = "Core skills library for VS Code: TDD, debugging, collaboration patterns, and proven techniques";
-      fs.writeFileSync(targetPluginJsonPath, JSON.stringify(pluginData, null, 2) + '\n', 'utf8');
-    }
-
-    writeVsCodeSettings(settingsPath, targetRoot);
-  }
-
-  return {
-    targetRoot,
-    relativeTargetRoot: VSCODE_PLUGIN_DIR,
-    settingsPath,
-    relativeSettingsPath: SETTINGS_PATH,
-  };
-}
-
-function writeVsCodeSettings(settingsPath, targetRoot) {
-  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-
-  let settings = {};
-  if (fs.existsSync(settingsPath)) {
-    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  }
-
-  const pluginLocations = isPlainObject(settings['chat.pluginLocations'])
-    ? { ...settings['chat.pluginLocations'] }
-    : {};
-
-  pluginLocations[targetRoot] = true;
-  settings['chat.pluginLocations'] = pluginLocations;
-
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
-}
-
-function isPlainObject(value) {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}

package/src/installer/detect.js

@@ -1,257 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { formatPromptBlock, promptOption } from '../cli/output.js';
-import { getAdapterById, listAdapters } from './registry.js';
-import { InstallerError } from './errors.js';
-
-export function detectHarnessCandidates({ env = process.env, fsImpl = fs } = {}) {
-  const homeDir = os.homedir();
-  const adapters = listAdapters();
-
-  return adapters
-    .map((adapter) => scoreAdapter(adapter, env, fsImpl, homeDir))
-    .filter((candidate) => candidate.score > 0)
-    .sort((a, b) => b.score - a.score || a.label.localeCompare(b.label));
-}
-
-export async function chooseHarness({
-  forcedHarness = null,
-  env = process.env,
-  fs = fs,
-  prompt = null,
-} = {}) {
-  if (forcedHarness) {
-    const adapter = getAdapterById(normalizeHarness(forcedHarness));
-    if (!adapter) {
-      throw new InstallerError(`Unsupported harness: ${forcedHarness}`);
-    }
-    return { adapter, source: 'forced', candidates: [] };
-  }
-
-  if (!prompt) {
-    throw new InstallerError('No harness selected. Re-run with --harness or use an interactive terminal.');
-  }
-
-  const homeDir = os.homedir();
-  const detectedCandidates = detectHarnessCandidates({ env, fsImpl: fs });
-  const candidates = buildPromptCandidates(detectedCandidates, env, fs, homeDir);
-
-  let validationMessage = null;
-  while (true) {
-    const answer = await prompt(renderPrompt(candidates, validationMessage));
-    const adapter = resolvePromptAnswer(answer, candidates);
-    if (adapter) {
-      return { adapter, source: 'prompt', candidates };
-    }
-    validationMessage = `Unsupported choice: ${answer || '(empty)'}. Please choose a number or harness name from the list.`;
-  }
-}
-
-function scoreAdapter(adapter, env, fsImpl, homeDir) {
-  let score = 0;
-  const reasons = [];
-
-  let missingBinaries = false;
-
-  for (const key of adapter.envKeys) {
-    if (env[key]) {
-      score += 100;
-      reasons.push(`env:${key}`);
-    }
-  }
-
-  if (adapter.binaryNames && adapter.binaryNames.length > 0) {
-    missingBinaries = true;
-    for (const binaryName of adapter.binaryNames) {
-      if (commandExists(binaryName, env, fsImpl)) {
-        score += 70;
-        reasons.push(`path:${binaryName}`);
-        missingBinaries = false;
-        break;
-      }
-    }
-  }
-
-  for (const configPath of adapter.configPaths) {
-    for (const candidatePath of candidateConfigPaths(homeDir, env, configPath)) {
-      if (fsImpl.existsSync(candidatePath)) {
-        score += 90;
-        reasons.push(`config:${candidatePath}`);
-        break;
-      }
-    }
-  }
-
-  return {
-    id: adapter.id,
-    label: adapter.label,
-    score,
-    reasons,
-    missingBinaries,
-  };
-}
-
-function candidateConfigPaths(homeDir, env, configPath) {
-  const paths = [];
-  if (env.OPENCODE_CONFIG_DIR && configPath === 'opencode.json') {
-    paths.push(path.join(env.OPENCODE_CONFIG_DIR, 'opencode.json'));
-  }
-  if (configPath === 'GEMINI.md') {
-    paths.push(
-      path.join(homeDir, '.gemini', 'GEMINI.md'),
-      path.join(homeDir, 'GEMINI.md')
-    );
-  }
-  if (configPath === 'gemini-extension.json') {
-    paths.push(
-      path.join(homeDir, 'gemini-extension.json'),
-      path.join(homeDir, '.gemini', 'gemini-extension.json')
-    );
-  }
-  return paths;
-}
-
-function commandExists(commandName, env, fsImpl) {
-  const paths = String(env.PATH ?? '').split(path.delimiter).filter(Boolean);
-  const exts = process.platform === 'win32'
-    ? String(env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
-    : [''];
-
-  for (const dir of paths) {
-    for (const ext of exts) {
-      const candidate = path.join(dir, `${commandName}${ext}`);
-      try {
-        fsImpl.accessSync(candidate, fs.constants.X_OK);
-        return true;
-      } catch {
-        try {
-          fsImpl.accessSync(candidate, fs.constants.F_OK);
-          return true;
-        } catch {
-          continue;
-        }
-      }
-    }
-  }
-
-  return false;
-}
-
-function buildPromptCandidates(detectedCandidates, env, fsImpl, homeDir) {
-  const allAdapters = listAdapters();
-  const detectedIds = new Set(detectedCandidates.map((candidate) => candidate.id));
-
-  return [
-    ...detectedCandidates,
-    ...allAdapters
-      .filter((adapter) => !detectedIds.has(adapter.id))
-      .map((adapter) => {
-        const result = scoreAdapter(adapter, env, fsImpl, homeDir);
-        result.score = 0;
-        result.reasons = [];
-        return result;
-      }),
-  ];
-}
-
-function renderPrompt(candidates, validationMessage = null) {
-  const lines = [];
-
-  if (validationMessage) {
-    lines.push(validationMessage);
-    lines.push('');
-  }
-
-  const detectedCount = candidates.filter((candidate) => candidate.score > 0).length;
-  const recommendedIds = new Set(candidates.filter((candidate) => candidate.score > 0).map((candidate) => candidate.id));
-
-  if (detectedCount > 0) {
-    lines.push('Recommended from your current environment:');
-    lines.push('');
-  }
-
-  for (const [index, candidate] of candidates.entries()) {
-    let label = candidate.label;
-    if (candidate.missingBinaries) {
-      label += ' [Missing CLI]';
-    }
-
-    const hint = recommendedIds.has(candidate.id) ? 'recommended' : null;
-    lines.push(
-      promptOption(
-        index + 1,
-        label,
-        candidate.id,
-        hint,
-        describeHarness(candidate.id, candidate.missingBinaries)
-      )
-    );
-  }
-
-  return formatPromptBlock(
-    'Install SPARK',
-    lines,
-    'Enter a number or harness name.'
-  );
-}
-
-function resolvePromptAnswer(answer, candidates) {
-  const value = normalizeHarness(answer);
-  if (!value) return null;
-
-  const numeric = Number(value);
-  if (Number.isInteger(numeric) && numeric >= 1 && numeric <= candidates.length) {
-    return getAdapterById(candidates[numeric - 1].id);
-  }
-
-  const exact = candidates.find((candidate) => candidate.id === value || candidate.label.toLowerCase() === value);
-  if (!exact) return null;
-
-  return getAdapterById(exact.id);
-}
-
-function describeHarness(id, missingBinaries = false) {
-  const descriptions = {
-    claude: 'Best for Claude Code sessions and project-local plugin workflows.',
-    codex: 'For the Codex CLI plugin marketplace flow in terminal sessions.',
-    vscode: 'One install path for VS Code agent sessions across Claude, Copilot, GPT, and other supported models.',
-    cursor: 'Native Cursor plugin install for fresh Agent sessions.',
-    copilot: 'For GitHub Copilot CLI in terminal-based agent sessions.',
-    opencode: 'Registers the OpenCode plugin in your local config directory.',
-    gemini: 'Installs the Gemini CLI extension and loads SPARK at startup.',
-    pi: 'Installs the Pi extension from the SPARK repository.',
-    antigravity: 'Installs the Antigravity plugin and loads SPARK on new sessions.',
-  };
-
-  let description = descriptions[id] ?? null;
-  if (description && missingBinaries) {
-    description += '\n   ⚠️  Requires its official CLI to be installed first.';
-  }
-
-  return description;
-}
-
-function normalizeHarness(value) {
-  const normalized = String(value ?? '').trim().toLowerCase();
-
-  if (!normalized) {
-    return '';
-  }
-
-  const aliases = new Map([
-    ['codex cli', 'codex'],
-    ['codex-cli', 'codex'],
-    ['codex vscode', 'vscode'],
-    ['codex vs code', 'vscode'],
-    ['codex-vs-code', 'vscode'],
-    ['codex app', 'vscode'],
-    ['copilot vscode', 'vscode'],
-    ['copilot vs code', 'vscode'],
-    ['copilot-vs-code', 'vscode'],
-    ['vscode agent', 'vscode'],
-    ['vs code', 'vscode'],
-  ]);
-
-  return aliases.get(normalized) ?? normalized;
-}

package/src/installer/errors.js

@@ -1,7 +0,0 @@
-export class InstallerError extends Error {
-  constructor(message, code = 'INSTALLER_ERROR') {
-    super(message);
-    this.name = 'InstallerError';
-    this.code = code;
-  }
-}