@adityaaria/spark 6.0.3

package/src/installer/adapters/common.js

@@ -0,0 +1,59 @@
+import { spawnSync } from 'node:child_process';
+import { InstallerError } from '../errors.js';
+
+export function createAdapter({
+  id,
+  label,
+  kind,
+  bootstrap,
+  installHint,
+  verifyHint,
+  command = null,
+  envKeys = [],
+  binaryNames = [],
+  configPaths = [],
+}) {
+  return {
+    id,
+    label,
+    envKeys,
+    binaryNames,
+    configPaths,
+    command,
+    planInstall() {
+      return {
+        kind,
+        bootstrap,
+        installHint,
+        verifyHint,
+        command,
+      };
+    },
+    async install({ runner = spawnSync, dryRun = false } = {}) {
+      if (dryRun) {
+        return this.planInstall();
+      }
+
+      if (!command) {
+        throw new InstallerError(`${label} install is not fully automatable yet.`);
+      }
+
+      const result = runner(command.file, command.args ?? [], {
+        cwd: command.cwd ?? process.cwd(),
+        env: command.env ?? process.env,
+        encoding: 'utf8',
+      });
+
+      if (result.status !== 0) {
+        throw new InstallerError(
+          `${label} install failed: ${result.stderr || result.stdout || 'unknown error'}`
+        );
+      }
+
+      return this.planInstall();
+    },
+    async verify() {
+      return verifyHint;
+    },
+  };
+}

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

@@ -0,0 +1,67 @@
+import { createAdapter } from './common.js';
+
+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: 'Run opencode logs or a fresh OpenCode session and confirm bootstrap injection.',
+  });
+}
+
+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',
+    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.',
+    command: {
+      file: 'gemini',
+      args: ['extensions', 'install', 'https://github.com/adityaaria/SPARK'],
+    },
+  });
+}
+
+export function createAntigravityAdapter() {
+  return createAdapter({
+    id: 'antigravity',
+    label: 'Antigravity',
+    kind: 'context-file',
+    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.',
+    command: {
+      file: 'agy',
+      args: ['plugin', 'install', 'https://github.com/adityaaria/SPARK'],
+    },
+  });
+}

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

@@ -0,0 +1,57 @@
+import { createAdapter } from './common.js';
+
+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.',
+  });
+}
+
+export function createCodexAdapter() {
+  return createAdapter({
+    id: 'codex',
+    label: 'Codex',
+    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.',
+  });
+}
+
+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: 'Run a fresh Cursor Agent session and confirm using-spark loads before coding.',
+  });
+}
+
+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.',
+    command: {
+      file: 'copilot',
+      args: ['plugin', 'install', 'spark@spark-marketplace'],
+    },
+  });
+}

package/src/installer/detect.js

@@ -0,0 +1,168 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { getAdapterById, listAdapters } from './registry.js';
+import { InstallerError } from './errors.js';
+
+const HIGH_CONFIDENCE_SCORE = 80;
+const AMBIGUOUS_MARGIN = 20;
+
+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: [] };
+  }
+
+  const candidates = detectHarnessCandidates({ env, fsImpl: fs });
+  if (candidates.length === 0) {
+    throw new InstallerError(
+      `Could not detect a supported harness. Supported harnesses: ${listAdapters().map((adapter) => adapter.label).join(', ')}`
+    );
+  }
+
+  if (isConfident(candidates)) {
+    const adapter = getAdapterById(candidates[0].id);
+    return { adapter, source: 'auto', candidates };
+  }
+
+  if (!prompt) {
+    throw new InstallerError(`Multiple harnesses look plausible: ${candidates.map((candidate) => candidate.label).join(', ')}`);
+  }
+
+  const answer = await prompt(renderPrompt(candidates));
+  const adapter = resolvePromptAnswer(answer, candidates);
+  return { adapter, source: 'prompt', candidates };
+}
+
+function scoreAdapter(adapter, env, fsImpl, homeDir) {
+  let score = 0;
+  const reasons = [];
+
+  for (const key of adapter.envKeys) {
+    if (env[key]) {
+      score += 100;
+      reasons.push(`env:${key}`);
+    }
+  }
+
+  for (const binaryName of adapter.binaryNames) {
+    if (commandExists(binaryName, env, fsImpl)) {
+      score += 70;
+      reasons.push(`path:${binaryName}`);
+    }
+  }
+
+  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,
+  };
+}
+
+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'));
+    paths.push(path.join(homeDir, 'GEMINI.md'));
+  }
+  if (configPath === 'gemini-extension.json') {
+    paths.push(path.join(homeDir, 'gemini-extension.json'));
+    paths.push(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 isConfident(candidates) {
+  if (candidates[0].score < HIGH_CONFIDENCE_SCORE) return false;
+  if (candidates.length === 1) return true;
+  return candidates[0].score - candidates[1].score >= AMBIGUOUS_MARGIN;
+}
+
+function renderPrompt(candidates) {
+  return [
+    'Choose the harness to install SPARK for:',
+    ...candidates.map((candidate, index) => `${index + 1}. ${candidate.label} (${candidate.id})`),
+    'Enter a number or harness name:',
+  ].join('\n');
+}
+
+function resolvePromptAnswer(answer, candidates) {
+  const value = normalizeHarness(answer);
+  if (!value) {
+    throw new InstallerError('No harness selected.');
+  }
+
+  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) {
+    throw new InstallerError(`Unsupported harness choice: ${answer}`);
+  }
+
+  return getAdapterById(exact.id);
+}
+
+function normalizeHarness(value) {
+  return String(value ?? '').trim().toLowerCase();
+}

package/src/installer/errors.js

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

package/src/installer/registry.js

@@ -0,0 +1,35 @@
+import {
+  createClaudeCodeAdapter,
+  createCodexAdapter,
+  createCopilotAdapter,
+  createCursorAdapter,
+} from './adapters/shell-hook.js';
+import {
+  createAntigravityAdapter,
+  createGeminiAdapter,
+  createOpenCodeAdapter,
+  createPiAdapter,
+} from './adapters/extension-style.js';
+
+const ADAPTERS = [
+  createClaudeCodeAdapter(),
+  createCodexAdapter(),
+  createCursorAdapter(),
+  createCopilotAdapter(),
+  createOpenCodeAdapter(),
+  createGeminiAdapter(),
+  createPiAdapter(),
+  createAntigravityAdapter(),
+];
+
+export function listAdapters() {
+  return ADAPTERS.map((adapter) => ({ ...adapter }));
+}
+
+export function getAdapterById(id) {
+  return ADAPTERS.find((adapter) => adapter.id === id) ?? null;
+}
+
+export function getAdapterLabels() {
+  return ADAPTERS.map((adapter) => adapter.label);
+}