regent-code 3.0.0

package/mcp/shared.js

@@ -0,0 +1,428 @@
+import fs from 'fs';
+import path from 'path';
+
+// ── Dispatch safety limits ──
+export const MAX_DISPATCH_ITEMS = 10;
+export const MAX_STRING_LENGTH = 8000;
+export const MAX_ID_LENGTH = 200;
+export const MAX_DISPATCHES_PER_WINDOW = 20;
+export const DISPATCH_WINDOW_MS = 60000;
+
+// ── Typed recovery actions ──
+export const RecoveryAction = {
+  RETRY: 'retry',
+  ABORT: 'abort',
+  SKIP: 'skip',
+  ESCALATE: 'escalate',
+};
+
+export function classifyError(err) {
+  const msg = (err?.message || String(err)).toLowerCase();
+  if (msg.includes('timeout') || msg.includes('rate limit') || msg.includes('too many'))
+    return RecoveryAction.RETRY;
+  if (
+    msg.includes('not found') ||
+    msg.includes('missing') ||
+    msg.includes('invalid') ||
+    msg.includes('enoent')
+  )
+    return RecoveryAction.ABORT;
+  if (msg.includes('permission') || msg.includes('denied') || msg.includes('unauthorized'))
+    return RecoveryAction.ESCALATE;
+  return RecoveryAction.RETRY;
+}
+
+// ── Retry with exponential backoff ──
+export async function withRetry(fn, maxRetries = 2) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      const action = classifyError(err);
+      if (action === RecoveryAction.ABORT || action === RecoveryAction.SKIP) throw err;
+      if (attempt < maxRetries) {
+        const delay = Math.min(1000 * Math.pow(2, attempt), 4000);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+
+// ── Evidence tracking ──
+/** @param {string} absolutePath @returns {{ exists: boolean, size?: number, mtimeMs?: number }} */
+export function fileFingerprint(absolutePath) {
+  try {
+    const stat = fs.statSync(absolutePath);
+    return { exists: true, size: stat.size, mtimeMs: stat.mtimeMs };
+  } catch {
+    return { exists: false };
+  }
+}
+
+/**
+ * @param {string[]} files
+ * @param {string} directory
+ * @returns {Array<{ file: string, absolute: string, stat: { exists: boolean, size?: number, mtimeMs?: number } }>}
+ */
+function buildFingerprints(files, directory = '') {
+  return files.map((file) => {
+    const absolute = path.isAbsolute(file) ? file : path.resolve(directory || process.cwd(), file);
+    return { file, absolute, stat: fileFingerprint(absolute) };
+  });
+}
+
+/**
+ * Grade verification evidence by the current state of the files it points at.
+ * An entry is FRESH while every file it claimed still matches the fingerprint
+ * recorded when the evidence was captured; STALE when any of them changed.
+ *
+ * @param {any[]} entries
+ * @returns {{ total: number, fresh: number, stale: number, missing: number, stale_files: string[] }}
+ */
+export function evidenceFreshness(entries) {
+  const grades = [];
+  const staleFiles = [];
+  for (const entry of entries) {
+    if (entry.verified !== true) continue;
+    if (!Array.isArray(entry.fingerprints) || entry.fingerprints.length === 0) {
+      grades.push('missing');
+      continue;
+    }
+    let checkable = 0;
+    let stale = false;
+    for (const fp of entry.fingerprints) {
+      if (fp?.stat?.exists !== true) continue;
+      checkable++;
+      const current = fileFingerprint(fp.absolute);
+      if (!current.exists || current.size !== fp.stat.size || current.mtimeMs !== fp.stat.mtimeMs) {
+        stale = true;
+        staleFiles.push(fp.file);
+      }
+    }
+    if (checkable === 0) {
+      grades.push('missing');
+      continue;
+    }
+    grades.push(stale ? 'stale' : 'fresh');
+  }
+  return {
+    total: grades.length,
+    fresh: grades.filter((grade) => grade === 'fresh').length,
+    stale: grades.filter((grade) => grade === 'stale').length,
+    missing: grades.filter((grade) => grade === 'missing').length,
+    stale_files: [...new Set(staleFiles)],
+  };
+}
+
+export function recordEvidence(sessionId, files, directory = '') {
+  if (files.length > 0) {
+    evidenceLog.push({
+      sessionId,
+      files,
+      timestamp: Date.now(),
+      verified: false,
+      fingerprints: buildFingerprints(files, directory),
+    });
+  }
+}
+
+export function markEvidenceVerified(sessionId) {
+  for (const entry of evidenceLog) {
+    if (entry.sessionId === sessionId) entry.verified = true;
+  }
+  for (const [sid, data] of sessionFileChanges) {
+    if (sid === sessionId) data.verified = true;
+  }
+}
+
+export function evidenceForScope() {
+  return evidenceLog;
+}
+
+/** @param {string} text @returns {string} */
+export function redactSecrets(text) {
+  return String(text)
+    .replace(/\bauthorization\s*:\s*(?:bearer\s+)?[^\s,;}\]]+/gi, 'authorization: <REDACTED>')
+    .replace(
+      /((?:api[_-]?key|api key|secret|token|passwd|password|authorization|bearer)(?:\s+provided)?(?:\s*[:=]\s*|\s+(?:is|was|are|were)\s+))["']?[^"'\s,;}\]]+/gi,
+      '$1<REDACTED>',
+    )
+    .replace(/\beyJ[A-Za-z0-9_-]{10,}(?:\.[A-Za-z0-9_-]{10,}){2}\b/g, '<REDACTED>')
+    .replace(
+      /\b(?:sk-(?:ant|proj|live)-[A-Za-z0-9]{8,}|sk-[A-Za-z0-9]{16,}|sk_live_[A-Za-z0-9]{16,}|ghp_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{6,}|AKIA[0-9A-Z]{16})\b/g,
+      '<REDACTED>',
+    );
+}
+
+// ── Sensitive focus-path protection (shared with explore) ──
+const SENSITIVE_FOCUS_NAMES = new Set([
+  '.aws',
+  '.azure',
+  '.docker',
+  '.htpasswd',
+  '.kube',
+  '.netrc',
+  '.npmrc',
+  '.pypirc',
+  '.ssh',
+  '.yarnrc',
+  '.yarnrc.yml',
+  '.git-credentials',
+  'authorized_keys',
+  'cookies',
+  'cookies.json',
+  'known_hosts',
+  'login.json',
+  'auth.json',
+  'oauth.json',
+  'passwd',
+  'password',
+  'passwords',
+  'secrets.json',
+  'secret.json',
+  'session.json',
+  'shadow',
+  'token.json',
+  'cert',
+  'certs',
+  'certificates',
+  'key',
+  'keys',
+  'private',
+  'private-keys',
+]);
+
+const SENSITIVE_FOCUS_MATERIAL =
+  /(?:^|[._-])(?:certificate|cert|certificates|certs|key|keys|private(?:[._-]?key)?|service[-_]?account|firebase[-_]?adminsdk)(?:$|[._-])/i;
+const SENSITIVE_FOCUS_CREDENTIAL =
+  /(?:^|[._-])(?:auth|authorization|cookie|cookies|credential|credentials|oauth|pass(?:word|wd)s?|secret|secrets|session|sessions|token|tokens)(?:$|[._-])/i;
+const SENSITIVE_FOCUS_KEY = /^id_(?:rsa|dsa|ecdsa|ed25519)(?:$|[._-])/i;
+const SENSITIVE_FOCUS_EXTENSION =
+  /\.(?:asc|cer|crt|csr|der|gpg|jks|keystore|key|p12|p8|pem|pgp|pfx|ppk)$/i;
+
+export function isSensitiveFocusPath(focusPath, worktreeRoot) {
+  const relative = path.relative(worktreeRoot, focusPath);
+  const segments = relative
+    .split(path.sep)
+    .filter(Boolean)
+    .map((segment) => segment.toLowerCase());
+  const name = segments.at(-1) || '';
+  const parentSegments = segments.slice(0, -1);
+
+  if (
+    parentSegments.some(
+      (segment) =>
+        segment === '.git' ||
+        SENSITIVE_FOCUS_NAMES.has(segment) ||
+        SENSITIVE_FOCUS_CREDENTIAL.test(segment) ||
+        SENSITIVE_FOCUS_MATERIAL.test(segment),
+    )
+  ) {
+    return true;
+  }
+  if (name === '.env' || name.startsWith('.env.')) return true;
+  if (name === '.git' || SENSITIVE_FOCUS_NAMES.has(name)) return true;
+  if (SENSITIVE_FOCUS_CREDENTIAL.test(name) && !/\.(?:log|md|txt)$/i.test(name)) return true;
+  return (
+    SENSITIVE_FOCUS_MATERIAL.test(name) ||
+    SENSITIVE_FOCUS_KEY.test(name) ||
+    SENSITIVE_FOCUS_EXTENSION.test(name)
+  );
+}
+
+// ── Subagent text-response parsing ──
+/**
+ * @param {string} text
+ * @returns {{ status: string, concerns: string[], filesChanged: string[] }}
+ */
+export function parseSubagentTextResponse(text) {
+  let status = 'done';
+  let concerns = [];
+
+  if (text.includes('BLOCKED')) {
+    status = 'blocked';
+  } else if (text.includes('NEEDS_CONTEXT')) {
+    status = 'needs_context';
+  } else if (text.includes('CONCERN:')) {
+    status = 'done_with_concerns';
+    concerns = text.match(/CONCERN:.*$/gm)?.map((c) => c.replace('CONCERN:', '').trim()) || [];
+  }
+
+  const pathPattern =
+    /(?:^|\n)(?:[\w./\\-]+\.[a-zA-Z0-9]+|[\w.-]+(?:[\\/][\w.-]+)+(?:\.[a-zA-Z0-9]+)?|^[A-Za-z][\w-]+\.[\w-]+|^[A-Za-z][\w-]+(?:\.[\w-]+)*$(?!\.))/gm;
+  const matches = text.match(pathPattern);
+  const filesChanged = (matches || [])
+    .map((f) => f.trim())
+    .filter(
+      (f) =>
+        !f.startsWith('CONCERN:') &&
+        !f.startsWith('NEEDS_CONTEXT') &&
+        !f.startsWith('BLOCKED') &&
+        !/^\d+\.\s/.test(f),
+    )
+    .slice(0, 20);
+
+  return { status, concerns, filesChanged };
+}
+
+export function unwrapData(result) {
+  return result?.data ?? result;
+}
+
+// ── State (single MCP process scope; no session lineage) ──
+/** @type {Map<string, { taskId?: string, files: string[], timestamp: number, verified: boolean }>} */
+export const sessionFileChanges = new Map();
+/** @type {any[]} */
+export const evidenceLog = [];
+/** @type {Map<string, number[]>} */
+const dispatchTimesByKey = new Map();
+/** @type {Map<string, { failures: number, recoveryReady?: boolean, halfOpen?: boolean }>} */
+const circuitStateByKey = new Map();
+/** @type {Set<string>} */
+export const workerSessionIds = new Set();
+
+export function dispatchRateLimit(key) {
+  const now = Date.now();
+  const times = dispatchTimesByKey.get(key) || [];
+  while (times.length > 0 && times[0] < now - DISPATCH_WINDOW_MS) times.shift();
+  if (times.length >= MAX_DISPATCHES_PER_WINDOW) return false;
+  times.push(now);
+  dispatchTimesByKey.set(key, times);
+  return true;
+}
+
+export function circuitIsOpen(key) {
+  const state = circuitStateByKey.get(key);
+  if (!state || (state.failures || 0) < 2) return false;
+
+  // Block once when open, then permit one half-open recovery attempt.
+  if (state.recoveryReady) {
+    circuitStateByKey.set(key, { failures: state.failures, recoveryReady: false, halfOpen: true });
+    return false;
+  }
+
+  circuitStateByKey.set(key, { failures: state.failures, recoveryReady: true });
+  return true;
+}
+
+export function recordCircuitResult(key, success) {
+  if (success) {
+    circuitStateByKey.delete(key);
+    return;
+  }
+
+  const current = circuitStateByKey.get(key) || { failures: 0 };
+  circuitStateByKey.set(key, { failures: current.failures + 1 });
+}
+
+export function resetState() {
+  evidenceLog.length = 0;
+  sessionFileChanges.clear();
+  dispatchTimesByKey.clear();
+  circuitStateByKey.clear();
+  workerSessionIds.clear();
+}
+
+// ── MCP content helpers ──
+/** @param {unknown} payload @returns {{ content: Array<{ type: 'text', text: string }> }} */
+export const toContent = (payload) => ({
+  content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+});
+
+/** @param {string} message @returns {{ status: string, output: string, concerns: string[], files_changed: string[] }} */
+export function structuredBlockedResult(message) {
+  return {
+    status: 'blocked',
+    output: `Subagent error: ${message}`,
+    concerns: [],
+    files_changed: [],
+  };
+}
+
+// ── Tool input schemas (identical to the plugin's) ──
+export const TOOL_INPUTS = {
+  delegate: {
+    type: 'object',
+    properties: {
+      task: { type: 'string', description: 'The specific task for the subagent to complete' },
+      context: { type: 'string', description: 'Background context for the task' },
+      expected_output: { type: 'string', description: 'What done looks like for the task' },
+      agent: { type: 'string', description: 'Optional child-capable agent ID override' },
+    },
+    required: ['task', 'context', 'expected_output'],
+    additionalProperties: false,
+  },
+  delegate_many: {
+    type: 'object',
+    properties: {
+      tasks: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', description: 'Unique identifier for this task' },
+            task: { type: 'string', description: 'What this subagent should do' },
+            context: { type: 'string', description: 'Background context for this task' },
+            expected_output: { type: 'string', description: 'What done looks like for this task' },
+            agent: { type: 'string', description: 'Optional child-capable agent ID override' },
+          },
+          required: ['id', 'task', 'context', 'expected_output'],
+          additionalProperties: false,
+        },
+      },
+    },
+    required: ['tasks'],
+    additionalProperties: false,
+  },
+  research: {
+    type: 'object',
+    properties: {
+      questions: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', description: 'Unique identifier' },
+            question: { type: 'string', description: 'The question to research' },
+            scope: { type: 'string', description: 'Optional narrowing scope' },
+            agent: { type: 'string', description: 'Optional child-capable agent ID override' },
+          },
+          required: ['id', 'question'],
+          additionalProperties: false,
+        },
+      },
+    },
+    required: ['questions'],
+    additionalProperties: false,
+  },
+  explore: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'What to understand in the codebase' },
+      focus: { type: 'string', description: 'Optional directory path, file pattern, or topic' },
+    },
+    required: ['query'],
+    additionalProperties: false,
+  },
+  'changed-files': {
+    type: 'object',
+    properties: {
+      session_id: { type: 'string', description: 'Optional session ID filter' },
+      task_id: { type: 'string', description: 'Optional task ID filter' },
+    },
+    additionalProperties: false,
+  },
+  verify: {
+    type: 'object',
+    properties: {
+      requirements: { type: 'string', description: 'The requirements text' },
+      implementation_context: { type: 'string', description: 'What was built' },
+      session_id: { type: 'string', description: 'Optional session ID to verify' },
+    },
+    required: ['requirements', 'implementation_context'],
+    additionalProperties: false,
+  },
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "regent-code",
+  "version": "3.0.0",
+  "description": "Agent orchestration for OpenCode. From idea to shipped — zero ceremony. Plugin + MCP server.",
+  "type": "module",
+  "main": ".opencode/plugins/regent.js",
+  "exports": {
+    ".": "./.opencode/plugins/regent.js",
+    "./mcp": "./mcp/index.js"
+  },
+  "bin": {
+    "regent-code": "mcp/cli.js"
+  },
+  "license": "MIT",
+  "author": "nathwn12",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@opencode-ai/client": "0.0.0-beta-18314",
+    "@opencode-ai/plugin": "0.0.0-beta-18314",
+    "jsonc-parser": "3.3.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nathwn12/regent-code.git"
+  },
+  "scripts": {
+    "mcp": "node mcp/index.js",
+    "lint": "eslint .opencode/plugins/ mcp/ --max-warnings 0",
+    "lint:fix": "eslint .opencode/plugins/regent.js skills/ mcp/ --fix",
+    "format": "prettier --write .opencode/plugins/ skills/ mcp/ --no-error-on-unmatched-pattern",
+    "format:check": "prettier --check .opencode/plugins/ skills/ mcp/ --no-error-on-unmatched-pattern",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test .opencode/tests/regent.test.js .opencode/tests/regent.live-test.js .opencode/tests/regent.v2.test.js .opencode/tests/regent.hybrid.v2.6.1.test.js .opencode/tests/regent.runtime.v2.6.1.test.js mcp/tests/mcp.test.js",
+    "verify": "npm run format:check && npm run lint && npm run typecheck && npm test"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.9.3",
+    "eslint": "^10.4.1",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.6.0",
+    "prettier": "^3.8.4",
+    "typescript": "^5.8.0"
+  },
+  "overrides": {
+    "eslint": {
+      "minimatch": {
+        "brace-expansion": "5.0.9"
+      }
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "checkJs": true,
+    "allowJs": true,
+    "strict": true,
+    "noImplicitAny": false,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": [".opencode/plugins/regent.js", "mcp/**/*.js"],
+  "exclude": ["*.test.js"]
+}