@ghl-ai/aw 0.1.50-beta.1 → 0.1.50

package/integrations/context-mode.mjs

@@ -0,0 +1,514 @@
+import { accessSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { constants as fsConstants } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { delimiter, dirname, join } from 'node:path';
+
+import TOML from '@iarna/toml';
+
+const INTEGRATION_NAME = 'context-mode';
+const BINARY_NAME = 'context-mode';
+
+const CODEX_HOOK_COMMANDS = {
+  PreToolUse: 'context-mode hook codex pretooluse',
+  PostToolUse: 'context-mode hook codex posttooluse',
+  SessionStart: 'context-mode hook codex sessionstart',
+  PreCompact: 'context-mode hook codex precompact',
+  UserPromptSubmit: 'context-mode hook codex userpromptsubmit',
+  Stop: 'context-mode hook codex stop',
+};
+
+const CURSOR_HOOK_COMMANDS = {
+  preToolUse: 'context-mode hook cursor pretooluse',
+  postToolUse: 'context-mode hook cursor posttooluse',
+  stop: 'context-mode hook cursor stop',
+};
+
+function truthy(value) {
+  return ['1', 'true', 'yes', 'on'].includes(String(value || '').trim().toLowerCase());
+}
+
+function unique(values) {
+  return [...new Set(values)];
+}
+
+function readJson(filePath, fallback = {}) {
+  if (!existsSync(filePath)) return fallback;
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch (err) {
+    throw new Error(`Could not parse JSON config ${filePath}: ${err.message}`);
+  }
+}
+
+function writeJsonIfChanged(filePath, value, dryRun = false) {
+  const next = `${JSON.stringify(value, null, 2)}\n`;
+  const existing = existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+  if (next === existing) return false;
+  if (!dryRun) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, next);
+  }
+  return true;
+}
+
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value ?? {}));
+}
+
+function parseTomlConfig(filePath, warnings) {
+  if (!existsSync(filePath)) return {};
+  try {
+    return TOML.parse(readFileSync(filePath, 'utf8'));
+  } catch (err) {
+    warnings.push(`Could not parse ${filePath}; leaving Codex TOML unchanged: ${err.message}`);
+    return null;
+  }
+}
+
+function writeTomlIfChanged(filePath, value, dryRun = false) {
+  const next = TOML.stringify(value);
+  const existing = existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+  if (next === existing) return false;
+  if (!dryRun) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, next);
+  }
+  return true;
+}
+
+function executableCandidates(binaryName) {
+  return process.platform === 'win32'
+    ? [binaryName, `${binaryName}.cmd`, `${binaryName}.exe`]
+    : [binaryName];
+}
+
+function findExecutable(binaryName, env = process.env) {
+  const pathValue = env.PATH || '';
+  for (const dir of pathValue.split(delimiter).filter(Boolean)) {
+    for (const candidate of executableCandidates(binaryName)) {
+      const fullPath = join(dir, candidate);
+      try {
+        accessSync(fullPath, fsConstants.X_OK);
+        return fullPath;
+      } catch {
+        // Keep scanning PATH.
+      }
+    }
+  }
+  return null;
+}
+
+function isContextModeCommand(command) {
+  return String(command || '').startsWith('context-mode hook ');
+}
+
+function ensureObject(parent, key) {
+  if (!parent[key] || typeof parent[key] !== 'object' || Array.isArray(parent[key])) {
+    parent[key] = {};
+  }
+  return parent[key];
+}
+
+function mergeJsonMcpServer(filePath, dryRun = false) {
+  const config = readJson(filePath, {});
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw new Error(`Expected JSON object in ${filePath}`);
+  }
+
+  const mcpServers = ensureObject(config, 'mcpServers');
+  const existing = mcpServers[INTEGRATION_NAME];
+  const desired = { command: BINARY_NAME };
+  if (JSON.stringify(existing) === JSON.stringify(desired)) return false;
+
+  mcpServers[INTEGRATION_NAME] = desired;
+  return writeJsonIfChanged(filePath, config, dryRun);
+}
+
+function removeJsonMcpServer(filePath, dryRun = false) {
+  if (!existsSync(filePath)) return false;
+  const config = readJson(filePath, {});
+  if (!config?.mcpServers?.[INTEGRATION_NAME]) return false;
+
+  delete config.mcpServers[INTEGRATION_NAME];
+  if (Object.keys(config.mcpServers).length === 0) delete config.mcpServers;
+  return writeJsonIfChanged(filePath, config, dryRun);
+}
+
+function mergeCodexToml(filePath, warnings, dryRun = false) {
+  const config = parseTomlConfig(filePath, warnings);
+  if (config === null) return false;
+
+  const before = JSON.stringify(config);
+  config.features = config.features && typeof config.features === 'object' && !Array.isArray(config.features)
+    ? config.features
+    : {};
+  config.features.hooks = true;
+  config.features.codex_hooks = true;
+
+  config.mcp_servers = config.mcp_servers && typeof config.mcp_servers === 'object' && !Array.isArray(config.mcp_servers)
+    ? config.mcp_servers
+    : {};
+  config.mcp_servers[INTEGRATION_NAME] = { command: BINARY_NAME };
+
+  if (JSON.stringify(config) === before) return false;
+  return writeTomlIfChanged(filePath, config, dryRun);
+}
+
+function removeCodexToml(filePath, warnings, dryRun = false) {
+  if (!existsSync(filePath)) return false;
+  const config = parseTomlConfig(filePath, warnings);
+  if (config === null) return false;
+  if (!config.mcp_servers?.[INTEGRATION_NAME]) return false;
+
+  delete config.mcp_servers[INTEGRATION_NAME];
+  if (Object.keys(config.mcp_servers).length === 0) delete config.mcp_servers;
+  return writeTomlIfChanged(filePath, config, dryRun);
+}
+
+function ensureCodexHook(config, phase, command) {
+  config.hooks = config.hooks && typeof config.hooks === 'object' && !Array.isArray(config.hooks)
+    ? config.hooks
+    : {};
+  const entries = Array.isArray(config.hooks[phase]) ? config.hooks[phase] : [];
+  if (entries.some(entry => Array.isArray(entry?.hooks) && entry.hooks.some(hook => hook?.command === command))) {
+    config.hooks[phase] = entries;
+    return false;
+  }
+
+  const target = entries.find(entry => Array.isArray(entry?.hooks));
+  const hook = { type: 'command', command };
+  if (target) {
+    target.hooks.push(hook);
+  } else {
+    const entry = { hooks: [hook] };
+    if (phase === 'SessionStart') entry.matcher = 'startup|resume';
+    if (phase === 'PreToolUse' || phase === 'PostToolUse') entry.matcher = '*';
+    entries.push(entry);
+  }
+  config.hooks[phase] = entries;
+  return true;
+}
+
+function mergeCodexHooks(filePath, dryRun = false) {
+  const config = readJson(filePath, {});
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw new Error(`Expected JSON object in ${filePath}`);
+  }
+
+  let changed = false;
+  for (const [phase, command] of Object.entries(CODEX_HOOK_COMMANDS)) {
+    changed = ensureCodexHook(config, phase, command) || changed;
+  }
+  return changed && writeJsonIfChanged(filePath, config, dryRun);
+}
+
+function removeCodexHooks(filePath, dryRun = false) {
+  if (!existsSync(filePath)) return false;
+  const config = readJson(filePath, {});
+  if (!config?.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)) return false;
+
+  let changed = false;
+  for (const phase of Object.keys(config.hooks)) {
+    if (!Array.isArray(config.hooks[phase])) continue;
+    const nextEntries = config.hooks[phase]
+      .map(entry => {
+        if (!Array.isArray(entry?.hooks)) return entry;
+        const nextHooks = entry.hooks.filter(hook => !isContextModeCommand(hook?.command));
+        if (nextHooks.length !== entry.hooks.length) changed = true;
+        if (nextHooks.length === 0) return null;
+        return { ...entry, hooks: nextHooks };
+      })
+      .filter(Boolean);
+
+    if (nextEntries.length > 0) config.hooks[phase] = nextEntries;
+    else delete config.hooks[phase];
+  }
+
+  if (!changed) return false;
+  if (Object.keys(config.hooks).length === 0) delete config.hooks;
+  return writeJsonIfChanged(filePath, config, dryRun);
+}
+
+function ensureCursorHook(config, phase, command) {
+  config.hooks = config.hooks && typeof config.hooks === 'object' && !Array.isArray(config.hooks)
+    ? config.hooks
+    : {};
+  const entries = Array.isArray(config.hooks[phase]) ? config.hooks[phase] : [];
+  if (entries.some(entry => entry?.command === command)) {
+    config.hooks[phase] = entries;
+    return false;
+  }
+  entries.push({ command });
+  config.hooks[phase] = entries;
+  return true;
+}
+
+function mergeCursorHooks(filePath, dryRun = false) {
+  const config = readJson(filePath, {});
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw new Error(`Expected JSON object in ${filePath}`);
+  }
+
+  let changed = false;
+  if (config.version === undefined) {
+    config.version = 1;
+    changed = true;
+  }
+  for (const [phase, command] of Object.entries(CURSOR_HOOK_COMMANDS)) {
+    changed = ensureCursorHook(config, phase, command) || changed;
+  }
+  return changed && writeJsonIfChanged(filePath, config, dryRun);
+}
+
+function runConfigMutation(label, filePath, mutate, warnings) {
+  try {
+    return mutate();
+  } catch (err) {
+    warnings.push(`Could not update ${label} at ${filePath}: ${err.message}`);
+    return false;
+  }
+}
+
+function removeCursorHooks(filePath, dryRun = false) {
+  if (!existsSync(filePath)) return false;
+  const config = readJson(filePath, {});
+  if (!config?.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)) return false;
+
+  let changed = false;
+  for (const phase of Object.keys(config.hooks)) {
+    if (!Array.isArray(config.hooks[phase])) continue;
+    const nextEntries = config.hooks[phase].filter(entry => !isContextModeCommand(entry?.command));
+    if (nextEntries.length !== config.hooks[phase].length) changed = true;
+    if (nextEntries.length > 0) config.hooks[phase] = nextEntries;
+    else delete config.hooks[phase];
+  }
+
+  if (!changed) return false;
+  if (Object.keys(config.hooks).length === 0) delete config.hooks;
+  return writeJsonIfChanged(filePath, config, dryRun);
+}
+
+function hasJsonMcpServer(filePath) {
+  if (!existsSync(filePath)) return false;
+  try {
+    return readJson(filePath, {}).mcpServers?.[INTEGRATION_NAME]?.command === BINARY_NAME;
+  } catch {
+    return false;
+  }
+}
+
+function hasCodexMcpServer(filePath) {
+  if (!existsSync(filePath)) return false;
+  try {
+    const config = TOML.parse(readFileSync(filePath, 'utf8'));
+    return config.mcp_servers?.[INTEGRATION_NAME]?.command === BINARY_NAME;
+  } catch {
+    return false;
+  }
+}
+
+function hasCodexHookCoverage(filePath) {
+  if (!existsSync(filePath)) return false;
+  try {
+    const config = readJson(filePath, {});
+    return Object.entries(CODEX_HOOK_COMMANDS).every(([phase, command]) =>
+      Array.isArray(config.hooks?.[phase])
+      && config.hooks[phase].some(entry =>
+        Array.isArray(entry?.hooks) && entry.hooks.some(hook => hook?.command === command)
+      )
+    );
+  } catch {
+    return false;
+  }
+}
+
+function hasCursorHookCoverage(filePath) {
+  if (!existsSync(filePath)) return false;
+  try {
+    const config = readJson(filePath, {});
+    return Object.entries(CURSOR_HOOK_COMMANDS).every(([phase, command]) =>
+      Array.isArray(config.hooks?.[phase])
+      && config.hooks[phase].some(entry => entry?.command === command)
+    );
+  } catch {
+    return false;
+  }
+}
+
+function hasAnyContextModeConfig(home) {
+  return hasCodexMcpServer(join(home, '.codex', 'config.toml'))
+    || hasCodexHookCoverage(join(home, '.codex', 'hooks.json'))
+    || hasJsonMcpServer(join(home, '.cursor', 'mcp.json'))
+    || hasCursorHookCoverage(join(home, '.cursor', 'hooks.json'))
+    || hasJsonMcpServer(join(home, '.claude.json'));
+}
+
+function hasCompleteContextModeConfig(home) {
+  return hasCodexMcpServer(join(home, '.codex', 'config.toml'))
+    && hasCodexHookCoverage(join(home, '.codex', 'hooks.json'))
+    && hasJsonMcpServer(join(home, '.cursor', 'mcp.json'))
+    && hasCursorHookCoverage(join(home, '.cursor', 'hooks.json'))
+    && hasJsonMcpServer(join(home, '.claude.json'));
+}
+
+export function isContextModeRequested(args = {}, env = process.env) {
+  if (args['--context-mode'] === true) return true;
+  if (truthy(env.AW_CONTEXT_MODE)) return true;
+  return String(env.AW_INTEGRATIONS || '')
+    .split(',')
+    .map(value => value.trim().toLowerCase())
+    .includes(INTEGRATION_NAME);
+}
+
+export function detectContextModeBinary(options = {}) {
+  const env = options.env || options || process.env;
+  const binaryPath = findExecutable(BINARY_NAME, env);
+  if (!binaryPath) {
+    return {
+      present: false,
+      path: null,
+      version: null,
+      reason: `${BINARY_NAME} binary not found on PATH`,
+    };
+  }
+
+  const versionEnv = {
+    ...process.env,
+    ...env,
+    PATH: [env.PATH, process.env.PATH].filter(Boolean).join(delimiter),
+  };
+  const versionResult = spawnSync(binaryPath, ['--version'], {
+    env: versionEnv,
+    encoding: 'utf8',
+    timeout: 3000,
+  });
+  const versionOutput = `${versionResult.stdout || ''}${versionResult.stderr || ''}`.trim();
+
+  return {
+    present: true,
+    path: binaryPath,
+    version: versionOutput || 'unknown',
+    reason: null,
+  };
+}
+
+export function ensureContextModeIntegration(home, options = {}) {
+  const env = options.env || process.env;
+  const dryRun = options.dryRun === true;
+  const warnings = [];
+  const changedFiles = [];
+  const configuredHarnesses = [];
+  const binary = detectContextModeBinary({ env });
+
+  if (!binary.present) {
+    return {
+      changedFiles,
+      warnings: [`context-mode binary is required before config mutation: ${binary.reason}`],
+      configuredHarnesses,
+      binary,
+      dryRun,
+    };
+  }
+
+  const updates = [
+    ['Codex MCP', join(home, '.codex', 'config.toml'), () => mergeCodexToml(join(home, '.codex', 'config.toml'), warnings, dryRun)],
+    ['Codex hooks', join(home, '.codex', 'hooks.json'), () => mergeCodexHooks(join(home, '.codex', 'hooks.json'), dryRun)],
+    ['Cursor MCP', join(home, '.cursor', 'mcp.json'), () => mergeJsonMcpServer(join(home, '.cursor', 'mcp.json'), dryRun)],
+    ['Cursor hooks', join(home, '.cursor', 'hooks.json'), () => mergeCursorHooks(join(home, '.cursor', 'hooks.json'), dryRun)],
+    ['Claude MCP', join(home, '.claude.json'), () => mergeJsonMcpServer(join(home, '.claude.json'), dryRun)],
+  ];
+
+  for (const [label, filePath, update] of updates) {
+    if (runConfigMutation(label, filePath, update, warnings)) {
+      changedFiles.push(filePath);
+      configuredHarnesses.push(label);
+    }
+  }
+
+  return {
+    changedFiles: unique(changedFiles),
+    warnings,
+    configuredHarnesses,
+    binary,
+    dryRun,
+  };
+}
+
+export function removeContextModeIntegration(home, options = {}) {
+  const dryRun = options.dryRun === true;
+  const warnings = [];
+  const changedFiles = [];
+
+  const removals = [
+    ['Codex MCP', join(home, '.codex', 'config.toml'), () => removeCodexToml(join(home, '.codex', 'config.toml'), warnings, dryRun)],
+    ['Codex hooks', join(home, '.codex', 'hooks.json'), () => removeCodexHooks(join(home, '.codex', 'hooks.json'), dryRun)],
+    ['Cursor MCP', join(home, '.cursor', 'mcp.json'), () => removeJsonMcpServer(join(home, '.cursor', 'mcp.json'), dryRun)],
+    ['Cursor hooks', join(home, '.cursor', 'hooks.json'), () => removeCursorHooks(join(home, '.cursor', 'hooks.json'), dryRun)],
+    ['Claude MCP', join(home, '.claude.json'), () => removeJsonMcpServer(join(home, '.claude.json'), dryRun)],
+  ];
+
+  for (const [label, filePath, remove] of removals) {
+    if (runConfigMutation(label, filePath, remove, warnings)) changedFiles.push(filePath);
+  }
+
+  return {
+    changedFiles: unique(changedFiles),
+    warnings,
+    dryRun,
+  };
+}
+
+export function getContextModeIntegrationSummary(home, options = {}) {
+  const env = options.env || process.env;
+  const binary = detectContextModeBinary({ env });
+  const hasAnyConfig = hasAnyContextModeConfig(home);
+  const configured = binary.present && hasCompleteContextModeConfig(home);
+  const state = configured ? 'configured' : hasAnyConfig ? 'broken' : 'absent';
+  const summary = configured
+    ? `context-mode configured (${binary.version || 'version unknown'})`
+    : hasAnyConfig
+      ? `context-mode partially configured; run aw integration add ${INTEGRATION_NAME}`
+      : `context-mode not configured${binary.present ? '' : '; binary not installed'}`;
+
+  return {
+    name: INTEGRATION_NAME,
+    installed: binary.present,
+    configured,
+    state,
+    version: binary.version,
+    path: binary.path,
+    summary,
+    binary,
+  };
+}
+
+export function getContextModeDoctorStatus(home, options = {}) {
+  const summary = getContextModeIntegrationSummary(home, options);
+  if (summary.configured) {
+    return [{
+      id: 'context-mode',
+      title: 'Context Mode integration',
+      status: 'pass',
+      summary: summary.summary,
+      fix: null,
+    }];
+  }
+
+  if (summary.state === 'broken') {
+    return [{
+      id: 'context-mode',
+      title: 'Context Mode integration',
+      status: 'warn',
+      summary: summary.summary,
+      fix: `Run \`aw integration add ${INTEGRATION_NAME}\` to repair or \`aw integration remove ${INTEGRATION_NAME}\` to clean it up.`,
+    }];
+  }
+
+  return [{
+    id: 'context-mode',
+    title: 'Context Mode integration',
+    status: 'pass',
+    summary: summary.summary,
+    fix: null,
+  }];
+}

package/integrations/index.mjs

@@ -0,0 +1,31 @@
+import {
+  ensureContextModeIntegration,
+  getContextModeIntegrationSummary,
+  removeContextModeIntegration,
+} from './context-mode.mjs';
+
+export const KNOWN_INTEGRATIONS = [
+  {
+    name: 'context-mode',
+    description: 'Local context-mode MCP server and hook integration.',
+    add: ensureContextModeIntegration,
+    remove: removeContextModeIntegration,
+    status: getContextModeIntegrationSummary,
+  },
+];
+
+export function resolveIntegration(name) {
+  const normalized = String(name || '').trim().toLowerCase();
+  const integration = KNOWN_INTEGRATIONS.find(item => item.name === normalized);
+  if (integration) return integration;
+
+  const known = KNOWN_INTEGRATIONS.map(item => item.name).join(', ');
+  throw new Error(`Unknown integration: ${name || '<missing>'}. Known integrations: ${known}`);
+}
+
+export function listIntegrations(home, options = {}) {
+  return KNOWN_INTEGRATIONS.map(integration => ({
+    ...integration.status(home, options),
+    description: integration.description,
+  }));
+}