@delegance/claude-autopilot 5.0.0 → 5.0.2

package/src/core/worker/client.ts

@@ -1,46 +0,0 @@
-import type { Finding } from '../findings/types.ts';
-import type { GuardrailConfig } from '../config/types.ts';
-import type { WorkerLock } from './lockfile.ts';
-
-export interface WorkerReviewRequest {
-  files: string[];
-  config: GuardrailConfig;
-}
-
-export interface WorkerReviewResponse {
-  findings: Finding[];
-  usage?: { costUSD: number };
-}
-
-export async function dispatchToWorker(
-  lock: WorkerLock,
-  req: WorkerReviewRequest,
-): Promise<WorkerReviewResponse> {
-  const url = `http://127.0.0.1:${lock.port}/review`;
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(req),
-    signal: AbortSignal.timeout(120_000),
-  });
-  if (!res.ok) throw new Error(`Worker returned ${res.status}: ${await res.text()}`);
-  return res.json() as Promise<WorkerReviewResponse>;
-}
-
-export async function getWorkerStatus(lock: WorkerLock): Promise<{
-  pid: number; port: number; jobsProcessed: number; queueDepth: number; uptimeMs: number;
-}> {
-  const url = `http://127.0.0.1:${lock.port}/status`;
-  const res = await fetch(url, { signal: AbortSignal.timeout(5_000) });
-  if (!res.ok) throw new Error(`Worker status returned ${res.status}`);
-  return res.json() as Promise<{ pid: number; port: number; jobsProcessed: number; queueDepth: number; uptimeMs: number }>;
-}
-
-export async function stopWorker(lock: WorkerLock): Promise<void> {
-  try {
-    await fetch(`http://127.0.0.1:${lock.port}/stop`, {
-      method: 'POST',
-      signal: AbortSignal.timeout(5_000),
-    });
-  } catch { /* worker may have already exited */ }
-}

package/src/core/worker/lockfile.ts

@@ -1,38 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-export interface WorkerLock {
-  pid: number;
-  port: number;
-  startedAt: string;
-}
-
-const LOCK_FILE = '.guardrail-cache/worker.lock';
-
-export function lockfilePath(cwd: string): string {
-  return path.join(cwd, LOCK_FILE);
-}
-
-export function readLock(cwd: string): WorkerLock | null {
-  const p = lockfilePath(cwd);
-  if (!fs.existsSync(p)) return null;
-  try { return JSON.parse(fs.readFileSync(p, 'utf8')) as WorkerLock; }
-  catch { return null; }
-}
-
-export function writeLock(cwd: string, lock: WorkerLock): void {
-  const dir = path.join(cwd, '.guardrail-cache');
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(lockfilePath(cwd), JSON.stringify(lock, null, 2), 'utf8');
-}
-
-export function deleteLock(cwd: string): void {
-  const p = lockfilePath(cwd);
-  if (fs.existsSync(p)) fs.unlinkSync(p);
-}
-
-/** Returns true if the PID in the lock is currently alive. */
-export function isWorkerAlive(lock: WorkerLock): boolean {
-  try { process.kill(lock.pid, 0); return true; }
-  catch { return false; }
-}

package/src/core/worker/server.ts

@@ -1,81 +0,0 @@
-import * as http from 'node:http';
-import * as net from 'node:net';
-import type { GuardrailConfig } from '../config/types.ts';
-import type { Finding } from '../findings/types.ts';
-
-export interface WorkerServerOptions {
-  cwd: string;
-  onReview: (files: string[], config: GuardrailConfig) => Promise<{ findings: Finding[]; usage?: { costUSD: number } }>;
-}
-
-export interface WorkerServer {
-  port: number;
-  close(): Promise<void>;
-}
-
-async function getRandomPort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const srv = net.createServer();
-    srv.listen(0, '127.0.0.1', () => {
-      const addr = srv.address() as net.AddressInfo;
-      srv.close(() => resolve(addr.port));
-    });
-    srv.on('error', reject);
-  });
-}
-
-export async function startWorkerServer(opts: WorkerServerOptions): Promise<WorkerServer> {
-  const port = await getRandomPort();
-  let jobsProcessed = 0;
-  const startedAt = Date.now();
-
-  const server = http.createServer(async (req, res) => {
-    if (req.method === 'GET' && req.url === '/status') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        pid: process.pid, port, jobsProcessed,
-        queueDepth: 0,
-        uptimeMs: Date.now() - startedAt,
-      }));
-      return;
-    }
-
-    if (req.method === 'POST' && req.url === '/stop') {
-      res.writeHead(200);
-      res.end('{"ok":true}');
-      setImmediate(() => server.close());
-      return;
-    }
-
-    if (req.method === 'POST' && req.url === '/review') {
-      let body = '';
-      req.on('data', (chunk: Buffer) => { body += chunk.toString(); });
-      req.on('end', async () => {
-        try {
-          const { files, config } = JSON.parse(body) as { files: string[]; config: GuardrailConfig };
-          const result = await opts.onReview(files, config);
-          jobsProcessed++;
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify(result));
-        } catch (err) {
-          res.writeHead(500, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: String(err) }));
-        }
-      });
-      return;
-    }
-
-    res.writeHead(404);
-    res.end('Not found');
-  });
-
-  await new Promise<void>((resolve, reject) => {
-    server.listen(port, '127.0.0.1', () => resolve());
-    server.on('error', reject);
-  });
-
-  return {
-    port,
-    close: () => new Promise<void>(resolve => server.close(() => resolve())),
-  };
-}

package/src/formatters/github-annotations.ts

@@ -1,36 +0,0 @@
-import type { Finding } from '../core/findings/types.ts';
-
-export function encodeAnnotationProperty(s: string): string {
-  return s
-    .replace(/%/g, '%25')
-    .replace(/\r/g, '%0D')
-    .replace(/\n/g, '%0A')
-    .replace(/:/g, '%3A')
-    .replace(/,/g, '%2C');
-}
-
-export function encodeAnnotationData(s: string): string {
-  return s
-    .replace(/%/g, '%25')
-    .replace(/\r/g, '%0D')
-    .replace(/\n/g, '%0A');
-}
-
-function severityToCommand(s: Finding['severity']): 'error' | 'warning' | 'notice' {
-  if (s === 'critical') return 'error';
-  if (s === 'warning') return 'warning';
-  return 'notice';
-}
-
-export function emitAnnotations(findings: Finding[]): void {
-  if (process.env.GITHUB_ACTIONS !== 'true') return;
-  for (const f of findings) {
-    const cmd = severityToCommand(f.severity);
-    const props: string[] = [`file=${encodeAnnotationProperty(f.file)}`];
-    if (f.line !== undefined) {
-      props.push(`line=${f.line}`, `endLine=${f.line}`);
-    }
-    props.push(`title=${encodeAnnotationProperty(f.category)}`);
-    process.stdout.write(`::${cmd} ${props.join(',')}::${encodeAnnotationData(f.message)}\n`);
-  }
-}

package/src/formatters/junit.ts

@@ -1,52 +0,0 @@
-import type { RunResult } from '../core/pipeline/run.ts';
-
-function escapeXml(s: string): string {
-  return s
-    .replace(/&/g, '&')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&apos;');
-}
-
-export function toJUnit(result: RunResult, opts: { suiteName?: string } = {}): string {
-  const name = opts.suiteName ?? 'guardrail';
-  const findings = result.allFindings;
-  const failures = findings.filter(f => f.severity === 'critical').length;
-  const total = findings.length;
-  const time = (result.durationMs / 1000).toFixed(3);
-
-  const lines: string[] = [
-    '<?xml version="1.0" encoding="UTF-8"?>',
-    `<testsuites name="${escapeXml(name)}" tests="${total}" failures="${failures}" time="${time}">`,
-    `  <testsuite name="${escapeXml(name)}" tests="${total}" failures="${failures}" errors="0" time="${time}">`,
-  ];
-
-  if (findings.length === 0) {
-    lines.push(`    <testcase name="no findings" classname="${escapeXml(name)}" />`);
-  }
-
-  for (const f of findings) {
-    const loc = f.line ? `${f.file}:${f.line}` : f.file;
-    const testName = escapeXml(`[${f.severity.toUpperCase()}] ${f.category} — ${loc}`);
-    const classname = escapeXml(f.file.replace(/\//g, '.').replace(/\.[tj]sx?$/, ''));
-    const body = escapeXml(f.message + (f.suggestion ? `\n${f.suggestion}` : ''));
-
-    if (f.severity === 'critical') {
-      lines.push(
-        `    <testcase name="${testName}" classname="${classname}">`,
-        `      <failure type="${escapeXml(f.category)}" message="${escapeXml(f.message)}">${body}</failure>`,
-        `    </testcase>`,
-      );
-    } else {
-      lines.push(
-        `    <testcase name="${testName}" classname="${classname}">`,
-        `      <system-out>${body}</system-out>`,
-        `    </testcase>`,
-      );
-    }
-  }
-
-  lines.push('  </testsuite>', '</testsuites>');
-  return lines.join('\n');
-}

package/src/formatters/sarif.ts

@@ -1,103 +0,0 @@
-import * as path from 'node:path';
-import type { RunResult } from '../core/pipeline/run.ts';
-import type { Finding } from '../core/findings/types.ts';
-
-interface SarifLog {
-  $schema: string;
-  version: '2.1.0';
-  runs: SarifRun[];
-}
-interface SarifRun {
-  tool: { driver: SarifDriver };
-  results: SarifResult[];
-}
-interface SarifDriver {
-  name: string;
-  version: string;
-  informationUri: string;
-  rules: SarifRule[];
-}
-interface SarifRule {
-  id: string;
-  name: string;
-  shortDescription: { text: string };
-}
-interface SarifResult {
-  ruleId: string;
-  level: 'error' | 'warning' | 'note';
-  message: { text: string };
-  locations: SarifLocation[];
-  fixes?: Array<{ description: { text: string } }>;
-}
-interface SarifLocation {
-  physicalLocation: {
-    artifactLocation: { uri: string; uriBaseId: string };
-    region?: { startLine: number };
-  };
-}
-
-export type { SarifLog };
-
-export function normalizeSarifUri(file: string, cwd: string): string {
-  let rel = path.isAbsolute(file) ? path.relative(cwd, file) : file;
-  rel = rel.replace(/\\/g, '/');
-  if (rel.startsWith('./')) rel = rel.slice(2);
-  if (rel.startsWith('../')) rel = file.replace(/\\/g, '/');
-  return rel;
-}
-
-function severityToLevel(s: Finding['severity']): 'error' | 'warning' | 'note' {
-  if (s === 'critical') return 'error';
-  if (s === 'warning') return 'warning';
-  return 'note';
-}
-
-export function toSarif(
-  result: RunResult,
-  opts: { toolVersion: string; cwd?: string },
-): SarifLog {
-  const cwd = opts.cwd ?? process.cwd();
-
-  const rulesMap = new Map<string, SarifRule>();
-  for (const f of result.allFindings) {
-    if (!rulesMap.has(f.category)) {
-      rulesMap.set(f.category, {
-        id: f.category,
-        name: f.category,
-        shortDescription: { text: f.category },
-      });
-    }
-  }
-
-  const results: SarifResult[] = result.allFindings.map(f => {
-    const r: SarifResult = {
-      ruleId: f.category,
-      level: severityToLevel(f.severity),
-      message: { text: f.message },
-      locations: [{
-        physicalLocation: {
-          artifactLocation: { uri: normalizeSarifUri(f.file, cwd), uriBaseId: '%SRCROOT%' },
-          ...(f.line !== undefined ? { region: { startLine: f.line } } : {}),
-        },
-      }],
-    };
-    if (f.suggestion) r.fixes = [{ description: { text: f.suggestion } }];
-    return r;
-  });
-
-  return {
-    $schema: 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json',
-    version: '2.1.0',
-    runs: [{
-      tool: {
-        driver: {
-          name: 'guardrail',
-          version: opts.toolVersion,
-          informationUri: 'https://github.com/axledbetter/guardrail',
-          rules: [...rulesMap.values()],
-        },
-      },
-      results,
-    }],
-  };
-}