reslop 0.2.7 → 0.3.1

package/lib/agents/agents.js

@@ -0,0 +1,573 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { jsonParse } = require('metautil');
+const { IS_WIN, runProc, spawnBase } = require('../common/process.js');
+const { trimText } = require('../common/utilities.js');
+const { commandEnv, PipeProcess } = require('../runs/process.js');
+const { ensurePlanAllows, PLAN_ALLOWS } = require('./allow.js');
+const models = require('./models.js');
+const { parseNameList, parseCursorModels, parseCursorWide } = models;
+const { parseJsonModels, catalogOf, emptyChoice, contextMenu } = models;
+const { parseJsonEfforts, parseHelpModels, optionValues } = models;
+
+const LIST_MS = 5000;
+const AUTH_NEED = /authentication required/i;
+const PERMISSION_FAIL =
+  /permissions?[ -]?(?:denied|denial)|denied permissions?/i;
+const GITDIR_PREFIX = 'gitdir:';
+
+const plainEffort = (level) => level;
+const codexEffort = (level) => `model_reasoning_effort=${level}`;
+
+const bashAllow = (entry) => {
+  if (!entry.startsWith('Shell(') || !entry.endsWith(')')) return '';
+  const bin = entry.slice('Shell('.length, -1).split(/\s+/)[0];
+  if (!bin) return '';
+  return `Bash(${bin} *)`;
+};
+
+const BASH_ALLOWS = [...new Set(PLAN_ALLOWS.map(bashAllow).filter(Boolean))];
+
+// A piped session has no approval host. Preapproved shells can still run tests.
+const CLAUDE_PREFIX = [
+  '--print',
+  '--permission-mode',
+  'acceptEdits',
+  '--permission-prompts',
+  'none',
+  '--allowedTools',
+  ...BASH_ALLOWS,
+];
+
+const defineAgent = (spec) => ({
+  id: spec.id,
+  name: spec.name ?? spec.id,
+  title: spec.title,
+  bins: spec.bins,
+  models: spec.models,
+  modelFlag: spec.modelFlag ?? '--model',
+  effortFlag: spec.effortFlag ?? '',
+  effortValue: spec.effortValue ?? plainEffort,
+  efforts: spec.efforts ?? [],
+  modelParams: spec.modelParams === true,
+  prefix: spec.prefix ?? [],
+  promptFlag: spec.promptFlag ?? '',
+  login: spec.login ?? [],
+  status: spec.status ?? [],
+  contexts: spec.contexts ?? [],
+  resumeWith: spec.resumeWith ?? null,
+  listCmds: spec.listCmds,
+  parseModels: spec.parseModels ?? parseNameList,
+  wideModels: spec.wideModels ?? null,
+  partialList: spec.partialList === true,
+  modelEfforts: spec.modelEfforts ?? null,
+  effortCmds: spec.effortCmds ?? [],
+  allowlist: spec.allowlist === true,
+  denied: spec.denied ?? null,
+  savesExtra: spec.savesExtra === true,
+});
+
+const AGENTS = [
+  defineAgent({
+    id: 'claude',
+    title: 'Claude Code',
+    bins: ['claude'],
+    models: ['default', 'sonnet', 'opus', 'haiku', 'fable'],
+    effortFlag: '--effort',
+    efforts: ['default', 'low', 'medium', 'high', 'max'],
+    prefix: CLAUDE_PREFIX,
+    resumeWith: (id) => ['--resume', id],
+    // No command lists models: the help names the aliases and the efforts
+    listCmds: [['--help']],
+    parseModels: parseHelpModels,
+    partialList: true,
+    effortCmds: [['--help']],
+  }),
+  defineAgent({
+    id: 'opencode',
+    title: 'OpenCode',
+    bins: ['opencode'],
+    models: ['default', 'sonnet', 'opus', 'gpt-5'],
+    resumeWith: (id) => ['--session', id],
+    listCmds: [['models']],
+  }),
+  defineAgent({
+    id: 'cursor',
+    title: 'Cursor',
+    bins: ['cursor-agent', 'agent'],
+    models: ['default', 'auto', 'grok-4.6', 'composer-2', 'gpt-5', 'sonnet'],
+    modelParams: true,
+    efforts: ['default', 'low', 'medium', 'high', 'xhigh'],
+    prefix: ['--print', '--trust'],
+    allowlist: true,
+    login: ['login'],
+    status: ['status', '--format', 'json'],
+    contexts: ['256k', '1m'],
+    resumeWith: (id) => [`--resume=${id}`],
+    listCmds: [['--list-models'], ['models']],
+    parseModels: parseCursorModels,
+    wideModels: parseCursorWide,
+  }),
+  defineAgent({
+    id: 'codex',
+    title: 'Codex',
+    bins: ['codex'],
+    models: ['default', 'gpt-5.1-codex', 'gpt-5', 'o3'],
+    effortFlag: '-c',
+    effortValue: codexEffort,
+    efforts: ['default', 'low', 'medium', 'high', 'xhigh'],
+    // The TUI rejects a closed stdin; exec is the non-interactive entry
+    prefix: ['exec'],
+    resumeWith: (id) => ['resume', id],
+    listCmds: [
+      ['debug', 'models', '--bundled'],
+      ['debug', 'models'],
+      ['models'],
+    ],
+    parseModels: parseJsonModels,
+    modelEfforts: parseJsonEfforts,
+  }),
+  defineAgent({
+    id: 'agy',
+    title: 'Antigravity',
+    bins: ['agy'],
+    models: [
+      'default',
+      'gemini-3.8-flash-high',
+      'gemini-3.8-flash-medium',
+      'gemini-3.8-flash-low',
+      'gemini-3.7-flash-high',
+      'gemini-3.7-flash-medium',
+      'gemini-3.7-flash-low',
+      'gemini-3.6-flash-high',
+      'gemini-3.6-flash-medium',
+      'gemini-3.6-flash-low',
+      'gemini-3.1-pro-high',
+      'gemini-3.1-pro-low',
+      'claude-sonnet-4-6',
+      'claude-opus-4-6-thinking',
+      'gpt-oss-120b-medium',
+    ],
+    effortFlag: '--effort',
+    efforts: ['default', 'low', 'medium', 'high'],
+    promptFlag: '-p',
+    // Exits 0 after a refused tool call, so the output tells the outcome
+    denied: PERMISSION_FAIL,
+    // Extra flags in .reslop are the opt-in to run without confirmations
+    savesExtra: true,
+    resumeWith: (id) => ['--conversation', id],
+    listCmds: [['models']],
+    effortCmds: [['--help']],
+  }),
+];
+
+const agentSpec = (id) => AGENTS.find((spec) => spec.id === id) ?? null;
+
+const pathDirs = (env) => {
+  const raw = env.PATH ?? env.Path ?? '';
+  return raw.split(path.delimiter).filter(Boolean);
+};
+
+const winNames = (name, env) => {
+  const ext = env.PATHEXT || '.EXE;.CMD;.BAT;.COM';
+  const upper = name.toUpperCase();
+  const names = [name];
+  for (const item of ext.split(';').filter(Boolean)) {
+    const suffix = item.startsWith('.') ? item : `.${item}`;
+    if (upper.endsWith(suffix.toUpperCase())) return [name];
+    names.push(`${name}${suffix}`);
+  }
+  return names;
+};
+
+const binNames = (name, env) => (IS_WIN ? winNames(name, env) : [name]);
+
+const isBin = (file) => {
+  try {
+    if (!fs.statSync(file).isFile()) return false;
+    if (!IS_WIN) fs.accessSync(file, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const findBin = (name, env = process.env) => {
+  for (const dir of pathDirs(env)) {
+    for (const file of binNames(name, env)) {
+      const full = path.join(dir, file);
+      if (isBin(full)) return full;
+    }
+  }
+  return '';
+};
+
+const findAgentBin = (spec, env) => {
+  for (const name of spec.bins) {
+    const found = findBin(name, env);
+    if (found) return found;
+  }
+  return '';
+};
+
+const detectAgents = (env = process.env) =>
+  AGENTS.map((spec) => ({
+    id: spec.id,
+    name: spec.name,
+    spec,
+    models: spec.models.slice(),
+    wide: null,
+    listedEfforts: null,
+    modelEfforts: null,
+    bin: findAgentBin(spec, env),
+  }));
+
+const canLogin = (row) =>
+  Boolean(row && row.bin && row.spec && row.spec.login.length);
+
+const tryList = async (run, bin, args, options) => {
+  try {
+    return await run(bin, args, options);
+  } catch {
+    return null;
+  }
+};
+
+const listedOf = (listed) => {
+  const bare = Array.isArray(listed);
+  const given = bare ? { names: listed, wide: listed.wide } : listed;
+  const from = given && typeof given === 'object' ? given : {};
+  const efforts = Array.isArray(from.efforts) ? from.efforts : [];
+  const perModel = from.modelEfforts instanceof Map ? from.modelEfforts : null;
+  return {
+    names: Array.isArray(from.names) ? from.names : [],
+    wide: Array.isArray(from.wide) ? from.wide : null,
+    efforts: efforts.length ? efforts : null,
+    modelEfforts: perModel && perModel.size ? perModel : null,
+  };
+};
+
+// One answer per command line, so a command that serves two lists runs once
+class CliProbe {
+  constructor(bin, options) {
+    this.bin = bin;
+    this.run = options.run ?? runProc;
+    this.env = { ...process.env, ...options.env };
+    this.timeout = options.timeout ?? LIST_MS;
+    this.texts = new Map();
+  }
+
+  async read(args) {
+    const key = args.join(' ');
+    if (this.texts.has(key)) return this.texts.get(key);
+    const { env, timeout } = this;
+    const result = await tryList(this.run, this.bin, args, { env, timeout });
+    const { stdout = '', stderr = '' } = result ?? {};
+    const text = result ? `${stdout}\n${stderr}` : '';
+    this.texts.set(key, text);
+    return text;
+  }
+
+  async first(cmds, parse) {
+    for (const args of cmds) {
+      const text = await this.read(args);
+      const found = text ? parse(text) : [];
+      if (found.length) return { text, found };
+    }
+    return null;
+  }
+}
+
+const listModels = async (bin, spec, options = {}) => {
+  const listed = { names: [], wide: null, efforts: null, modelEfforts: null };
+  if (!bin || !spec) return listed;
+  const probe = new CliProbe(bin, options);
+  const models = await probe.first(spec.listCmds, spec.parseModels);
+  if (models) {
+    const { text } = models;
+    listed.names = models.found;
+    listed.wide = spec.wideModels ? spec.wideModels(text) : null;
+    listed.modelEfforts = spec.modelEfforts ? spec.modelEfforts(text) : null;
+  }
+  const levels = (text) => optionValues(text, spec.effortFlag);
+  const efforts = await probe.first(spec.effortCmds, levels);
+  if (efforts) listed.efforts = efforts.found;
+  return listed;
+};
+
+const splitArgs = (text) => trimText(text).split(/\s+/).filter(Boolean);
+
+const quoteArg = (text) => {
+  const arg = `${text ?? ''}`;
+  if (!arg) return '""';
+  if (!/[\s"'\\]/.test(arg)) return arg;
+  return `"${arg.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+};
+
+const commandLine = (launch) => {
+  if (!launch || !launch.ok || !launch.cmd) return '';
+  const args = launch.args ?? [];
+  const hasPrompt = launch.prompt && args.at(-1) === launch.prompt;
+  const shown = hasPrompt ? args.slice(0, -1) : args;
+  const plan = launch.plan ? quoteArg(launch.plan) : '';
+  const bin = path.basename(launch.cmd);
+  return [bin, ...shown.map(quoteArg), plan].filter(Boolean).join(' ');
+};
+
+const planRef = (reviewPath, cwd) => {
+  const file = `${reviewPath ?? ''}`;
+  if (!file || !cwd) return file;
+  const rel = path.relative(cwd, file);
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return file;
+  return rel.split(path.sep).join('/');
+};
+
+const planPrompt = (reviewPath) =>
+  `Read and execute repair plan at ${reviewPath}`;
+
+const needsAuth = (text) => AUTH_NEED.test(`${text ?? ''}`);
+
+const parsedAuth = (raw) => {
+  const start = raw.indexOf('{');
+  const end = raw.lastIndexOf('}');
+  if (start < 0 || end <= start) return null;
+  const body = raw.slice(start, end + 1);
+  const data = jsonParse(body);
+  if (!data || typeof data !== 'object') return null;
+  if (typeof data.isAuthenticated === 'boolean') return data.isAuthenticated;
+  if (data.status === 'authenticated') return true;
+  if (data.status === 'unauthenticated') return false;
+  if (data.status === 'partially-authenticated') return false;
+  return null;
+};
+
+const authState = (text) => {
+  const raw = trimText(text);
+  if (!raw) return null;
+  const parsed = parsedAuth(raw);
+  if (parsed !== null) return parsed;
+  if (/not logged in/i.test(raw)) return false;
+  if (/logged in/i.test(raw)) return true;
+  return null;
+};
+
+const probeAuth = async (row) => {
+  const args = row && row.spec ? row.spec.status : [];
+  if (!row || !row.bin || !args.length) return null;
+  const result = await runProc(row.bin, args, {
+    env: commandEnv(),
+    timeout: LIST_MS,
+  });
+  if (!result || result.error) return null;
+  const text = `${result.stdout ?? ''}\n${result.stderr ?? ''}`;
+  return authState(text);
+};
+
+const effortArgs = (spec, effort) => {
+  const level = trimText(effort);
+  if (!spec.effortFlag || !level || level === 'default') return [];
+  return [spec.effortFlag, spec.effortValue(level)];
+};
+
+const statOf = (file) => {
+  try {
+    return fs.statSync(file);
+  } catch {
+    return null;
+  }
+};
+
+const readFirstLine = (file) => {
+  try {
+    return fs.readFileSync(file, 'utf8').split('\n')[0] ?? '';
+  } catch {
+    return '';
+  }
+};
+
+const realPath = (file) => {
+  try {
+    return fs.realpathSync.native(file);
+  } catch {
+    return path.resolve(file);
+  }
+};
+
+const gitDirOf = (dot) => {
+  const line = readFirstLine(dot).trim();
+  if (!line.startsWith(GITDIR_PREFIX)) return '';
+  const raw = line.slice(GITDIR_PREFIX.length).trim();
+  if (!raw) return '';
+  return path.resolve(path.dirname(dot), raw);
+};
+
+const commonGitDir = (gitDir) => {
+  const raw = readFirstLine(path.join(gitDir, 'commondir')).trim();
+  if (!raw) return gitDir;
+  return path.resolve(gitDir, raw);
+};
+
+// workspace-write remounts .git read-only unless that path is itself writable.
+const gitWriteRoots = (cwd) => {
+  if (!cwd) return [];
+  const dot = path.join(path.resolve(cwd), '.git');
+  const stat = statOf(dot);
+  if (!stat) return [];
+  if (stat.isDirectory()) return [realPath(dot)];
+  if (!stat.isFile()) return [];
+  const gitDir = gitDirOf(dot);
+  if (!gitDir) return [];
+  const roots = [realPath(gitDir), realPath(commonGitDir(gitDir))];
+  return [...new Set(roots)];
+};
+
+const tomlQuote = (text) => {
+  const escaped = text.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+  return `"${escaped}"`;
+};
+
+const codexGitArgs = (cwd) => {
+  const roots = gitWriteRoots(cwd);
+  if (!roots.length) return [];
+  const listed = roots.map(tomlQuote).join(',');
+  const value = `sandbox_workspace_write.writable_roots=[${listed}]`;
+  return ['--sandbox', 'workspace-write', '-c', value];
+};
+
+const paramPart = (key, value) => {
+  const text = trimText(value);
+  if (!text) return '';
+  return `${key}=${text}`;
+};
+
+const withParams = (model, parts) => {
+  const body = parts.filter(Boolean).join(',');
+  if (!body || !model || model === 'default') return model;
+  return `${model}[${body}]`;
+};
+
+const effortParam = (model, effort) => {
+  const level = trimText(effort);
+  if (!level || level === 'default') return '';
+  if (`${model ?? ''}`.endsWith(`-${level}`)) return '';
+  return level;
+};
+
+const fastParam = (model, fast) => {
+  if (fast !== true) return '';
+  if (`${model ?? ''}`.endsWith('-fast')) return '';
+  return 'true';
+};
+
+const modelArg = (spec, resolved, context, fast) => {
+  const parts = [paramPart('context', context)];
+  const brackets = spec.modelParams && !resolved.encoded;
+  if (!brackets || resolved.params === false) {
+    return withParams(resolved.model, parts);
+  }
+  const level = effortParam(resolved.model, resolved.effort);
+  parts.push(paramPart('effort', level));
+  parts.push(paramPart('fast', fastParam(resolved.model, fast)));
+  return withParams(resolved.model, parts);
+};
+
+const createLaunch = (row, kind, args, plan = '', prompt = '') => {
+  const launch = {
+    ok: true,
+    cmd: row.bin,
+    args,
+    prompt,
+    plan,
+    id: row.id,
+    name: row.name,
+    kind,
+    command: '',
+  };
+  launch.command = commandLine(launch);
+  return launch;
+};
+
+const resumeArgs = (spec, sessionId) => {
+  const id = `${sessionId ?? ''}`;
+  if (!id || !spec.resumeWith) return [];
+  return spec.resumeWith(id);
+};
+
+const buildLaunch = (row, choice, reviewPath, cwd, sessionId = '') => {
+  if (!row || !row.bin) return { ok: false, error: 'not installed' };
+  if (!reviewPath) return { ok: false, error: 'no plan' };
+  const { spec } = row;
+  const picked = choice ?? emptyChoice(row);
+  const catalog = catalogOf(row.models);
+  const resolved = catalog.withFast(catalog.resolve(picked), picked.fast);
+  const asked = trimText(picked.context);
+  const menu = contextMenu(resolved.model, row.wide, catalog, spec.contexts);
+  const pass = menu.includes(asked) && asked !== menu[0] ? asked : '';
+  const model = modelArg(spec, resolved, pass, picked.fast);
+  const plan = planRef(reviewPath, cwd) || reviewPath;
+  const prompt = planPrompt(plan);
+  const continued = resumeArgs(spec, sessionId);
+  const args = [...spec.prefix, ...continued];
+  if (model && model !== 'default') args.push(spec.modelFlag, model);
+  if (!spec.modelParams && !resolved.encoded) {
+    args.push(...effortArgs(spec, resolved.effort));
+  }
+  if (spec.id === 'codex') args.push(...codexGitArgs(cwd));
+  args.push(...splitArgs(picked.extra));
+  if (spec.promptFlag) args.push(spec.promptFlag);
+  args.push(prompt);
+  const launch = createLaunch(row, 'run', args, plan, prompt);
+  const id = `${sessionId ?? ''}`;
+  if (id) launch.session = id;
+  return launch;
+};
+
+const buildLogin = (row) => {
+  if (!row || !row.bin) return { ok: false, error: 'not installed' };
+  if (!canLogin(row)) return { ok: false, error: 'no login' };
+  return createLaunch(row, 'login', row.spec.login.slice());
+};
+
+// The review screen forces raw output. An agent needs the reduced test report.
+const agentEnv = () => {
+  const env = commandEnv();
+  delete env.RESLOP_OUTPUT;
+  return env;
+};
+
+const startPipe = (cwd, launch, onData, onClose) => {
+  const options = spawnBase({ cwd, env: agentEnv(), detached: !IS_WIN });
+  const proc = new PipeProcess(onData, onClose);
+  proc.start(launch.cmd, launch.args, options).closeInput();
+  return proc;
+};
+
+// An agent that reads an allow list gets the plan entries before it runs
+const startAgent = (cwd, launch, onData, onClose) => {
+  const spec = agentSpec(launch.id);
+  const listed = launch.kind === 'run' && spec && spec.allowlist;
+  if (listed) ensurePlanAllows();
+  return startPipe(cwd, launch, onData, onClose);
+};
+
+module.exports = {
+  ...models,
+  AGENTS,
+  agentSpec,
+  findBin,
+  detectAgents,
+  canLogin,
+  listedOf,
+  listModels,
+  splitArgs,
+  planPrompt,
+  needsAuth,
+  authState,
+  probeAuth,
+  commandLine,
+  buildLaunch,
+  buildLogin,
+  startAgent,
+};

package/lib/agents/allow.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { jsonParse, isHashObject } = require('metautil');
+const { writeJson, trimText } = require('../common/utilities.js');
+
+const { planAllows: PLAN_ALLOWS } = require('./allow.json');
+
+const cursorConfigPath = (env = process.env) => {
+  const override = trimText(env.RESLOP_CURSOR_CONFIG);
+  if (override) return override;
+  const root = trimText(env.CURSOR_CONFIG_DIR);
+  const dir = root || path.join(os.homedir(), '.cursor');
+  return path.join(dir, 'cli-config.json');
+};
+
+const readConfig = (file) => {
+  let text = null;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch (error) {
+    if (!error || error.code !== 'ENOENT') return null;
+  }
+  if (text === null) return {};
+  const data = jsonParse(text);
+  if (!isHashObject(data)) return null;
+  return data;
+};
+
+const allowList = (data) => {
+  if (!data.permissions || typeof data.permissions !== 'object') {
+    data.permissions = { allow: [], deny: [] };
+  }
+  if (!Array.isArray(data.permissions.allow)) data.permissions.allow = [];
+  if (!Array.isArray(data.permissions.deny)) data.permissions.deny = [];
+  return data.permissions.allow;
+};
+
+const ensureAllows = (file, entries) => {
+  const data = readConfig(file);
+  if (!data) return false;
+  const allow = allowList(data);
+  let changed = false;
+  for (const entry of entries) {
+    const token = trimText(entry);
+    if (!token || allow.includes(token)) continue;
+    allow.push(token);
+    changed = true;
+  }
+  if (!changed) return true;
+  if (!data.version) data.version = 1;
+  if (!data.approvalMode) data.approvalMode = 'allowlist';
+  try {
+    writeJson(file, data);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const ensurePlanAllows = (env = process.env) =>
+  ensureAllows(cursorConfigPath(env), PLAN_ALLOWS);
+
+module.exports = {
+  PLAN_ALLOWS,
+  cursorConfigPath,
+  ensureAllows,
+  ensurePlanAllows,
+};

package/lib/agents/allow.json

@@ -0,0 +1,17 @@
+{
+  "planAllows": [
+    "Write(.plan/**)",
+    "Write(.plan/**/*.md)",
+    "Write(**/.plan/**)",
+    "Write(**/.plan/**/*.md)",
+    "Shell(npm)",
+    "Shell(npm test)",
+    "Shell(npm t)",
+    "Shell(npx)",
+    "Shell(node)",
+    "Shell(node --test)",
+    "Shell(reslop)",
+    "Shell(reslop t)",
+    "Shell(git)"
+  ]
+}