forgeos 0.1.0-alpha.7 → 0.1.0-alpha.71

package/src/forge/agent-memory/types.ts

@@ -0,0 +1,215 @@
+import type { Diagnostic } from "../compiler/types/diagnostic.ts";
+
+export const AGENT_EVENT_SCHEMA = "forge.agent-event.v1" as const;
+
+export type AgentMemorySourceName = "claude-code" | "codex" | "cursor" | "generic";
+export type AgentMemoryIntegrationKind = "native-hook" | "mcp" | "cli-wrapper" | "file-watcher" | "git-hook" | "manual-import";
+export type AgentMemoryTrustLevel =
+  | "direct-hook"
+  | "mcp-tool"
+  | "forge-command"
+  | "file-watcher"
+  | "git-observer"
+  | "manual-import"
+  | "inferred";
+
+export interface AgentEventEnvelope {
+  schema: typeof AGENT_EVENT_SCHEMA;
+  source: {
+    agent: AgentMemorySourceName | string;
+    integration: AgentMemoryIntegrationKind | string;
+    version: string;
+  };
+  workspace: {
+    root: string;
+    gitBranch?: string;
+    gitHead?: string;
+  };
+  session: {
+    externalSessionId?: string;
+    forgeSessionId?: string;
+    turnId?: string;
+  };
+  event: {
+    kind: string;
+    timestamp: string;
+  };
+  actor: {
+    kind: "agent" | "human" | "forge" | "unknown";
+    name: string;
+    model?: string;
+  };
+  payload: Record<string, unknown>;
+  privacy: {
+    rawPromptStored: false;
+    rawCompletionStored: false;
+    rawToolArgsStored: false;
+    transcriptImported: false;
+    redacted: true;
+    sensitiveFieldsRemoved: string[];
+  };
+  capture: {
+    trustLevel: AgentMemoryTrustLevel;
+    confidence: number;
+  };
+}
+
+export interface AgentMemoryEventRecord {
+  id: string;
+  externalEventId: string;
+  sourceName: string;
+  integrationKind: string;
+  trustLevel: string;
+  externalSessionId?: string;
+  externalTurnId?: string;
+  eventKind: string;
+  normalizedKind: string;
+  summary?: string;
+  confidence: number;
+  capturedAt: string;
+  operationId?: string;
+  data: Record<string, unknown>;
+}
+
+export interface AgentMemoryContextEvent {
+  id: string;
+  source: string;
+  integration: string;
+  trustLevel: string;
+  kind: string;
+  capturedAt: string;
+  summary?: string;
+  sessionId?: string;
+  turnId?: string;
+  tool?: string;
+  command?: string;
+  status?: string;
+  files: string[];
+  entries: string[];
+  proofs: string[];
+  confidence: number;
+}
+
+export interface AgentMemoryContextPack {
+  ok: true;
+  freshness?: AgentMemoryFreshness;
+  scope: "current" | "entry" | "change" | "proof" | "handoff";
+  scopeTarget: {
+    kind: "current-session" | "entry" | "change" | "proof" | "handoff";
+    value?: string;
+    semanticTarget?: string;
+    currentSessionId?: string;
+  };
+  entry?: string;
+  change?: string;
+  proof?: string;
+  currentState: Record<string, unknown>;
+  recommendedCommands: string[];
+  agentMemory: {
+    summary: {
+      events: number;
+      goals: number;
+      toolCalls: number;
+      files: number;
+      entries: number;
+      approvals: number;
+      proofs: number;
+      openQuestions: number;
+      sources: string[];
+      tools: string[];
+      latestEventAt?: string;
+    };
+    goals: Array<{ source: string; summary: string; confidence: number }>;
+    toolCalls: Array<{ source: string; tool: string; status?: string; summary?: string }>;
+    files: string[];
+    entries: string[];
+    approvals: Array<{ source: string; status: string; summary?: string }>;
+    proofs: Array<{ kind: string; result?: string }>;
+    events: AgentMemoryContextEvent[];
+    openQuestions: string[];
+  };
+  exitCode: 0;
+}
+
+export interface AgentMemoryFreshness {
+  status: "current" | "pending" | "unavailable";
+  pendingBytes: number;
+  queuedEvents: number;
+  inspectedEventsTruncated: boolean;
+  lastQueuedAt?: string;
+  latestMatchingEventAt?: string;
+  error?: string;
+}
+
+export interface AgentInstallResult {
+  ok: boolean;
+  target: string;
+  filesWritten: string[];
+  filesPlanned: string[];
+  privacy: {
+    rawPrompts: "off";
+    rawCompletions: "off";
+    rawToolArgs: "off";
+    transcriptImport: "off";
+    cloudSync: "off";
+  };
+  warnings: string[];
+  exitCode: 0 | 1;
+}
+
+export interface AgentIngestResult {
+  ok: boolean;
+  event?: AgentMemoryEventRecord;
+  envelope?: AgentEventEnvelope;
+  fallback?: {
+    kind: "agent-events-ndjson";
+    path: string;
+    reason: "pglite-active";
+  };
+  busy?: AgentMemoryUnavailableResult["busy"];
+  exitCode: 0 | 1;
+  error?: string;
+  diagnostics?: Diagnostic[];
+  nextActions?: string[];
+}
+
+export interface AgentIngestWatchResult {
+  ok: boolean;
+  watch: boolean;
+  source: string;
+  file?: string;
+  dryRun?: boolean;
+  eventsIngested: number;
+  errors: string[];
+  bytesRead?: number;
+  pendingBytes?: number;
+  checkpointFile?: string;
+  compacted?: boolean;
+  historyFile?: string;
+  busy?: AgentMemoryUnavailableResult["busy"];
+  pendingDueToBusy?: boolean;
+  busyRetries?: number;
+  nextActions: string[];
+  exitCode: 0 | 1;
+}
+
+export interface AgentMemoryUnavailableResult {
+  ok: false;
+  error: string;
+  events?: AgentMemoryEventRecord[];
+  busy?: {
+    code: "FORGE_DELTA_BUSY";
+    lockPath: string;
+    relativeLockPath: string;
+    pid?: number;
+    processAlive: boolean;
+    createdAt?: string;
+    ageMs?: number;
+    cwd?: string;
+    command?: string;
+    holderKnown: boolean;
+  };
+  diagnostics: Diagnostic[];
+  nextActions: string[];
+  exitCode: 1;
+}

package/src/forge/bench.ts

@@ -0,0 +1,248 @@
+import { run as runCompiler } from "./compiler/orchestrator/run.ts";
+import { getCompileTimings, type CompilePhaseTimings } from "./compiler/orchestrator/profile.ts";
+import type { Diagnostic } from "./compiler/types/diagnostic.ts";
+
+export type BenchSubcommand = "compiler";
+
+export interface BenchCommandOptions {
+  subcommand: BenchSubcommand;
+  workspaceRoot: string;
+  json: boolean;
+  iterations: number;
+  warmups: number;
+  concurrency: number;
+}
+
+export interface CompilerBenchIteration {
+  iteration: number;
+  warmup: boolean;
+  totalMs: number;
+  phases: CompilePhaseTimings;
+}
+
+export interface CompilerBenchSummary {
+  iterations: number;
+  warmups: number;
+  concurrency: number;
+  medianMs: number;
+  averageMs: number;
+  minMs: number;
+  maxMs: number;
+}
+
+export interface CompilerBenchResult {
+  schemaVersion: "0.1.0";
+  ok: boolean;
+  benchmark: "compiler";
+  mode: "dry-run";
+  summary: CompilerBenchSummary;
+  results: CompilerBenchIteration[];
+  diagnostics: Diagnostic[];
+  exitCode: 0 | 1;
+}
+
+function positiveInteger(value: number | undefined, fallback: number): number {
+  return value && Number.isFinite(value) && value >= 1 ? Math.floor(value) : fallback;
+}
+
+function roundMs(value: number): number {
+  return Math.round(value * 100) / 100;
+}
+
+function summarize(results: CompilerBenchIteration[], options: BenchCommandOptions): CompilerBenchSummary {
+  const measured = results.filter((result) => !result.warmup).map((result) => result.totalMs).sort((a, b) => a - b);
+  if (measured.length === 0) {
+    return {
+      iterations: options.iterations,
+      warmups: options.warmups,
+      concurrency: options.concurrency,
+      medianMs: 0,
+      averageMs: 0,
+      minMs: 0,
+      maxMs: 0,
+    };
+  }
+  const total = measured.reduce((sum, value) => sum + value, 0);
+  const middle = Math.floor(measured.length / 2);
+  const median = measured.length % 2 === 0
+    ? (measured[middle - 1]! + measured[middle]!) / 2
+    : measured[middle]!;
+  return {
+    iterations: options.iterations,
+    warmups: options.warmups,
+    concurrency: options.concurrency,
+    medianMs: roundMs(median),
+    averageMs: roundMs(total / measured.length),
+    minMs: roundMs(measured[0] ?? 0),
+    maxMs: roundMs(measured[measured.length - 1] ?? 0),
+  };
+}
+
+export async function runCompilerBenchCommand(options: BenchCommandOptions): Promise<CompilerBenchResult> {
+  const normalized: BenchCommandOptions = {
+    ...options,
+    iterations: positiveInteger(options.iterations, 5),
+    warmups: Math.max(0, Math.floor(options.warmups)),
+    concurrency: positiveInteger(options.concurrency, 4),
+  };
+  const previousProfile = process.env.FORGE_PROFILE;
+  process.env.FORGE_PROFILE = "silent";
+  const results: CompilerBenchIteration[] = [];
+  const diagnostics: Diagnostic[] = [];
+
+  try {
+    const totalRuns = normalized.warmups + normalized.iterations;
+    for (let index = 0; index < totalRuns; index += 1) {
+      const warmup = index < normalized.warmups;
+      const result = await runCompiler({
+        workspaceRoot: normalized.workspaceRoot,
+        check: false,
+        dryRun: true,
+        json: true,
+        concurrency: normalized.concurrency,
+      });
+      diagnostics.push(...result.errors, ...result.warnings);
+      const timings = getCompileTimings();
+      if (!timings) {
+        diagnostics.push({
+          severity: "error",
+          code: "FORGE_BENCH_PROFILE_MISSING",
+          message: "compiler timings were not recorded",
+        });
+        break;
+      }
+      results.push({
+        iteration: warmup ? index + 1 : index - normalized.warmups + 1,
+        warmup,
+        totalMs: roundMs(timings.totalMs),
+        phases: {
+          fastCheckMs: roundMs(timings.fastCheckMs),
+          sessionMs: roundMs(timings.sessionMs),
+          discoverMs: roundMs(timings.discoverMs),
+          graphBuildMs: roundMs(timings.graphBuildMs),
+          appGraphMs: roundMs(timings.appGraphMs),
+          ...(timings.appGraph
+            ? {
+                appGraph: {
+                  normalizeMs: roundMs(timings.appGraph.normalizeMs),
+                  parseMs: roundMs(timings.appGraph.parseMs),
+                  symbolsMs: roundMs(timings.appGraph.symbolsMs),
+                  duplicatesMs: roundMs(timings.appGraph.duplicatesMs),
+                  moduleGraphMs: roundMs(timings.appGraph.moduleGraphMs),
+                  inputHashMs: roundMs(timings.appGraph.inputHashMs),
+                  totalMs: roundMs(timings.appGraph.totalMs),
+                },
+              }
+            : {}),
+          packageGraphMs: roundMs(timings.packageGraphMs),
+          classifyMs: roundMs(timings.classifyMs),
+          ...(timings.classifierSignals
+            ? {
+                classifierSignals: {
+                  calls: timings.classifierSignals.calls,
+                  totalMs: roundMs(timings.classifierSignals.totalMs),
+                  entrypoints: timings.classifierSignals.entrypoints,
+                  exports: timings.classifierSignals.exports,
+                  textFragments: timings.classifierSignals.textFragments,
+                  corpusBytes: timings.classifierSignals.corpusBytes,
+                  packageCount: timings.classifierSignals.packageCount,
+                  topPackages: timings.classifierSignals.topPackages.map((pkg) => ({
+                    packageName: pkg.packageName,
+                    calls: pkg.calls,
+                    totalMs: roundMs(pkg.totalMs),
+                    entrypoints: pkg.entrypoints,
+                    exports: pkg.exports,
+                    textFragments: pkg.textFragments,
+                    corpusBytes: pkg.corpusBytes,
+                  })),
+                },
+              }
+            : {}),
+          planMs: roundMs(timings.planMs),
+          ...(timings.planDetail
+            ? {
+                planDetail: {
+                  coreArtifactsMs: roundMs(timings.planDetail.coreArtifactsMs),
+                  agentArtifactsMs: roundMs(timings.planDetail.agentArtifactsMs),
+                  supportArtifactsMs: roundMs(timings.planDetail.supportArtifactsMs),
+                  fileRenderMs: roundMs(timings.planDetail.fileRenderMs),
+                  finalizeMs: roundMs(timings.planDetail.finalizeMs),
+                  totalMs: roundMs(timings.planDetail.totalMs),
+                },
+              }
+            : {}),
+          runtimeMatrixMs: roundMs(timings.runtimeMatrixMs),
+          importGuardsMs: roundMs(timings.importGuardsMs),
+          qualityGateMs: roundMs(timings.qualityGateMs),
+          emitMs: roundMs(timings.emitMs),
+          postEmitMs: roundMs(timings.postEmitMs),
+          unaccountedMs: roundMs(timings.unaccountedMs),
+          totalMs: roundMs(timings.totalMs),
+        },
+      });
+      if (result.exitCode !== 0) {
+        break;
+      }
+    }
+  } finally {
+    if (previousProfile === undefined) {
+      delete process.env.FORGE_PROFILE;
+    } else {
+      process.env.FORGE_PROFILE = previousProfile;
+    }
+  }
+
+  const measuredCount = results.filter((result) => !result.warmup).length;
+  const ok = measuredCount === normalized.iterations && diagnostics.every((diagnostic) => diagnostic.severity !== "error");
+  return {
+    schemaVersion: "0.1.0",
+    ok,
+    benchmark: "compiler",
+    mode: "dry-run",
+    summary: summarize(results, normalized),
+    results,
+    diagnostics,
+    exitCode: ok ? 0 : 1,
+  };
+}
+
+export function formatCompilerBenchJson(result: CompilerBenchResult): string {
+  return `${JSON.stringify(result, null, 2)}\n`;
+}
+
+export function formatCompilerBenchHuman(result: CompilerBenchResult): string {
+  const lines = [
+    `${result.ok ? "ok" : "fail"} compiler bench (${result.summary.iterations} iterations, ${result.summary.warmups} warmups)`,
+    `median ${result.summary.medianMs}ms, avg ${result.summary.averageMs}ms, min ${result.summary.minMs}ms, max ${result.summary.maxMs}ms`,
+  ];
+  for (const item of result.results.filter((entry) => !entry.warmup)) {
+    lines.push(
+      `  #${item.iteration}: ${item.totalMs}ms ` +
+        `(discover ${item.phases.discoverMs}ms, graphs ${item.phases.graphBuildMs}ms, classify ${item.phases.classifyMs}ms, plan ${item.phases.planMs}ms, emit ${item.phases.emitMs}ms)`,
+    );
+    if (item.phases.appGraph) {
+      lines.push(
+        `      app detail: parse ${item.phases.appGraph.parseMs}ms, symbols ${item.phases.appGraph.symbolsMs}ms, module ${item.phases.appGraph.moduleGraphMs}ms, hash ${item.phases.appGraph.inputHashMs}ms`,
+      );
+    }
+    if (item.phases.classifierSignals) {
+      lines.push(
+        `      classifier detail: gatherSignals ${item.phases.classifierSignals.totalMs}ms across ${item.phases.classifierSignals.calls} calls, ${item.phases.classifierSignals.exports} exports`,
+      );
+      for (const pkg of item.phases.classifierSignals.topPackages.slice(0, 3)) {
+        lines.push(
+          `        ${pkg.packageName}: ${pkg.totalMs}ms, ${pkg.calls} calls, ${pkg.exports} exports`,
+        );
+      }
+    }
+    if (item.phases.planDetail) {
+      lines.push(
+        `      plan detail: core ${item.phases.planDetail.coreArtifactsMs}ms, agent ${item.phases.planDetail.agentArtifactsMs}ms, support ${item.phases.planDetail.supportArtifactsMs}ms, render ${item.phases.planDetail.fileRenderMs}ms, finalize ${item.phases.planDetail.finalizeMs}ms`,
+      );
+    }
+  }
+  for (const diagnostic of result.diagnostics) {
+    lines.push(`${diagnostic.severity} ${diagnostic.code}: ${diagnostic.message}`);
+  }
+  return `${lines.join("\n")}\n`;
+}