@bluecopa/harness 1.0.0 → 2.0.0

package/src/agent/create-tools.ts

@@ -1,33 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-export interface ExtractedToolSchema {
-  name: string;
-  description: string;
-  input_schema: {
-    type: string;
-    properties?: Record<string, unknown>;
-    required?: string[];
-    additionalProperties?: boolean;
-  };
-}
-
-export interface ExtractedToolsDocument {
-  version: string;
-  source: string;
-  tools: ExtractedToolSchema[];
-}
-
-export function loadExtractedTools(docPath?: string): ExtractedToolsDocument {
-  const path = docPath ?? resolve(import.meta.dirname, '../extracted/tools.json');
-  return JSON.parse(readFileSync(path, 'utf8')) as ExtractedToolsDocument;
-}
-
-export function createToolRegistry(docPath?: string): Map<string, ExtractedToolSchema> {
-  const extracted = loadExtractedTools(docPath);
-  return new Map(extracted.tools.map((tool) => [tool.name, tool]));
-}
-
-export function extractedToolNames(docPath?: string): string[] {
-  return loadExtractedTools(docPath).tools.map((tool) => tool.name);
-}

package/src/agent/step-executor.ts

@@ -1,15 +0,0 @@
-export type StepTask<T> = () => Promise<T>;
-
-// Ensures only one step task executes at a time for deterministic turn ordering.
-export class SingleFlightStepExecutor {
-  private queue = Promise.resolve();
-
-  run<T>(task: StepTask<T>): Promise<T> {
-    const next = this.queue.then(task, task);
-    this.queue = next.then(
-      () => undefined,
-      () => undefined
-    );
-    return next;
-  }
-}

package/src/agent/types.ts

@@ -1,57 +0,0 @@
-export interface ToolCallInfo {
-  toolCallId: string;
-  toolName: string;
-  args: Record<string, unknown>;
-}
-
-export interface ToolResultInfo {
-  toolCallId: string;
-  toolName: string;
-  result: string;
-  isError?: boolean;
-}
-
-export interface AgentMessage {
-  role: 'system' | 'user' | 'assistant' | 'tool';
-  content: string;
-  toolCalls?: ToolCallInfo[];      // assistant messages: what tools were called
-  toolResults?: ToolResultInfo[];  // tool messages: results keyed by toolCallId
-}
-
-export interface ToolCallAction {
-  type: 'tool';
-  name: string;
-  args: Record<string, unknown>;
-  toolCallId?: string;
-}
-
-export interface FinalAction {
-  type: 'final';
-  content: string;
-}
-
-export interface ToolBatchAction {
-  type: 'tool_batch';
-  calls: ToolCallAction[];
-}
-
-export type AgentAction = ToolCallAction | FinalAction | ToolBatchAction;
-
-export interface AgentRunResult {
-  messages: AgentMessage[];
-  output: string;
-  steps: number;
-}
-
-export type AgentStreamEvent =
-  | { type: 'text_delta'; text: string }
-  | { type: 'tool_start'; name: string; args: Record<string, unknown>; toolCallId?: string }
-  | { type: 'tool_end'; name: string; result: { success: boolean; output: string; error?: string } }
-  | { type: 'step_start'; step: number }
-  | { type: 'step_end'; step: number }
-  | { type: 'done'; output: string; steps: number };
-
-export interface AgentLoop {
-  nextAction(messages: AgentMessage[]): Promise<AgentAction>;
-  streamAction?(messages: AgentMessage[]): AsyncIterable<AgentStreamEvent>;
-}

package/src/context/llm-compaction-strategy.ts

@@ -1,37 +0,0 @@
-import type { CompactionInput, CompactionResult, CompactionStrategy } from '../interfaces/compaction-strategy';
-import type { Message } from '../interfaces/session-store';
-
-export class LLMCompactionStrategy implements CompactionStrategy {
-  constructor(private readonly thresholdRatio = 0.85) {}
-
-  shouldCompact(input: CompactionInput): boolean {
-    return input.tokenCount >= Math.floor(input.maxTokens * this.thresholdRatio);
-  }
-
-  async compact(input: CompactionInput): Promise<CompactionResult> {
-    const { messages } = input;
-
-    if (messages.length <= 2) {
-      return {
-        compactedMessages: messages,
-        summary: 'No compaction required',
-        newBoundary: messages.length - 1
-      };
-    }
-
-    const preserveTail = 2;
-    const head = messages.slice(0, Math.max(0, messages.length - preserveTail));
-    const tail = messages.slice(-preserveTail);
-
-    const summary: Message = {
-      role: 'system',
-      content: `Compaction summary: condensed ${head.length} earlier message(s).`
-    };
-
-    return {
-      compactedMessages: [summary, ...tail],
-      summary: summary.content,
-      newBoundary: head.length
-    };
-  }
-}

package/src/context/prepare-step.ts

@@ -1,65 +0,0 @@
-import type { Message } from '../interfaces/session-store';
-import type { CompactionStrategy } from '../interfaces/compaction-strategy';
-import type { HarnessTelemetry } from '../observability/otel';
-import { recordCompaction } from '../observability/metrics';
-import { traceStep } from '../observability/tracing';
-import { TokenTracker } from './token-tracker';
-
-export interface PrepareStepState {
-  pendingCompaction?: boolean;
-  compactionBoundary?: number;
-}
-
-export interface PrepareStepInput {
-  messages: Message[];
-  maxTokens: number;
-  isStreaming: boolean;
-  state: PrepareStepState;
-  tokenTracker: TokenTracker;
-  compactionStrategy: CompactionStrategy;
-  telemetry?: HarnessTelemetry;
-}
-
-export interface PrepareStepOutput {
-  messages: Message[];
-  state: PrepareStepState;
-}
-
-export async function prepareStep(input: PrepareStepInput): Promise<PrepareStepOutput> {
-  const { messages, maxTokens, isStreaming, state, tokenTracker, compactionStrategy, telemetry } = input;
-  const tokenCount = tokenTracker.countMessages(messages);
-
-  const shouldCompactNow = state.pendingCompaction || compactionStrategy.shouldCompact({
-    messages,
-    tokenCount,
-    maxTokens
-  });
-
-  if (!shouldCompactNow) {
-    return { messages, state };
-  }
-
-  if (isStreaming) {
-    return {
-      messages,
-      state: { ...state, pendingCompaction: true }
-    };
-  }
-
-  const compacted = await traceStep(telemetry, 'context.compaction', { tokenCount, maxTokens }, () =>
-    compactionStrategy.compact({
-      messages,
-      tokenCount,
-      maxTokens
-    })
-  );
-  recordCompaction(telemetry);
-
-  return {
-    messages: compacted.compactedMessages,
-    state: {
-      pendingCompaction: false,
-      compactionBoundary: compacted.newBoundary
-    }
-  };
-}

package/src/context/token-tracker.ts

@@ -1,26 +0,0 @@
-import type { Message } from '../interfaces/session-store';
-
-export interface TokenCountOptions {
-  estimator?: (text: string) => number;
-}
-
-export class TokenTracker {
-  constructor(private readonly options: TokenCountOptions = {}) {}
-
-  private estimate(text: string): number {
-    if (this.options.estimator) {
-      return this.options.estimator(text);
-    }
-
-    // Fast fallback estimator for provider-agnostic usage.
-    return Math.ceil(text.length / 4);
-  }
-
-  countText(text: string): number {
-    return this.estimate(text);
-  }
-
-  countMessages(messages: Message[]): number {
-    return messages.reduce((sum, message) => sum + this.estimate(message.content), 0);
-  }
-}

package/src/extracted/manifest.json

@@ -1,10 +0,0 @@
-{
-  "schemaVersion": "1.0.0",
-  "sourceCommit": "pending-extraction",
-  "extractedAt": "2026-02-22T19:42:33.319Z",
-  "checksums": {
-    "tools": "3f7794093f9dd302d3fd547b6a30f68242e183526ae608e32e5827c31a065083",
-    "systemPrompt": "700b33b01a81750c7f0df34a6a8ad7665b994e53fd58a4b1f9e4591b4cece18c",
-    "compactionPrompt": "89032b0b1b45bdfae86732b88fb0fca25e542b2e2c6efca5e2e6efbe9e785cb0"
-  }
-}

package/src/extracted/prompts/compaction.md

@@ -1,5 +0,0 @@
-# Compaction Prompt Baseline
-
-This file contains the compaction prompt baseline used when context exceeds limits.
-
-Status: placeholder baseline captured from requirements doc. Replace with extracted prompt material from source repositories before production release.

package/src/extracted/prompts/system.md

@@ -1,5 +0,0 @@
-# System Prompt Baseline
-
-This file contains the extracted baseline system instructions used for parity testing.
-
-Status: placeholder baseline captured from requirements doc. Replace with extracted prompt material from source repositories before production release.

package/src/extracted/tools.json

@@ -1,82 +0,0 @@
-{
-  "version": "2026-02-22",
-  "source": "claude-agent-sdk parity baseline",
-  "tools": [
-    {
-      "name": "Bash",
-      "description": "Run shell commands in the execution environment.",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "command": { "type": "string" }
-        },
-        "required": ["command"],
-        "additionalProperties": false
-      }
-    },
-    {
-      "name": "Read",
-      "description": "Read a file from disk.",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "path": { "type": "string" }
-        },
-        "required": ["path"],
-        "additionalProperties": false
-      }
-    },
-    {
-      "name": "Write",
-      "description": "Write content to a file.",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "path": { "type": "string" },
-          "content": { "type": "string" }
-        },
-        "required": ["path", "content"],
-        "additionalProperties": false
-      }
-    },
-    {
-      "name": "Edit",
-      "description": "Apply targeted text edits to a file.",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "path": { "type": "string" },
-          "old_text": { "type": "string" },
-          "new_text": { "type": "string" }
-        },
-        "required": ["path", "old_text", "new_text"],
-        "additionalProperties": false
-      }
-    },
-    {
-      "name": "Glob",
-      "description": "Find files by glob pattern.",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "pattern": { "type": "string" }
-        },
-        "required": ["pattern"],
-        "additionalProperties": false
-      }
-    },
-    {
-      "name": "Grep",
-      "description": "Search file contents with a pattern.",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "pattern": { "type": "string" },
-          "path": { "type": "string" }
-        },
-        "required": ["pattern"],
-        "additionalProperties": false
-      }
-    }
-  ]
-}

package/src/hooks/hook-runner.ts

@@ -1,22 +0,0 @@
-import type { HookCallback, HookContext, HookDecision } from '../interfaces/hooks';
-
-export class HookRunner {
-  private readonly hooks = new Map<string, HookCallback[]>();
-
-  register(event: HookContext['event'], callback: HookCallback): void {
-    const list = this.hooks.get(event) ?? [];
-    list.push(callback);
-    this.hooks.set(event, list);
-  }
-
-  async run(context: HookContext): Promise<HookDecision> {
-    const list = this.hooks.get(context.event) ?? [];
-    for (const hook of list) {
-      const result = await hook(context);
-      if (result && result.allow === false) {
-        return result;
-      }
-    }
-    return { allow: true };
-  }
-}

package/src/hooks/tool-wrappers.ts

@@ -1,64 +0,0 @@
-import type { ToolProvider, ToolResult } from '../interfaces/tool-provider';
-import { HookRunner } from './hook-runner';
-import { PermissionManager } from '../permissions/permission-manager';
-import type { HarnessTelemetry } from '../observability/otel';
-import { recordToolCallDuration } from '../observability/metrics';
-import { traceStep } from '../observability/tracing';
-
-export function withHooks(
-  provider: ToolProvider,
-  hookRunner: HookRunner,
-  permissionManager: PermissionManager,
-  telemetry?: HarnessTelemetry
-): ToolProvider {
-  async function guarded(
-    toolName: string,
-    input: Record<string, unknown>,
-    execute: () => Promise<ToolResult>
-  ): Promise<ToolResult> {
-    return traceStep(telemetry, 'tool.call', { tool: toolName }, async () => {
-      const started = Date.now();
-      const pre = await hookRunner.run({ event: 'PreToolUse', toolName, input });
-      if (!pre.allow) {
-        const result = { success: false, output: '', error: pre.reason ?? 'blocked by pre-hook' };
-        recordToolCallDuration(telemetry, toolName, Date.now() - started, false);
-        return result;
-      }
-
-      const permission = await permissionManager.check({ toolName, input });
-      if (!permission.allow) {
-        const result = {
-          success: false,
-          output: '',
-          error: permission.reason ?? 'blocked by permission manager'
-        };
-        recordToolCallDuration(telemetry, toolName, Date.now() - started, false);
-        return result;
-      }
-
-      const result = await execute();
-      await hookRunner.run({ event: 'PostToolUse', toolName, input, output: result });
-      recordToolCallDuration(telemetry, toolName, Date.now() - started, result.success);
-      return result;
-    });
-  }
-
-  return {
-    capabilities: () => provider.capabilities(),
-    initialize: provider.initialize?.bind(provider),
-    destroy: provider.destroy?.bind(provider),
-    bash: (command, options) => guarded('Bash', { command }, () => provider.bash(command, options)),
-    readFile: (path, options) => guarded('Read', { path }, () => provider.readFile(path, options)),
-    writeFile: (path, content) => guarded('Write', { path }, () => provider.writeFile(path, content)),
-    editFile: (path, oldText, newText) =>
-      guarded('Edit', { path, oldText, newText }, () => provider.editFile(path, oldText, newText)),
-    glob: (pattern, options) => guarded('Glob', { pattern }, () => provider.glob(pattern, options)),
-    grep: (pattern, path, options) => guarded('Grep', { pattern, path }, () => provider.grep(pattern, path, options)),
-    webFetch: provider.webFetch
-      ? (options) => guarded('WebFetch', { url: options.url }, () => provider.webFetch!(options))
-      : undefined,
-    webSearch: provider.webSearch
-      ? (query) => guarded('WebSearch', { query }, () => provider.webSearch!(query))
-      : undefined
-  };
-}

package/src/interfaces/compaction-strategy.ts

@@ -1,18 +0,0 @@
-import type { Message } from './session-store';
-
-export interface CompactionInput {
-  messages: Message[];
-  tokenCount: number;
-  maxTokens: number;
-}
-
-export interface CompactionResult {
-  compactedMessages: Message[];
-  summary: string;
-  newBoundary: number;
-}
-
-export interface CompactionStrategy {
-  shouldCompact(input: CompactionInput): boolean;
-  compact(input: CompactionInput): Promise<CompactionResult>;
-}

package/src/interfaces/hooks.ts

@@ -1,24 +0,0 @@
-import type { ToolResult } from './tool-provider';
-
-export type HookEventName =
-  | 'PreToolUse'
-  | 'PostToolUse'
-  | 'SessionStart'
-  | 'SessionEnd'
-  | 'CompactionStart'
-  | 'CompactionEnd';
-
-export interface HookContext {
-  event: HookEventName;
-  toolName?: string;
-  input?: Record<string, unknown>;
-  output?: ToolResult;
-  metadata?: Record<string, unknown>;
-}
-
-export interface HookDecision {
-  allow: boolean;
-  reason?: string;
-}
-
-export type HookCallback = (context: HookContext) => Promise<HookDecision | void>;

package/src/interfaces/sandbox-provider.ts

@@ -1,29 +0,0 @@
-export interface SandboxExecResult {
-  exitCode: number;
-  stdout: string;
-  stderr: string;
-}
-
-export interface SandboxExecOptions {
-  cwd?: string | undefined;
-  timeoutMs?: number | undefined;
-  env?: Record<string, string> | undefined;
-}
-
-export interface SandboxFileBlob {
-  data: Uint8Array;
-  mimeType?: string | undefined;
-  filename?: string | undefined;
-}
-
-export interface SandboxProvider {
-  initialize?(): Promise<void>;
-  destroy?(): Promise<void>;
-  exec(command: string, options?: SandboxExecOptions): Promise<SandboxExecResult>;
-  readSandboxFile(path: string): Promise<SandboxFileBlob>;
-  writeSandboxFile(path: string, content: SandboxFileBlob): Promise<void>;
-  upload?(localPath: string, remotePath: string): Promise<void>;
-  listFiles?(path: string): Promise<string[]>;
-  snapshot?(): Promise<string>;
-  restore?(snapshotId: string): Promise<void>;
-}

package/src/interfaces/session-store.ts

@@ -1,48 +0,0 @@
-export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
-
-export interface Message {
-  role: MessageRole;
-  content: string;
-  createdAt?: string;
-}
-
-export interface ExecutionTrace {
-  events: Array<Record<string, unknown>>;
-  metadata?: Record<string, unknown>;
-}
-
-export interface AgentSession {
-  id: string;
-  createdAt: Date;
-  updatedAt: Date;
-  messages: Message[];
-  compactionBoundary?: number;
-  providerState?: string;
-  metadata: Record<string, unknown>;
-  trace?: ExecutionTrace;
-  task?: { prompt: string; metadata?: Record<string, unknown> };
-  status: 'running' | 'completed' | 'failed' | 'timeout';
-  score?: number | Record<string, number>;
-  configHash?: string;
-}
-
-export interface SessionFilter {
-  status?: AgentSession['status'];
-  scoredOnly?: boolean;
-  scoreBelow?: number;
-  scoreAbove?: number;
-  configHash?: string;
-  taskPromptContains?: string;
-  after?: Date;
-  before?: Date;
-  limit?: number;
-  orderBy?: 'score_asc' | 'score_desc' | 'created_asc' | 'created_desc';
-}
-
-export interface SessionStore {
-  save(session: AgentSession): Promise<void>;
-  get(id: string): Promise<AgentSession | null>;
-  list(filter?: SessionFilter): Promise<AgentSession[]>;
-  delete(id: string): Promise<void>;
-  count?(filter?: SessionFilter): Promise<number>;
-}

package/src/interfaces/tool-provider.ts

@@ -1,70 +0,0 @@
-export interface ToolResult {
-  success: boolean;
-  output: string;
-  error?: string | undefined;
-  metadata?: Record<string, unknown> | undefined;
-}
-
-export interface BashOptions {
-  timeout?: number | undefined;
-  cwd?: string | undefined;
-}
-
-export interface ReadOptions {
-  lineRange?: [number, number] | undefined;
-  maxLines?: number | undefined;
-}
-
-export interface GlobOptions {
-  ignore?: string[] | undefined;
-  maxResults?: number | undefined;
-}
-
-export interface GrepOptions {
-  caseInsensitive?: boolean | undefined;
-  wholeWord?: boolean | undefined;
-  maxResults?: number | undefined;
-  include?: string | undefined;
-}
-
-export interface WebFetchOptions {
-  url: string;
-  selector?: string | undefined;
-  maxContentLength?: number | undefined;
-  headers?: Record<string, string> | undefined;
-}
-
-export type BatchOp =
-  | { op: "exec"; command: string; cwd?: string; timeoutMs?: number }
-  | { op: "write_file"; path: string; content: string; encoding?: "utf8" | "base64" }
-  | { op: "read_file"; path: string; encoding?: "utf8" | "base64" };
-
-export type BatchResult =
-  | { success: true; op: "exec"; exitCode: number; stdout: string; stderr: string }
-  | { success: true; op: "write_file" }
-  | { success: true; op: "read_file"; content: string }
-  | { success: false; op: string; error: string };
-
-export interface ToolProviderCapabilities {
-  bash: boolean;
-  fileSystem: boolean;
-  webFetch: boolean;
-  webSearch: boolean;
-  codeExecution: boolean;
-  sandboxed: boolean;
-}
-
-export interface ToolProvider {
-  bash(command: string, options?: BashOptions): Promise<ToolResult>;
-  readFile(path: string, options?: ReadOptions): Promise<ToolResult>;
-  writeFile(path: string, content: string): Promise<ToolResult>;
-  editFile(path: string, oldText: string, newText: string): Promise<ToolResult>;
-  glob(pattern: string, options?: GlobOptions): Promise<ToolResult>;
-  grep(pattern: string, path?: string, options?: GrepOptions): Promise<ToolResult>;
-  webFetch?: ((options: WebFetchOptions) => Promise<ToolResult>) | undefined;
-  webSearch?: ((query: string) => Promise<ToolResult>) | undefined;
-  batch?: ((ops: BatchOp[]) => Promise<BatchResult[]>) | undefined;
-  initialize?: (() => Promise<void>) | undefined;
-  destroy?: (() => Promise<void>) | undefined;
-  capabilities(): ToolProviderCapabilities;
-}