fuli-context 0.2.0

package/src/setup/agents.js

@@ -0,0 +1,123 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+import { connectCursor, disconnectCursor } from './cursor-config.js';
+import { connectCodex, disconnectCodex } from './codex-config.js';
+
+export function discoverAgents({
+  platform = process.platform,
+  env = process.env,
+  homeDir = homedir(),
+  fileExists = existsSync,
+  commandExists = (command) => defaultCommandExists(command, platform)
+} = {}) {
+  const pathApi = platform === 'win32' ? path.win32 : path.posix;
+  const codexHome = nonEmpty(env.CODEX_HOME) ?? pathApi.join(homeDir, '.codex');
+  const skillName = 'capturing-session-knowledge';
+  const projectSkillName = 'grilling-project';
+  return [
+    {
+      id: 'codex',
+      label: 'Codex',
+      command: 'codex',
+      configPath: pathApi.join(codexHome, 'config.toml'),
+      globalInstructionsPath: pathApi.join(codexHome, 'AGENTS.md'),
+      globalInstructionsOverridePath: pathApi.join(codexHome, 'AGENTS.override.md'),
+      skillPath: pathApi.join(homeDir, '.agents', 'skills', skillName),
+      projectSkillPath: pathApi.join(homeDir, '.agents', 'skills', projectSkillName),
+      available: Boolean(commandExists('codex') || fileExists(pathApi.join(codexHome, 'config.toml')))
+    },
+    {
+      id: 'claude-code',
+      label: 'Claude Code',
+      command: 'claude',
+      configPath: pathApi.join(homeDir, '.claude.json'),
+      skillPath: pathApi.join(homeDir, '.claude', 'skills', skillName),
+      projectSkillPath: pathApi.join(homeDir, '.claude', 'skills', projectSkillName),
+      available: Boolean(commandExists('claude'))
+    },
+    {
+      id: 'cursor',
+      label: 'Cursor',
+      command: 'cursor',
+      configPath: pathApi.join(homeDir, '.cursor', 'mcp.json'),
+      skillPath: pathApi.join(homeDir, '.cursor', 'skills', skillName),
+      projectSkillPath: pathApi.join(homeDir, '.cursor', 'skills', projectSkillName),
+      available: Boolean(commandExists('cursor'))
+    }
+  ];
+}
+
+export function buildAgentCommands(agent, context) {
+  const serverArgs = [
+    context.mcpServerPath,
+    '--runtime-config',
+    context.runtimeConfigPath
+  ];
+  const mcpArgs = [context.nodePath, ...serverArgs];
+  if (agent.id === 'codex') {
+    return {
+      remove: [agent.command, ['mcp', 'remove', 'fuli']],
+      add: [agent.command, ['mcp', 'add', 'fuli', '--', ...mcpArgs]]
+    };
+  }
+  if (agent.id === 'claude-code') {
+    return {
+      remove: [agent.command, ['mcp', 'remove', '--scope', 'user', 'fuli']],
+      add: [agent.command, ['mcp', 'add', '--scope', 'user', 'fuli', '--', ...mcpArgs]]
+    };
+  }
+  throw new TypeError(`Unsupported agent: ${agent.id}`);
+}
+
+export function connectAgent(agent, context, {
+  runCommand = defaultRunCommand,
+  connectCodexConfig = connectCodex,
+  connectCursorConfig = connectCursor
+} = {}) {
+  if (agent.id === 'codex') return connectCodexConfig(agent, context);
+  if (agent.id === 'cursor') return connectCursorConfig(agent, context);
+
+  const commands = buildAgentCommands(agent, context);
+  runCommand(...commands.remove);
+  const result = runCommand(...commands.add);
+  if (result?.status !== 0) {
+    throw new Error(`Could not connect ${agent.label} to Fuli`);
+  }
+  return { id: agent.id, label: agent.label, status: 'connected' };
+}
+
+export function disconnectAgent(agent, {
+  disconnectCodexConfig = disconnectCodex,
+  disconnectJsonConfig = disconnectCursor
+} = {}) {
+  if (agent.id === 'codex') return disconnectCodexConfig(agent);
+  if (agent.id === 'cursor' || agent.id === 'claude-code') {
+    return disconnectJsonConfig(agent);
+  }
+  throw new TypeError(`Unsupported agent: ${agent.id}`);
+}
+
+export function defaultCommandExists(command, platform = process.platform) {
+  const locator = platform === 'win32' ? 'where.exe' : 'which';
+  const result = spawnSync(locator, [command], {
+    encoding: 'utf8',
+    windowsHide: true,
+    stdio: 'ignore'
+  });
+  return result.status === 0;
+}
+
+function defaultRunCommand(command, args) {
+  return spawnSync(command, args, {
+    encoding: 'utf8',
+    windowsHide: true,
+    stdio: 'pipe'
+  });
+}
+
+function nonEmpty(value) {
+  return typeof value === 'string' && value.trim() ? value : null;
+}

package/src/setup/codex-bootstrap.js

@@ -0,0 +1,118 @@
+import { randomUUID } from 'node:crypto';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+
+const BLOCK_START = '<!-- BEGIN FULI MANAGED INSTRUCTIONS -->';
+const BLOCK_END = '<!-- END FULI MANAGED INSTRUCTIONS -->';
+
+const GLOBAL_INSTRUCTIONS = `${BLOCK_START}
+At the start of every user task, before any other tool or answer, call exactly
+\`get_collaboration_preferences\` with \`projectPath\`=current working directory. Never substitute
+project action or Fuli tool.
+Apply all returned \`effective_preferences\` before answers or tools. For write tools, enforce
+them in the actual payload; mentioning them later is not compliance.
+Before using a relevant \`deferred_conflict\`, call
+\`resolve_deferred_preference_conflict\`; ignore unrelated ones.
+The current request wins on conflict.
+${BLOCK_END}`;
+
+export function installCodexBootstrap(agent, _context, {
+  fileExists = existsSync,
+  readText = defaultReadText,
+  writeText = writeTextAtomic
+} = {}) {
+  if (!agent?.globalInstructionsPath) return { changed: false };
+  const instructionsPath = activeGlobalInstructionsPath(agent, {
+    fileExists,
+    readText
+  });
+  const current = readText(instructionsPath);
+  const next = replaceFuliGlobalInstructions(current);
+  if (next === current) return { changed: false };
+  writeText(instructionsPath, next);
+  return { changed: true };
+}
+
+export function removeCodexBootstrap(agent, {
+  fileExists = existsSync,
+  readText = defaultReadText,
+  writeText = writeTextAtomic
+} = {}) {
+  let changed = false;
+  for (const filePath of [
+    agent.globalInstructionsPath,
+    agent.globalInstructionsOverridePath
+  ].filter(Boolean)) {
+    if (!fileExists(filePath)) continue;
+    const current = readText(filePath);
+    const next = removeFuliGlobalInstructions(current);
+    if (next === current) continue;
+    writeText(filePath, next);
+    changed = true;
+  }
+  return { changed };
+}
+
+export function isCodexBootstrapCurrent(agent, _context, {
+  fileExists = existsSync,
+  readText = defaultReadText
+} = {}) {
+  if (!agent?.globalInstructionsPath) return false;
+  try {
+    const instructionsPath = activeGlobalInstructionsPath(agent, {
+      fileExists,
+      readText
+    });
+    const current = readText(instructionsPath);
+    return replaceFuliGlobalInstructions(current) === current;
+  } catch {
+    return false;
+  }
+}
+
+export function replaceFuliGlobalInstructions(source) {
+  const withoutBlock = removeFuliGlobalInstructions(source).trimEnd();
+  return `${withoutBlock ? `${withoutBlock}\n\n` : ''}${GLOBAL_INSTRUCTIONS}\n`;
+}
+
+export function removeFuliGlobalInstructions(source) {
+  const start = source.indexOf(BLOCK_START);
+  if (start === -1) return source;
+  const end = source.indexOf(BLOCK_END, start);
+  if (end === -1) return source;
+  const before = source.slice(0, start).trimEnd();
+  const after = source.slice(end + BLOCK_END.length).trimStart();
+  if (before && after) return `${before}\n\n${after}`;
+  if (before) return `${before}\n`;
+  return after;
+}
+
+function activeGlobalInstructionsPath(agent, { fileExists, readText }) {
+  const override = agent.globalInstructionsOverridePath;
+  if (override && fileExists(override) && readText(override).trim()) return override;
+  return agent.globalInstructionsPath;
+}
+
+function defaultReadText(filePath) {
+  return existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+}
+
+function writeTextAtomic(filePath, value) {
+  const directory = dirname(filePath);
+  const temporary = join(directory, `.${basename(filePath)}.${randomUUID()}.tmp`);
+  mkdirSync(directory, { recursive: true });
+  try {
+    writeFileSync(temporary, value, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    renameSync(temporary, filePath);
+  } catch (error) {
+    rmSync(temporary, { force: true });
+    throw error;
+  }
+}

package/src/setup/codex-config.js

@@ -0,0 +1,122 @@
+import { randomUUID } from 'node:crypto';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+
+import {
+  installCodexBootstrap,
+  removeCodexBootstrap
+} from './codex-bootstrap.js';
+
+export function connectCodex(agent, context, {
+  readConfig = readText,
+  writeConfig = writeTextAtomic,
+  installBootstrap = installCodexBootstrap
+} = {}) {
+  const current = readConfig(agent.configPath);
+  const next = replaceFuliTable(current, {
+    command: context.nodePath,
+    args: [context.mcpServerPath, '--runtime-config', context.runtimeConfigPath]
+  });
+  const bootstrap = installBootstrap(agent, context);
+  const registrationChanged = next !== current;
+  if (registrationChanged) writeConfig(agent.configPath, next);
+  return {
+    id: agent.id,
+    label: agent.label,
+    status: 'connected',
+    newTaskRequired: registrationChanged || bootstrap.changed === true
+  };
+}
+
+export function disconnectCodex(agent, {
+  fileExists = existsSync,
+  readConfig = readText,
+  writeConfig = writeTextAtomic,
+  removeBootstrap = removeCodexBootstrap
+} = {}) {
+  const bootstrap = removeBootstrap(agent);
+  let registrationChanged = false;
+  if (fileExists(agent.configPath)) {
+    const current = readConfig(agent.configPath);
+    const next = removeFuliTables(current);
+    if (next !== current) {
+      writeConfig(agent.configPath, next);
+      registrationChanged = true;
+    }
+  }
+  return {
+    id: agent.id,
+    label: agent.label,
+    status: registrationChanged || bootstrap.changed ? 'disconnected' : 'not_connected'
+  };
+}
+
+export function replaceFuliTable(source, { command, args }) {
+  const withoutFuli = removeFuliTables(source);
+  const lines = withoutFuli.replaceAll('\r\n', '\n').split('\n');
+  while (lines.length && !lines.at(-1).trim()) lines.pop();
+  const block = [
+    '[mcp_servers.fuli]',
+    `command = ${tomlString(command)}`,
+    `args = [${args.map(tomlString).join(', ')}]`,
+    'enabled = true',
+    'required = true',
+    'startup_timeout_sec = 30',
+    'tool_timeout_sec = 120',
+    'default_tools_approval_mode = "auto"'
+  ];
+  return `${[...lines, ...(lines.length ? [''] : []), ...block].join('\n')}\n`;
+}
+
+export function removeFuliTables(source) {
+  const lines = source.replaceAll('\r\n', '\n').split('\n');
+  const kept = [];
+  let skipping = false;
+  let removed = false;
+
+  for (const line of lines) {
+    const header = /^\s*\[([^\]]+)]\s*(?:#.*)?$/.exec(line)?.[1]?.trim();
+    if (header) {
+      skipping = isFuliTable(header);
+      if (skipping) removed = true;
+    }
+    if (!skipping) kept.push(line);
+  }
+
+  if (!removed) return source;
+  while (kept.length && !kept.at(-1).trim()) kept.pop();
+  return kept.length ? `${kept.join('\n')}\n` : '';
+}
+
+function isFuliTable(header) {
+  return /^mcp_servers\.(?:fuli|"fuli"|'fuli')(?:\.|$)/.test(header);
+}
+
+function tomlString(value) {
+  if (typeof value !== 'string' || !value) throw new TypeError('Codex MCP values must be nonempty');
+  return JSON.stringify(value);
+}
+
+function readText(filePath) {
+  return existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+}
+
+function writeTextAtomic(filePath, value) {
+  const directory = dirname(filePath);
+  const tempPath = join(directory, `.${basename(filePath)}.${randomUUID()}.tmp`);
+  mkdirSync(directory, { recursive: true });
+  try {
+    writeFileSync(tempPath, value, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    renameSync(tempPath, filePath);
+  } catch (error) {
+    rmSync(tempPath, { force: true });
+    throw error;
+  }
+}

package/src/setup/config-backup.js

@@ -0,0 +1,22 @@
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync
+} from 'node:fs';
+import { extname, join } from 'node:path';
+
+export function backupAgentConfig(agent, {
+  backupDir,
+  now = () => new Date(),
+  fileExists = existsSync,
+  makeDirectory = mkdirSync,
+  copyFile = copyFileSync
+}) {
+  if (!fileExists(agent.configPath)) return null;
+  makeDirectory(backupDir, { recursive: true });
+  const timestamp = now().toISOString().replaceAll(':', '-').replaceAll('.', '-');
+  const extension = extname(agent.configPath) || '.bak';
+  const backupPath = join(backupDir, `${agent.id}-${timestamp}${extension}`);
+  copyFile(agent.configPath, backupPath);
+  return backupPath;
+}