@bigknoxy/hashpilot 4.6.3

package/src/core/batch-edit.ts

@@ -0,0 +1,185 @@
+import { routeEdit, RouterResult } from "./router";
+import { recordEvent, ErrorCode } from "./telemetry";
+import type { RoutePolicy, EditRoute } from "./config";
+import { acquireSortedLocks, LOCK_TIMEOUT_MS } from "./locking";
+
+export interface BatchParams {
+  files: string[];
+  operation: string;
+  method?: EditRoute;
+  policy?: RoutePolicy;
+  // Hash params
+  oldHash?: string;
+  newContent?: string;
+  range?: { start: number; end: number };
+  // AST params
+  oldName?: string;
+  newName?: string;
+  symbolName?: string;
+  newBody?: string;
+  importSpec?: string;
+  content?: string;
+  // Diff params
+  oldContent?: string;
+  dryRun?: boolean;
+  /** Dry runs return a diff; set this to get the whole post-edit file back (#98). */
+  includeSource?: boolean;
+  // Provenance params
+  actor?: string;
+  taskId?: string;
+  reason?: string;
+}
+
+export interface BatchSummary {
+  total: number;
+  succeeded: number;
+  failed: number;
+  conflicts: number;   // CAS/STALE_ANCHOR failures (distinct from other errors)
+  elapsed_ms: number;
+}
+
+export interface BatchResult {
+  results: RouterResult[];
+  summary: BatchSummary;
+}
+
+async function editOne(
+  file: string,
+  params: BatchParams,
+  /** `editMany` holds every target's lock already; `editManySerial` does not. */
+  alreadyLocked = false,
+): Promise<RouterResult> {
+  return routeEdit({
+    filePath: file,
+    alreadyLocked,
+    operation: params.operation,
+    method: params.method,
+    policy: params.policy,
+    oldHash: params.oldHash,
+    newContent: params.newContent,
+    range: params.range,
+    oldName: params.oldName,
+    newName: params.newName,
+    symbolName: params.symbolName,
+    newBody: params.newBody,
+    importSpec: params.importSpec,
+    content: params.content,
+    oldContent: params.oldContent,
+    dryRun: params.dryRun,
+    includeSource: params.includeSource,
+    actor: params.actor,
+    taskId: params.taskId,
+    reason: params.reason,
+  });
+}
+export type BatchEditOptions = { timeoutMs?: number };
+
+export async function editMany(params: BatchParams, opts?: BatchEditOptions): Promise<BatchResult> {
+  const start = Date.now();
+  const uniqueFiles = [...new Set(params.files)];
+
+  // Acquire advisory locks in sorted path order (deterministic lock ordering)
+  // to prevent deadlock when two plans touch overlapping file sets ({A,B} vs {B,A}).
+  let releaseLocks: (() => void) | undefined;
+
+  try {
+    releaseLocks = await acquireSortedLocks(uniqueFiles, {
+      timeoutMs: opts?.timeoutMs ?? LOCK_TIMEOUT_MS,
+    });
+  } catch (err: any) {
+    // Lock acquisition failed — report per-file LOCK_TIMEOUT instead of aborting.
+    const lockFailed: RouterResult[] = uniqueFiles.map((f) => ({
+      route: null as any,
+      routeReason: "lock timeout",
+      result: {
+        success: false,
+        // A lock timeout is retryable, exactly like a stale anchor. Tag it the
+        // same way so callers that branch on `stale` retry instead of giving up.
+        stale: true,
+        errorCode: ErrorCode.LOCK_TIMEOUT,
+        message: `Cannot acquire lock for ${f}: ${err.message}`,
+        recovery: "Retry; the file may be locked by another HashPilot process.",
+      },
+      elapsed_ms: Date.now() - start,
+    }));
+
+    recordEvent({
+      operation: `batch-${params.operation}`,
+      route: "batch",
+      files_count: uniqueFiles.length,
+      success: false,
+      elapsed_ms: Date.now() - start,
+    });
+
+    return {
+      results: lockFailed,
+      // A lock timeout is a conflict, not a hard failure — the same classification
+      // the per-file path below gives a router-reported LOCK_TIMEOUT. Counting it
+      // as `failed` here made the same condition land in two different buckets
+      // depending on whether the lock was taken up front or mid-batch.
+      summary: { total: uniqueFiles.length, succeeded: 0, failed: 0, conflicts: uniqueFiles.length, elapsed_ms: Date.now() - start },
+    };
+  }
+
+  try {
+    const results = await Promise.all(
+      uniqueFiles.map((f) => editOne(f, params, true))
+    );
+
+    // Distinguish CAS/STALE_ANCHOR conflicts from other per-file failures.
+    const succeeded = results.filter((r) => r.result.success).length;
+    const conflicts = results.filter(
+      (r) => !r.result.success && (
+        r.result.errorCode === ErrorCode.STALE_ANCHOR ||
+        r.result.stale === true
+      ),
+    ).length;
+    const failed = results.length - succeeded - conflicts;
+
+    recordEvent({
+      operation: `batch-${params.operation}`,
+      route: "batch",
+      files_count: uniqueFiles.length,
+      success: failed === 0 && conflicts === 0,
+      elapsed_ms: Date.now() - start,
+    });
+
+    return {
+      results,
+      summary: { total: uniqueFiles.length, succeeded, failed, conflicts, elapsed_ms: Date.now() - start },
+    };
+  } finally {
+    releaseLocks();
+  }
+}
+export async function editManySerial(params: BatchParams): Promise<BatchResult> {
+  const start = Date.now();
+
+  const results: RouterResult[] = [];
+  for (const f of params.files) {
+    results.push(await editOne(f, params));
+  }
+
+  const elapsed = Date.now() - start;
+  const succeeded = results.filter((r) => r.result.success).length;
+  const conflicts = results.filter(
+    (r) => !r.result.success && (
+      r.result.errorCode === ErrorCode.STALE_ANCHOR ||
+      r.result.stale === true
+    ),
+  ).length;
+  const failed = results.length - succeeded - conflicts;
+
+  recordEvent({
+    operation: `batch-${params.operation}-serial`,
+    route: "batch",
+    files_count: params.files.length,
+    success: failed === 0 && conflicts === 0,
+    elapsed_ms: elapsed,
+  });
+
+  return {
+    results,
+    summary: { total: params.files.length, succeeded, failed, conflicts, elapsed_ms: elapsed },
+  };
+}

package/src/core/config.ts

@@ -0,0 +1,189 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import type { EditRoute } from "./router";
+
+export interface RoutePolicy {
+  /**
+   * Force a specific route for given languages. E.g. { "python": "hash" }.
+   * `null` means "unset": it removes an override inherited from a
+   * lower-priority config, which a merge alone cannot express (#51).
+   */
+  languageOverrides?: Record<string, EditRoute | null>;
+  /**
+   * Force a specific route for given operations. E.g. { "add-import": "diff" }.
+   * `null` unsets an inherited override — see `languageOverrides`.
+   */
+  operationOverrides?: Record<string, EditRoute | null>;
+  /** When multiple overrides match, which wins: "language" | "operation" | "strictest" */
+  conflictResolution?: "language" | "operation" | "strictest";
+}
+
+export interface TelemetryConfig {
+  enabled?: boolean;
+  maxFileSize?: number;
+  maxRotatedFiles?: number;
+  retentionDays?: number;
+  /**
+   * Cap on one serialized JSONL record, in bytes. Oversized payloads (a
+   * captured diff) are stored out-of-line by hash and referenced from the
+   * record, so the log stays a log rather than an object store (#20).
+   */
+  maxRecordBytes?: number;
+}
+
+export interface ProvenanceConfig {
+  /** Default actor identity when not provided at invocation */
+  defaultActor?: string;
+  /** Max length of stored context field (prevents log bloat), default 500 */
+  maxContextLength?: number;
+  /**
+   * Record a unified diff of every edit in the telemetry log. Off by default:
+   * a diff puts real source lines on disk in plaintext, which is a leak for
+   * private repos and anything holding credentials. Turn on deliberately.
+   */
+  captureDiffs?: boolean;
+}
+
+export interface SnapshotConfig {
+  /** Take a pre-edit snapshot of every written file so `undo` can restore it. Default true. */
+  enabled?: boolean;
+  /** Keep at most this many changeSets, default 200. */
+  maxChangeSets?: number;
+  /** Drop changeSets older than this many days, default 7. */
+  maxAgeDays?: number;
+}
+
+export interface HashPilotConfig {
+  routePolicy?: RoutePolicy;
+  telemetry?: TelemetryConfig;
+  provenance?: ProvenanceConfig;
+  snapshots?: SnapshotConfig;
+  /** Extra directories writes may target, beyond the project root. Relative entries resolve against cwd. */
+  allowedRoots?: string[];
+}
+
+const DEFAULT_CONFIG: HashPilotConfig = Object.freeze({
+  telemetry: Object.freeze({ enabled: true, maxFileSize: 10 * 1024 * 1024, maxRotatedFiles: 10, retentionDays: 30, maxRecordBytes: 4096 }),
+}) as HashPilotConfig;
+
+/**
+ * Every `loadConfig` call must hand back a config that shares no object with
+ * the defaults or with a previously returned config. A shallow spread left the
+ * nested `telemetry` object aliased, so one caller mutating its own config
+ * silently rewrote the defaults for the rest of the process — invisible in the
+ * CLI (one process, one call) but a cross-request leak in the MCP server and
+ * any library embedding (#51).
+ */
+function cloneDefaults(): HashPilotConfig {
+  return structuredClone({ ...DEFAULT_CONFIG }) as HashPilotConfig;
+}
+
+const ROUTE_PRECEDENCE: EditRoute[] = ["diff", "hash", "ast"];
+
+function resolveConflict(
+  fromLang: EditRoute | undefined,
+  fromOp: EditRoute | undefined,
+  method: "language" | "operation" | "strictest" = "operation"
+): EditRoute | undefined {
+  if (!fromLang && !fromOp) return undefined;
+  if (!fromOp) return fromLang;
+  if (!fromLang) return fromOp;
+  if (method === "language") return fromLang;
+  if (method === "operation") return fromOp;
+  // strictest: lowest precedence wins (diff < hash < ast)
+  return ROUTE_PRECEDENCE.indexOf(fromLang) <= ROUTE_PRECEDENCE.indexOf(fromOp)
+    ? fromLang
+    : fromOp;
+}
+
+export function policyForce(
+  policy: RoutePolicy | undefined,
+  language: string | null,
+  operation: string
+): EditRoute | undefined {
+  if (!policy) return undefined;
+  const fromLang = (language ? policy.languageOverrides?.[language] : undefined) ?? undefined;
+  const fromOp = policy.operationOverrides?.[operation] ?? undefined;
+  if (!fromLang && !fromOp) return undefined;
+  return resolveConflict(fromLang, fromOp, policy.conflictResolution);
+}
+
+export function loadConfig(configPath?: string): HashPilotConfig {
+  const paths: string[] = [];
+
+  // Global config
+  const globalDir = join(process.env.HOME || "/root", ".config", "hashpilot");
+  const globalPath = join(globalDir, "config.json");
+  if (existsSync(globalPath)) paths.push(globalPath);
+
+  // Project config (cwd)
+  const projectPath = join(process.cwd(), ".hashpilot.json");
+  if (existsSync(projectPath) && projectPath !== globalPath) paths.push(projectPath);
+
+  // CLI override
+  if (configPath && existsSync(configPath) && !paths.includes(configPath)) {
+    paths.push(configPath);
+  }
+
+  const config: HashPilotConfig = cloneDefaults();
+
+  for (const p of paths) {
+    try {
+      const data = JSON.parse(readFileSync(p, "utf-8"));
+      mergeConfig(config, data);
+    } catch {}
+  }
+
+  // Environment variable override
+  const envPolicy = process.env.HASHPILOT_ROUTE_POLICY;
+  if (envPolicy) {
+    try {
+      const parsed = JSON.parse(envPolicy);
+      mergeConfig(config, { routePolicy: parsed });
+    } catch {}
+  }
+
+  return config;
+}
+
+/**
+ * Merge one override map, treating an explicit `null` as "unset". Without it a
+ * higher-priority config can change or add an override but never remove one, so
+ * a global "always diff for Python" policy could not be opted out of per
+ * project (#51).
+ */
+function mergeOverrides(
+  base: Record<string, EditRoute | null> | undefined,
+  override: Record<string, EditRoute | null> | undefined
+): Record<string, EditRoute | null> {
+  const merged: Record<string, EditRoute | null> = { ...base };
+  for (const [key, value] of Object.entries(override ?? {})) {
+    if (value === null) delete merged[key];
+    else merged[key] = value;
+  }
+  return merged;
+}
+
+function mergeConfig(base: HashPilotConfig, override: Partial<HashPilotConfig>): void {
+  if (override.telemetry) {
+    base.telemetry = { ...base.telemetry, ...override.telemetry };
+  }
+  if (override.routePolicy) {
+    const basePolicy = base.routePolicy || {};
+    base.routePolicy = {
+      ...basePolicy,
+      conflictResolution: override.routePolicy.conflictResolution ?? basePolicy.conflictResolution,
+      languageOverrides: mergeOverrides(basePolicy.languageOverrides, override.routePolicy.languageOverrides),
+      operationOverrides: mergeOverrides(basePolicy.operationOverrides, override.routePolicy.operationOverrides),
+    };
+  }
+  if (override.provenance) {
+    base.provenance = { ...base.provenance, ...override.provenance };
+  }
+  if (override.snapshots) {
+    base.snapshots = { ...base.snapshots, ...override.snapshots };
+  }
+  if (override.allowedRoots) {
+    base.allowedRoots = [...(base.allowedRoots || []), ...override.allowedRoots];
+  }
+}