@imdeadpool/guardex 7.0.41 → 7.0.43

package/src/agents/finish.js

@@ -0,0 +1,172 @@
+const { TOOL_NAME } = require('../context');
+const finishCommands = require('../finish');
+const {
+  readAgentSession,
+  updateAgentSession,
+  listAgentSessions,
+} = require('./sessions');
+
+function resolveSessionByBranch(repoRoot, branch) {
+  const matches = listAgentSessions(repoRoot).filter((session) => session.branch === branch);
+  if (matches.length === 0) {
+    return null;
+  }
+  if (matches.length > 1) {
+    throw new Error(`Multiple agent sessions found for branch: ${branch}`);
+  }
+  return matches[0];
+}
+
+function resolveAgentSessionForFinish(repoRoot, options) {
+  if (options.sessionId) {
+    const session = readAgentSession(repoRoot, options.sessionId);
+    if (!session) {
+      throw new Error(`Agent session not found: ${options.sessionId}`);
+    }
+    return session;
+  }
+
+  if (options.branch) {
+    const session = resolveSessionByBranch(repoRoot, options.branch);
+    if (!session) {
+      throw new Error(`Agent session not found for branch: ${options.branch}`);
+    }
+    return session;
+  }
+
+  throw new Error('agents finish requires --session <id> or --branch <agent/...>');
+}
+
+function sessionStatusAfterFinish(finishArgs) {
+  const modeIndex = finishArgs.indexOf('--mode');
+  const directMode = finishArgs.includes('--direct-only') || finishArgs[modeIndex + 1] === 'direct';
+  return finishArgs.includes('--no-wait-for-merge') && !directMode ? 'pr-opened' : 'finished';
+}
+
+function cleanupResultAfterFinish(finishArgs, status) {
+  if (status === 'failed') return 'failed';
+  if (finishArgs.includes('--no-cleanup')) return 'skipped';
+  if (finishArgs.includes('--cleanup')) return status === 'finished' ? 'completed' : 'pending';
+  return 'unknown';
+}
+
+function firstMatch(text, patterns) {
+  for (const pattern of patterns) {
+    const match = text.match(pattern);
+    if (match && match[1]) return match[1].trim();
+  }
+  return '';
+}
+
+function finishOutputText(result, captured = {}) {
+  return [
+    captured.stdout,
+    captured.stderr,
+    result?.stdout,
+    result?.stderr,
+  ].map((value) => String(value || '')).join('\n');
+}
+
+function buildFinishEvidence(session, finishArgs, status, result, captured = {}) {
+  const outputText = finishOutputText(result, captured);
+  const prUrl = firstMatch(outputText, [
+    /\[agent-branch-finish\] (?:Merged PR|PR):\s+(https?:\/\/\S+)/,
+    /\b(https?:\/\/\S+\/pull\/\d+)\b/,
+  ]);
+  const mergeState = status === 'finished' ? 'MERGED' : status === 'pr-opened' ? 'OPEN' : status.toUpperCase();
+  return {
+    schemaVersion: 1,
+    sessionId: session.id || '',
+    branch: session.branch || '',
+    prUrl,
+    mergeState,
+    cleanupResult: cleanupResultAfterFinish(finishArgs, status),
+    status,
+  };
+}
+
+function captureProcessOutput(fn) {
+  let stdout = '';
+  let stderr = '';
+  const originalStdoutWrite = process.stdout.write;
+  const originalStderrWrite = process.stderr.write;
+  process.stdout.write = function captureStdout(chunk, encoding, callback) {
+    stdout += Buffer.isBuffer(chunk) ? chunk.toString(encoding || 'utf8') : String(chunk || '');
+    if (typeof encoding === 'function') encoding();
+    if (typeof callback === 'function') callback();
+    return true;
+  };
+  process.stderr.write = function captureStderr(chunk, encoding, callback) {
+    stderr += Buffer.isBuffer(chunk) ? chunk.toString(encoding || 'utf8') : String(chunk || '');
+    if (typeof encoding === 'function') encoding();
+    if (typeof callback === 'function') callback();
+    return true;
+  };
+  try {
+    return { result: fn(), captured: { stdout, stderr } };
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+  }
+}
+
+function finishAgentSession(repoRoot, options, deps = {}) {
+  const finishRunner = deps.finishRunner || finishCommands.finish;
+  const output = deps.output || process.stdout;
+  const session = resolveAgentSessionForFinish(repoRoot, options);
+  const jsonMode = Boolean(options.json);
+
+  if (!session.branch) {
+    throw new Error(`Agent session '${session.id}' has no branch metadata.`);
+  }
+
+  updateAgentSession(repoRoot, session.id, { status: 'finishing' });
+
+  const finishArgs = [
+    '--target',
+    repoRoot,
+    '--branch',
+    session.branch,
+    ...options.finishArgs,
+  ];
+
+  if (!jsonMode) {
+    output.write(`[${TOOL_NAME}] Agent session: ${session.id}\n`);
+    output.write(`[${TOOL_NAME}] Branch: ${session.branch}\n`);
+    output.write(`[${TOOL_NAME}] Worktree: ${session.worktreePath || '(unknown)'}\n`);
+  }
+
+  try {
+    const runnerResult = jsonMode
+      ? captureProcessOutput(() => finishRunner(finishArgs))
+      : { result: finishRunner(finishArgs), captured: {} };
+    const result = runnerResult.result;
+    const status = sessionStatusAfterFinish(finishArgs);
+    const evidence = buildFinishEvidence(session, finishArgs, status, result, runnerResult.captured);
+    updateAgentSession(repoRoot, session.id, {
+      status,
+      pr: { url: evidence.prUrl, state: evidence.mergeState },
+      finishEvidence: evidence,
+    });
+    if (!jsonMode) {
+      output.write(`[${TOOL_NAME}] Finish result: ${status}\n`);
+    }
+    return { session, status, result, finishArgs, evidence };
+  } catch (error) {
+    const evidence = buildFinishEvidence(session, finishArgs, 'failed', null);
+    updateAgentSession(repoRoot, session.id, {
+      status: 'failed',
+      finishEvidence: evidence,
+    });
+    if (!jsonMode) {
+      output.write(`[${TOOL_NAME}] Finish result: failed\n`);
+    }
+    throw error;
+  }
+}
+
+module.exports = {
+  buildFinishEvidence,
+  finishAgentSession,
+  resolveAgentSessionForFinish,
+};

package/src/agents/inspect.js

@@ -0,0 +1,189 @@
+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 worktreePathForBranch(repoRoot, branch) {
+  const result = git(repoRoot, ['worktree', 'list', '--porcelain'], { allowFailure: true });
+  if (result.status !== 0) return { worktreePath: repoRoot, worktreeFound: false };
+  const match = parseWorktreeList(result.stdout).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);
+  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,
+  parseWorktreeList,
+  readLockRegistry,
+  renderDiff,
+  renderFiles,
+  renderLocks,
+  resolveBaseBranch,
+  runInspectCommand,
+};

package/src/agents/launch.js

@@ -0,0 +1,240 @@
+'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 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 envPrefix = buildSessionEnv(agent, sessionId).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,
+};