@imdeadpool/guardex 7.0.41 → 7.1.0

package/src/agents/inspect.js

@@ -0,0 +1,202 @@
+const { fs, path, DEFAULT_BASE_BRANCH, LOCK_FILE_RELATIVE } = require('../context');
+const { run } = require('../core/runtime');
+const { resolveRepoRoot } = require('../git');
+
+const INSPECT_EXCLUDE_PATHS = new Set([LOCK_FILE_RELATIVE]);
+
+function git(repoRoot, args, options = {}) {
+  const result = run('git', ['-C', repoRoot, ...args], options);
+  if (result.status !== 0 && !options.allowFailure) {
+    throw new Error(`git ${args.join(' ')} failed: ${(result.stderr || '').trim()}`);
+  }
+  return result;
+}
+
+function readGitConfig(repoRoot, key) {
+  const result = git(repoRoot, ['config', '--get', key], { allowFailure: true });
+  return result.status === 0 ? String(result.stdout || '').trim() : '';
+}
+
+function refExists(repoRoot, ref) {
+  return git(repoRoot, ['show-ref', '--verify', '--quiet', ref], { allowFailure: true }).status === 0;
+}
+
+function parseWorktreeList(outputText) {
+  const worktrees = [];
+  let current = null;
+
+  for (const line of String(outputText || '').split(/\r?\n/)) {
+    if (!line.trim()) {
+      if (current) worktrees.push(current);
+      current = null;
+      continue;
+    }
+    if (line.startsWith('worktree ')) {
+      if (current) worktrees.push(current);
+      current = { path: line.slice('worktree '.length), branch: '' };
+      continue;
+    }
+    if (current && line.startsWith('branch ')) {
+      current.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '');
+    }
+  }
+  if (current) worktrees.push(current);
+
+  return worktrees;
+}
+
+function listWorktrees(repoRoot) {
+  const result = git(repoRoot, ['worktree', 'list', '--porcelain'], { allowFailure: true });
+  return result.status === 0 ? parseWorktreeList(result.stdout) : null;
+}
+
+// `worktrees` (pre-parsed via listWorktrees) lets callers iterating many branches
+// in one pass hoist the invariant `git worktree list` out of their loop. When
+// omitted, the list is fetched on demand — unchanged behavior.
+function worktreePathForBranch(repoRoot, branch, worktrees = null) {
+  let entries = worktrees;
+  if (entries == null) {
+    const result = git(repoRoot, ['worktree', 'list', '--porcelain'], { allowFailure: true });
+    if (result.status !== 0) return { worktreePath: repoRoot, worktreeFound: false };
+    entries = parseWorktreeList(result.stdout);
+  }
+  const match = entries.find((entry) => entry.branch === branch);
+  return {
+    worktreePath: match?.path || repoRoot,
+    worktreeFound: Boolean(match?.path),
+  };
+}
+
+function resolveBaseBranch(repoRoot, branch) {
+  return (
+    readGitConfig(repoRoot, `branch.${branch}.guardexBase`) ||
+    readGitConfig(repoRoot, 'multiagent.baseBranch') ||
+    DEFAULT_BASE_BRANCH
+  );
+}
+
+function compareRefForBase(repoRoot, baseBranch) {
+  if (refExists(repoRoot, `refs/remotes/origin/${baseBranch}`)) {
+    return `origin/${baseBranch}`;
+  }
+  return baseBranch;
+}
+
+function readLockRegistry(repoRoot, branch) {
+  const lockPath = path.join(repoRoot, LOCK_FILE_RELATIVE);
+  let parsed = null;
+  try {
+    parsed = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+  } catch (_error) {
+    parsed = null;
+  }
+  const locks = parsed?.locks && typeof parsed.locks === 'object' && !Array.isArray(parsed.locks)
+    ? parsed.locks
+    : {};
+
+  return Object.entries(locks)
+    .map(([filePath, entry]) => {
+      if (!entry || typeof entry !== 'object' || entry.branch !== branch) return null;
+      return {
+        file: filePath,
+        branch: entry.branch,
+        claimedAt: entry.claimed_at || '',
+        allowDelete: Boolean(entry.allow_delete),
+      };
+    })
+    .filter(Boolean)
+    .sort((left, right) => left.file.localeCompare(right.file));
+}
+
+function splitGitLines(outputText) {
+  return String(outputText || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function readUntrackedFiles(worktreePath) {
+  const result = git(worktreePath, ['ls-files', '--others', '--exclude-standard'], { allowFailure: true });
+  return result.status === 0
+    ? splitGitLines(result.stdout).filter((filePath) => !INSPECT_EXCLUDE_PATHS.has(filePath))
+    : [];
+}
+
+function inspectAgentBranch(options) {
+  const repoRoot = resolveRepoRoot(options.target || process.cwd());
+  const branch = String(options.branch || '').trim();
+  if (!branch) {
+    throw new Error('--branch requires an agent branch name');
+  }
+
+  const baseBranch = resolveBaseBranch(repoRoot, branch);
+  const compareRef = compareRefForBase(repoRoot, baseBranch);
+  const { worktreePath, worktreeFound } = worktreePathForBranch(repoRoot, branch, options.worktrees);
+  return { repoRoot, branch, baseBranch, compareRef, worktreePath, worktreeFound };
+}
+
+function changedFiles(options) {
+  const context = inspectAgentBranch(options);
+  const diffTarget = context.worktreeFound ? context.compareRef : `${context.compareRef}...${context.branch}`;
+  const result = git(context.worktreePath, ['diff', '--name-only', diffTarget, '--', '.', `:(exclude)${LOCK_FILE_RELATIVE}`]);
+  const files = [...splitGitLines(result.stdout), ...(context.worktreeFound ? readUntrackedFiles(context.worktreePath) : [])];
+  const uniqueFiles = Array.from(new Set(files)).sort((left, right) => left.localeCompare(right));
+  return { ...context, files: uniqueFiles };
+}
+
+function branchDiff(options) {
+  const context = inspectAgentBranch(options);
+  const diffTarget = context.worktreeFound ? context.compareRef : `${context.compareRef}...${context.branch}`;
+  const result = git(context.worktreePath, ['diff', diffTarget, '--', '.', `:(exclude)${LOCK_FILE_RELATIVE}`]);
+  const untrackedDiff = context.worktreeFound
+    ? readUntrackedFiles(context.worktreePath)
+      .map((filePath) => git(context.worktreePath, ['diff', '--no-index', '--', '/dev/null', filePath], { allowFailure: true }).stdout || '')
+      .join('')
+    : '';
+  return { ...context, diff: `${result.stdout || ''}${untrackedDiff}` };
+}
+
+function branchLocks(options) {
+  const context = inspectAgentBranch(options);
+  return { ...context, locks: readLockRegistry(context.repoRoot, context.branch) };
+}
+
+function renderFiles(payload, { json = false } = {}) {
+  if (json) return `${JSON.stringify(payload, null, 2)}\n`;
+  return payload.files.length > 0 ? `${payload.files.join('\n')}\n` : '';
+}
+
+function renderDiff(payload, { json = false } = {}) {
+  if (json) return `${JSON.stringify(payload, null, 2)}\n`;
+  return payload.diff;
+}
+
+function renderLocks(payload, { json = false } = {}) {
+  if (json) return `${JSON.stringify(payload, null, 2)}\n`;
+  if (payload.locks.length === 0) return '';
+  return `${payload.locks
+    .map((lock) => `${lock.file}\t${lock.branch}\t${lock.claimedAt}\tallow_delete=${lock.allowDelete ? 'true' : 'false'}`)
+    .join('\n')}\n`;
+}
+
+function runInspectCommand(options) {
+  if (options.subcommand === 'files') return renderFiles(changedFiles(options), options);
+  if (options.subcommand === 'diff') return renderDiff(branchDiff(options), options);
+  if (options.subcommand === 'locks') return renderLocks(branchLocks(options), options);
+  throw new Error(`Unknown agents subcommand: ${options.subcommand}`);
+}
+
+module.exports = {
+  branchDiff,
+  branchLocks,
+  changedFiles,
+  inspectAgentBranch,
+  listWorktrees,
+  parseWorktreeList,
+  readLockRegistry,
+  renderDiff,
+  renderFiles,
+  renderLocks,
+  resolveBaseBranch,
+  runInspectCommand,
+};

package/src/agents/launch.js

@@ -0,0 +1,249 @@
+'use strict';
+
+let registryModule = {};
+let registryPath = null;
+
+try {
+  registryPath = require.resolve('./registry');
+} catch (error) {
+  if (error && error.code !== 'MODULE_NOT_FOUND') {
+    throw error;
+  }
+}
+
+if (registryPath) {
+  registryModule = require(registryPath);
+}
+
+const FALLBACK_AGENTS = {
+  codex: {
+    command: 'codex',
+    promptMode: 'positional',
+    resumeCommand: ['codex', 'resume'],
+    permissionFlag: '--permission-mode',
+  },
+  claude: {
+    command: 'claude',
+    promptMode: 'option',
+    promptFlag: '--prompt',
+    resumeCommand: ['claude', '--continue'],
+    permissionFlag: '--permission-mode',
+  },
+  opencode: {
+    command: 'opencode',
+    promptMode: 'positional',
+    resumeCommand: ['opencode', 'resume'],
+    permissionFlag: '--permission-mode',
+  },
+  cursor: {
+    command: 'cursor-agent',
+    promptMode: 'stdin',
+    resumeCommand: ['cursor-agent', 'resume'],
+    permissionFlag: '--permission-mode',
+  },
+  gemini: {
+    command: 'gemini',
+    promptMode: 'option',
+    promptFlag: '--prompt',
+    resumeCommand: ['gemini', 'resume'],
+    permissionFlag: '--permission-mode',
+  },
+};
+
+const SUPPORTED_PROMPT_MODES = new Set(['positional', 'option', 'stdin', 'argument']);
+
+function shellQuote(value) {
+  const stringValue = String(value);
+  if (stringValue.length === 0) return "''";
+  return `'${stringValue.replace(/'/g, `'\\''`)}'`;
+}
+
+function normalizeCommandParts(command) {
+  if (Array.isArray(command)) return command.map(String);
+  if (command && typeof command === 'object') {
+    return [
+      ...normalizeCommandParts(command.command || command.executable || command.bin),
+      ...normalizeCommandParts(command.args || command.defaultArgs),
+    ];
+  }
+  if (typeof command === 'string' && command.trim()) return [command];
+  return [];
+}
+
+function normalizeAgentsCollection(collection) {
+  if (!collection) return null;
+  if (collection instanceof Map) return Object.fromEntries(collection.entries());
+  if (Array.isArray(collection)) {
+    return Object.fromEntries(collection.map((agent) => [agent.id || agent.agentId || agent.name, agent]));
+  }
+  if (typeof collection === 'object') return collection;
+  return null;
+}
+
+function getRegistryAgent(agentId) {
+  const lookupFunctions = [
+    registryModule.getAgent,
+    registryModule.getAgentById,
+    registryModule.getAgentDefinition,
+    registryModule.resolveAgent,
+  ].filter((candidate) => typeof candidate === 'function');
+
+  for (const lookup of lookupFunctions) {
+    const agent = lookup(agentId);
+    if (agent) return agent;
+  }
+
+  const collections = [
+    registryModule.AGENTS,
+    registryModule.AGENT_REGISTRY,
+    registryModule.SUPPORTED_AGENTS,
+    registryModule.agents,
+    registryModule.registry,
+    registryModule.default,
+  ];
+
+  for (const collection of collections) {
+    const normalized = normalizeAgentsCollection(collection);
+    if (normalized && normalized[agentId]) return normalized[agentId];
+  }
+
+  return null;
+}
+
+function resolveAgent(agentId) {
+  if (!agentId || typeof agentId !== 'string') {
+    throw new TypeError('agentId is required');
+  }
+
+  const registryAgent = getRegistryAgent(agentId);
+  const fallbackAgent = FALLBACK_AGENTS[agentId];
+  const agent = { ...fallbackAgent, ...registryAgent };
+
+  if (!agent || (!agent.command && !agent.executable && !agent.bin)) {
+    throw new Error(`Unsupported agent: ${agentId}`);
+  }
+
+  return agent;
+}
+
+function buildPermissionParts(agent, permissionMode) {
+  if (!permissionMode) return [];
+
+  if (typeof agent.buildPermissionArgs === 'function') {
+    return normalizeCommandParts(agent.buildPermissionArgs(permissionMode));
+  }
+
+  const flag = agent.permissionFlag ||
+    agent.permissionModeFlag ||
+    agent.permission?.flag ||
+    agent.permissionMode?.flag;
+  if (!flag) return [];
+  return [flag, permissionMode];
+}
+
+function buildSessionParts(agent, sessionId) {
+  if (!sessionId) return [];
+
+  if (typeof agent.buildSessionArgs === 'function') {
+    return normalizeCommandParts(agent.buildSessionArgs(sessionId));
+  }
+
+  const flag = agent.sessionFlag || agent.sessionIdFlag || agent.session?.flag;
+  if (!flag) return [];
+  return [flag, sessionId];
+}
+
+function buildSessionEnv(agent, sessionId) {
+  if (!sessionId) return [];
+  const envVar = agent.sessionEnvVar || agent.session?.env || 'OMX_SESSION_ID';
+  return [`${envVar}=${shellQuote(sessionId)}`];
+}
+
+function commandToShell(parts) {
+  return parts.map(shellQuote).join(' ');
+}
+
+function buildPromptCommand(parts, agent, prompt) {
+  if (prompt === undefined || prompt === null || prompt === '') {
+    return commandToShell(parts);
+  }
+
+  const promptMode = agent.promptMode || agent.prompt?.mode || 'positional';
+  if (!SUPPORTED_PROMPT_MODES.has(promptMode)) {
+    throw new Error(`Unsupported prompt mode for ${agent.id || agent.command}: ${promptMode}`);
+  }
+
+  if (promptMode === 'stdin') {
+    return `printf %s ${shellQuote(prompt)} | ${commandToShell(parts)}`;
+  }
+
+  if (promptMode === 'option') {
+    const promptFlag = agent.promptFlag || agent.promptOption || agent.prompt?.flag || agent.prompt?.option || '--prompt';
+    return commandToShell([...parts, promptFlag, prompt]);
+  }
+
+  return commandToShell([...parts, prompt]);
+}
+
+function buildResourceEnv() {
+  const cpus = require('node:os').cpus().length || 8;
+  // Cap each agent's cargo parallelism to avoid overwhelming the system
+  // when multiple agents build concurrently.
+  const jobs = Math.max(2, Math.floor(cpus / 4));
+  return [`CARGO_BUILD_JOBS=${jobs}`];
+}
+
+function buildAgentLaunchCommand(options) {
+  if (!options || typeof options !== 'object') {
+    throw new TypeError('options are required');
+  }
+
+  const { agentId, prompt, worktreePath, permissionMode, sessionId } = options;
+  const agent = resolveAgent(agentId);
+  const command = normalizeCommandParts(agent.launchCommand || agent.launch || agent.command || agent.executable || agent.bin);
+  const baseParts = [
+    ...command,
+    ...normalizeCommandParts(agent.defaultArgs),
+    ...normalizeCommandParts(agent.args),
+    ...normalizeCommandParts(agent.launchArgs),
+    ...buildPermissionParts(agent, permissionMode),
+    ...buildSessionParts(agent, sessionId),
+  ];
+
+  if (baseParts.length === 0) {
+    throw new Error(`Unsupported agent: ${agentId}`);
+  }
+
+  const launchCommand = buildPromptCommand(baseParts, agent, prompt);
+  const envParts = [...buildResourceEnv(), ...buildSessionEnv(agent, sessionId)];
+  const envPrefix = envParts.join(' ');
+  const launchWithEnv = envPrefix ? `${envPrefix} ${launchCommand}` : launchCommand;
+  if (!worktreePath) return launchWithEnv;
+  return `cd ${shellQuote(worktreePath)} && ${launchWithEnv}`;
+}
+
+function buildAgentResumeCommand(agentId, permissionMode) {
+  const agent = resolveAgent(agentId);
+  const commandParts = normalizeCommandParts(agent.command || agent.executable || agent.bin);
+  const explicitResume = agent.resumeCommand || agent.resume;
+  const resumeArgs = normalizeCommandParts(agent.resumeArgs);
+  const resumeParts = explicitResume
+    ? normalizeCommandParts(explicitResume)
+    : [...commandParts, ...(resumeArgs.length > 0 ? resumeArgs : ['resume'])];
+  const command = [
+    ...resumeParts,
+    ...buildPermissionParts(agent, permissionMode),
+  ];
+
+  if (command.length === 0) {
+    throw new Error(`Unsupported agent: ${agentId}`);
+  }
+
+  return commandToShell(command);
+}
+
+module.exports = {
+  buildAgentLaunchCommand,
+  buildAgentResumeCommand,
+  shellQuote,
+};

package/src/agents/registry.js

@@ -0,0 +1,133 @@
+const AGENT_DEFINITIONS = [
+  {
+    id: 'codex',
+    label: 'Codex',
+    shortLabel: 'CX',
+    description: 'OpenAI Codex CLI for repository-aware coding tasks.',
+    command: 'codex',
+    detectCommand: 'codex --version',
+    defaultEnabled: true,
+    promptMode: 'argument',
+    resumeCommandTemplate: 'codex resume {sessionId}',
+    worktreeRoot: '.omx/agent-worktrees',
+  },
+  {
+    id: 'claude',
+    label: 'Claude Code',
+    shortLabel: 'CC',
+    description: 'Anthropic Claude Code CLI for interactive coding sessions.',
+    command: 'claude',
+    detectCommand: 'claude --version',
+    defaultEnabled: true,
+    promptMode: 'argument',
+    resumeCommandTemplate: 'claude --resume {sessionId}',
+    worktreeRoot: '.omc/agent-worktrees',
+  },
+  {
+    id: 'opencode',
+    label: 'OpenCode',
+    shortLabel: 'OC',
+    description: 'OpenCode CLI for terminal-native AI coding workflows.',
+    command: 'opencode',
+    detectCommand: 'opencode --version',
+    defaultEnabled: true,
+    promptMode: 'argument',
+    worktreeRoot: '.omx/agent-worktrees',
+  },
+  {
+    id: 'cursor',
+    label: 'Cursor Agent',
+    shortLabel: 'CA',
+    description: 'Cursor command-line agent for AI coding tasks.',
+    command: 'cursor-agent',
+    detectCommand: 'cursor-agent --version',
+    defaultEnabled: true,
+    promptMode: 'argument',
+    worktreeRoot: '.omx/agent-worktrees',
+  },
+  {
+    id: 'gemini',
+    label: 'Gemini CLI',
+    shortLabel: 'GM',
+    description: 'Google Gemini CLI for AI-assisted development workflows.',
+    command: 'gemini',
+    detectCommand: 'gemini --version',
+    defaultEnabled: true,
+    promptMode: 'argument',
+    worktreeRoot: '.omx/agent-worktrees',
+  },
+];
+
+function validateAgentDefinitions(definitions) {
+  const ids = new Set();
+  const shortLabels = new Set();
+
+  for (const definition of definitions) {
+    if (ids.has(definition.id)) {
+      throw new Error(`Duplicate agent id: ${definition.id}`);
+    }
+    ids.add(definition.id);
+
+    if (shortLabels.has(definition.shortLabel)) {
+      throw new Error(`Duplicate agent short label: ${definition.shortLabel}`);
+    }
+    shortLabels.add(definition.shortLabel);
+  }
+}
+
+validateAgentDefinitions(AGENT_DEFINITIONS);
+
+const AGENT_IDS = Object.freeze(AGENT_DEFINITIONS.map((definition) => definition.id));
+const AGENT_REGISTRY = Object.freeze(
+  Object.fromEntries(
+    AGENT_DEFINITIONS.map((definition) => [
+      definition.id,
+      Object.freeze({ ...definition }),
+    ]),
+  ),
+);
+
+function normalizeAgentId(rawAgentId) {
+  return String(rawAgentId || 'codex').trim().toLowerCase();
+}
+
+function isAgentId(value) {
+  return Object.prototype.hasOwnProperty.call(AGENT_REGISTRY, value);
+}
+
+function getAgentDefinition(id) {
+  return AGENT_REGISTRY[id];
+}
+
+function getAgentDefinitions() {
+  return AGENT_IDS.map((id) => AGENT_REGISTRY[id]);
+}
+
+function getDefaultEnabledAgents() {
+  return getAgentDefinitions().filter((definition) => definition.defaultEnabled);
+}
+
+function listAgentIds() {
+  return [...AGENT_IDS];
+}
+
+function resolveAgent(rawAgentId) {
+  const agentId = normalizeAgentId(rawAgentId);
+  const agent = getAgentDefinition(agentId);
+  if (!agent) {
+    throw new Error(`Unknown agent id: ${rawAgentId || '(empty)'} (expected one of: ${listAgentIds().join(', ')})`);
+  }
+  return agent;
+}
+
+module.exports = {
+  AGENT_IDS,
+  AGENT_REGISTRY,
+  isAgentId,
+  getAgentDefinition,
+  getAgentDefinitions,
+  getDefaultEnabledAgents,
+  listAgentIds,
+  normalizeAgentId,
+  resolveAgent,
+};