cognitive-core 0.2.4 → 0.3.1

package/src/learning/trajectory-sources/dataclaw.ts

@@ -1,403 +0,0 @@
-import { readFile, readdir, stat } from 'node:fs/promises';
-import { join, extname } from 'node:path';
-import {
-  DataclawSessionSchema,
-  type DataclawSession,
-  type DataclawToolUse,
-} from '../../types/dataclaw.js';
-import type {
-  TrajectorySource,
-  TrajectoryWithAnalysis,
-  TrajectoryLoadOptions,
-} from '../../types/trajectory-source.js';
-import type { Trajectory } from '../../types/trajectory.js';
-import type { Task } from '../../types/task.js';
-import type { Outcome } from '../../types/outcome.js';
-import type { Step } from '../../types/step.js';
-
-// ─── DataclawTrajectorySource ───────────────────────────────────────────
-// Bridges dataclaw JSONL exports into cognitive-core's learning pipeline.
-//
-// dataclaw (https://github.com/peteromallet/dataclaw) exports conversation
-// histories from AI coding assistants (Claude Code, Codex, Gemini CLI, etc.)
-// into structured JSONL — one session per line.
-//
-// This source reads that format and converts each session into a Trajectory:
-//   - Task description from the first user message
-//   - Steps from assistant messages: thinking → thought, tool_uses → actions
-//   - Outcome inferred heuristically from tool error rates + final messages
-//   - Token counts from dataclaw stats
-// ─────────────────────────────────────────────────────────────────────────
-
-export interface DataclawSourceOptions {
-  /** Domain to assign to all trajectories (default: inferred from tool names) */
-  domain?: string;
-  /** How to determine success/failure (default: 'heuristic') */
-  outcomeStrategy?: 'heuristic' | 'optimistic';
-  /** Only include sessions from specific sources (e.g. ['claude', 'codex']) */
-  sources?: string[];
-  /** Only include sessions using specific models */
-  models?: string[];
-}
-
-export class DataclawTrajectorySource implements TrajectorySource {
-  readonly name = 'dataclaw';
-
-  constructor(
-    /** Path to a .jsonl file or a directory containing .jsonl files */
-    private path: string,
-    private options?: DataclawSourceOptions,
-  ) {}
-
-  async load(
-    options?: TrajectoryLoadOptions,
-  ): Promise<TrajectoryWithAnalysis[]> {
-    const sessions = await this.readSessions();
-    const items: TrajectoryWithAnalysis[] = [];
-
-    for (const session of sessions) {
-      try {
-        // Pre-filter by dataclaw-specific options
-        if (
-          this.options?.sources?.length &&
-          !this.options.sources.includes(session.source)
-        ) {
-          continue;
-        }
-        if (
-          this.options?.models?.length &&
-          !this.options.models.includes(session.model)
-        ) {
-          continue;
-        }
-
-        const trajectory = this.synthesize(session);
-
-        // Apply standard TrajectoryLoadOptions filters
-        if (options?.since && trajectory.timestamp.getTime() < options.since.getTime()) {
-          continue;
-        }
-        if (options?.domain && trajectory.task.domain !== options.domain) {
-          continue;
-        }
-        if (options?.successOnly && !trajectory.outcome.success) {
-          continue;
-        }
-
-        items.push({ trajectory, analysis: undefined });
-      } catch {
-        // Skip sessions that fail to synthesize
-      }
-    }
-
-    if (options?.limit && options.limit > 0) {
-      return items.slice(0, options.limit);
-    }
-
-    return items;
-  }
-
-  async count(options?: TrajectoryLoadOptions): Promise<number> {
-    const items = await this.load(options);
-    return items.length;
-  }
-
-  /**
-   * Convert a dataclaw session into a cognitive-core Trajectory.
-   */
-  synthesize(session: DataclawSession): Trajectory {
-    const startTime = session.start_time
-      ? new Date(session.start_time)
-      : new Date();
-
-    return {
-      id: `dataclaw-${session.source}-${session.session_id}`,
-      task: this.extractTask(session),
-      steps: this.extractSteps(session),
-      outcome: this.inferOutcome(session),
-      agentId: session.model || session.source || 'unknown',
-      timestamp: startTime,
-      llmCalls: this.estimateLlmCalls(session),
-      totalTokens: this.computeTotalTokens(session),
-      wallTimeSeconds: this.computeWallTime(session),
-      metadata: {
-        source: 'dataclaw',
-        dataclawSource: session.source,
-        project: session.project,
-        model: session.model,
-        gitBranch: session.git_branch ?? undefined,
-        sessionId: session.session_id,
-      },
-    };
-  }
-
-  // ── Private: I/O ──────────────────────────────────────────────────
-
-  private async readSessions(): Promise<DataclawSession[]> {
-    const sessions: DataclawSession[] = [];
-
-    let isDir = false;
-    try {
-      const s = await stat(this.path);
-      isDir = s.isDirectory();
-    } catch {
-      return [];
-    }
-
-    if (isDir) {
-      // Read all .jsonl files in the directory
-      let files: string[];
-      try {
-        files = await readdir(this.path);
-      } catch {
-        return [];
-      }
-
-      for (const file of files) {
-        if (extname(file) === '.jsonl') {
-          const fileSessions = await this.parseJsonlFile(join(this.path, file));
-          sessions.push(...fileSessions);
-        }
-      }
-    } else {
-      // Single file
-      const fileSessions = await this.parseJsonlFile(this.path);
-      sessions.push(...fileSessions);
-    }
-
-    return sessions;
-  }
-
-  private async parseJsonlFile(filePath: string): Promise<DataclawSession[]> {
-    const sessions: DataclawSession[] = [];
-
-    let content: string;
-    try {
-      content = await readFile(filePath, 'utf-8');
-    } catch {
-      return [];
-    }
-
-    for (const line of content.split('\n')) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-
-      try {
-        const raw = JSON.parse(trimmed);
-        const parsed = DataclawSessionSchema.safeParse(raw);
-        if (parsed.success) {
-          sessions.push(parsed.data);
-        }
-      } catch {
-        // Skip malformed lines
-      }
-    }
-
-    return sessions;
-  }
-
-  // ── Private: Synthesis ────────────────────────────────────────────
-
-  private extractTask(session: DataclawSession): Task {
-    const description =
-      this.getFirstUserMessage(session) ?? 'Unknown task';
-
-    return {
-      id: `task-${session.session_id}`,
-      domain: this.options?.domain ?? this.inferDomain(session),
-      description,
-      context: {
-        project: session.project,
-        model: session.model,
-        gitBranch: session.git_branch ?? undefined,
-      },
-      metadata: {
-        dataclawSource: session.source,
-      },
-      createdAt: session.start_time
-        ? new Date(session.start_time)
-        : new Date(),
-    };
-  }
-
-  private extractSteps(session: DataclawSession): Step[] {
-    const steps: Step[] = [];
-
-    for (const msg of session.messages) {
-      if (msg.role !== 'assistant') continue;
-
-      const thought = msg.thinking || undefined;
-      const toolUses = msg.tool_uses ?? [];
-
-      if (toolUses.length === 0) {
-        // Pure reasoning / text-only response
-        if (msg.content || thought) {
-          steps.push({
-            thought: thought ?? msg.content,
-            action: msg.content && !thought ? msg.content : '',
-            observation: '',
-            timestamp: msg.timestamp ? new Date(msg.timestamp) : new Date(),
-            metadata: { messageType: 'text' },
-          });
-        }
-      } else {
-        // Tool-use steps
-        for (const tool of toolUses) {
-          steps.push({
-            thought: thought ?? (msg.content || undefined),
-            action: this.formatToolAction(tool),
-            observation: this.formatToolOutput(tool),
-            timestamp: msg.timestamp ? new Date(msg.timestamp) : new Date(),
-            metadata: {
-              toolName: tool.tool,
-              toolStatus: tool.status,
-              messageType: 'tool_use',
-            },
-          });
-          // Only attach the thought/content to the first tool use in a message
-        }
-      }
-    }
-
-    return steps;
-  }
-
-  private inferOutcome(session: DataclawSession): Outcome {
-    const strategy = this.options?.outcomeStrategy ?? 'heuristic';
-
-    if (strategy === 'optimistic') {
-      return {
-        success: true,
-        partialScore: 0.7,
-        verificationDetails: { strategy: 'optimistic' },
-      };
-    }
-
-    // Heuristic: check tool error rates and look for failure signals
-    const toolUses = session.messages.flatMap((m) => m.tool_uses ?? []);
-    const totalTools = toolUses.length;
-    const errorTools = toolUses.filter((t) => t.status === 'error').length;
-    const errorRate = totalTools > 0 ? errorTools / totalTools : 0;
-
-    // Check final assistant messages for failure signals
-    const lastAssistant = [...session.messages]
-      .reverse()
-      .find((m) => m.role === 'assistant');
-    const finalText = (lastAssistant?.content ?? '').toLowerCase();
-    const hasFailureSignal =
-      finalText.includes('unable to') ||
-      finalText.includes('cannot') ||
-      finalText.includes('failed') ||
-      finalText.includes('error');
-
-    // High error rate or strong failure signals → failure
-    if (errorRate > 0.5 || (hasFailureSignal && totalTools === 0)) {
-      return {
-        success: false,
-        partialScore: Math.max(0, 1 - errorRate),
-        errorInfo: hasFailureSignal
-          ? 'Failure signals detected in final response'
-          : `High tool error rate: ${(errorRate * 100).toFixed(0)}%`,
-        verificationDetails: {
-          strategy: 'heuristic',
-          toolErrorRate: errorRate,
-          hasFailureSignal,
-        },
-      };
-    }
-
-    // Has tool usage and reasonable success → likely success
-    const hasSubstantialWork = totalTools > 0;
-    return {
-      success: true,
-      partialScore: hasSubstantialWork ? 0.8 : 0.5,
-      verificationDetails: {
-        strategy: 'heuristic',
-        toolErrorRate: errorRate,
-        hasSubstantialWork,
-      },
-    };
-  }
-
-  private inferDomain(session: DataclawSession): string {
-    // Infer from tool names — dataclaw normalizes tool names across sources
-    const toolNames = session.messages
-      .flatMap((m) => m.tool_uses ?? [])
-      .map((t) => t.tool.toLowerCase());
-
-    // Look for file-related tool inputs for extension-based inference
-    const fileExtensions = session.messages
-      .flatMap((m) => m.tool_uses ?? [])
-      .flatMap((t) => {
-        const input = t.input as Record<string, unknown>;
-        const paths = [
-          input.file_path,
-          input.path,
-          input.command,
-        ].filter((v): v is string => typeof v === 'string');
-        return paths;
-      })
-      .join(' ');
-
-    if (/\.(test|spec)\.(ts|js|tsx|jsx|py)\b/.test(fileExtensions))
-      return 'testing';
-    if (/\.(ts|tsx)\b/.test(fileExtensions)) return 'typescript';
-    if (/\.py\b/.test(fileExtensions)) return 'python';
-    if (/\.go\b/.test(fileExtensions)) return 'go';
-    if (/\.rs\b/.test(fileExtensions)) return 'rust';
-    if (/\.(java|kt)\b/.test(fileExtensions)) return 'java';
-    if (/\.(rb)\b/.test(fileExtensions)) return 'ruby';
-
-    // Fall back to source-based heuristic
-    if (toolNames.some((n) => n.includes('bash') || n.includes('shell')))
-      return 'code';
-
-    return 'code';
-  }
-
-  private getFirstUserMessage(
-    session: DataclawSession,
-  ): string | undefined {
-    const firstUser = session.messages.find((m) => m.role === 'user');
-    if (!firstUser) return undefined;
-    const text = firstUser.content.trim();
-    // Truncate very long first messages to a reasonable task description
-    return text.length > 500 ? text.slice(0, 500) + '...' : text;
-  }
-
-  private formatToolAction(tool: DataclawToolUse): string {
-    return `${tool.tool}(${JSON.stringify(tool.input)})`;
-  }
-
-  private formatToolOutput(tool: DataclawToolUse): string {
-    const output = tool.output;
-    // Dataclaw output shapes vary by source
-    if ('text' in output && typeof output.text === 'string') {
-      return output.text;
-    }
-    if ('output' in output && typeof output.output === 'string') {
-      return output.output;
-    }
-    // Fallback: stringify the whole output
-    const str = JSON.stringify(output);
-    return str === '{}' ? '' : str;
-  }
-
-  private estimateLlmCalls(session: DataclawSession): number {
-    // Each assistant message is roughly one LLM call
-    return session.messages.filter((m) => m.role === 'assistant').length;
-  }
-
-  private computeTotalTokens(session: DataclawSession): number {
-    if (!session.stats) return 0;
-    return (session.stats.input_tokens ?? 0) + (session.stats.output_tokens ?? 0);
-  }
-
-  private computeWallTime(session: DataclawSession): number {
-    if (!session.start_time || !session.end_time) return 0;
-    const start = new Date(session.start_time).getTime();
-    const end = new Date(session.end_time).getTime();
-    if (isNaN(start) || isNaN(end)) return 0;
-    return Math.max(0, (end - start) / 1000);
-  }
-}

package/src/learning/trajectory-sources/entire.ts

@@ -1,251 +0,0 @@
-import type { SessionBank, SessionRecord } from '../../session-bank/index.js';
-import type {
-  TrajectorySource,
-  TrajectoryWithAnalysis,
-  TrajectoryLoadOptions,
-} from '../../types/trajectory-source.js';
-import type { Trajectory } from '../../types/trajectory.js';
-import type { Task } from '../../types/task.js';
-import type { Outcome } from '../../types/outcome.js';
-import type { Step } from '../../types/step.js';
-
-// ─── SessionTrajectorySource ────────────────────────────────────────
-// Bridges session-bank checkpoint data (SessionLog) into
-// cognitive-core's learning pipeline via the TrajectorySource
-// interface.
-//
-// Synthesis converts SessionRecord → Trajectory:
-//   - Task description from summary.intent or first user message
-//   - Steps from assistant tool_use blocks (ReAct pattern)
-//   - Outcome inferred from summary.outcome keywords or heuristic
-//   - Token counts direct from checkpoint metadata
-// ─────────────────────────────────────────────────────────────────────
-
-export interface SessionSynthesisOptions {
-  /** Domain to assign (default: inferred from files) */
-  domain?: string;
-  /** How to determine success/failure (default: 'summary') */
-  outcomeStrategy?: 'summary' | 'heuristic';
-  /** Source name for trajectory IDs and metadata (default: auto-detected from branch) */
-  sourceName?: string;
-}
-
-export class SessionTrajectorySource implements TrajectorySource {
-  readonly name: string;
-
-  constructor(
-    private sessionBank: SessionBank,
-    private options?: SessionSynthesisOptions,
-  ) {
-    this.name = options?.sourceName ?? 'session';
-  }
-
-  async load(
-    options?: TrajectoryLoadOptions,
-  ): Promise<TrajectoryWithAnalysis[]> {
-    const result = await this.sessionBank.query({
-      since: options?.since,
-      limit: options?.limit,
-    });
-
-    const items: TrajectoryWithAnalysis[] = [];
-
-    for (const session of result.sessions) {
-      try {
-        const trajectory = this.synthesize(session);
-        if (options?.domain && trajectory.task.domain !== options.domain) continue;
-        if (options?.successOnly && !trajectory.outcome.success) continue;
-        items.push({ trajectory, analysis: undefined });
-      } catch {
-        // Skip sessions that fail to synthesize
-      }
-    }
-
-    return items;
-  }
-
-  async count(options?: TrajectoryLoadOptions): Promise<number> {
-    return this.sessionBank.count({
-      since: options?.since,
-    });
-  }
-
-  /**
-   * Convert a SessionRecord into a cognitive-core Trajectory.
-   */
-  synthesize(session: SessionRecord): Trajectory {
-    const sourceName = this.resolveSourceName(session);
-    return {
-      id: `${sourceName}-${session.checkpointId}-${session.sessionId}`,
-      task: this.extractTask(session),
-      steps: this.extractSteps(session),
-      outcome: this.inferOutcome(session),
-      agentId: session.metadata.agent,
-      timestamp: session.metadata.createdAt,
-      llmCalls: session.tokenUsage.apiCallCount,
-      totalTokens: session.tokenUsage.total,
-      wallTimeSeconds: 0,
-      metadata: {
-        source: sourceName,
-        checkpointId: session.checkpointId,
-        sessionId: session.sessionId,
-        branch: session.metadata.branch,
-        filesTouched: session.metadata.filesTouched,
-        strategy: session.metadata.strategy,
-        attribution: session.attribution,
-      },
-    };
-  }
-
-  // ── Private helpers ──────────────────────────────────────────
-
-  private resolveSourceName(_session: SessionRecord): string {
-    if (this.options?.sourceName) return this.options.sourceName;
-    return 'sessionlog';
-  }
-
-  private extractTask(session: SessionRecord): Task {
-    const description =
-      session.summary?.intent ??
-      this.getFirstUserMessage(session) ??
-      'Unknown task';
-
-    return {
-      id: `task-${session.sessionId}`,
-      domain: this.options?.domain ?? this.inferDomain(session),
-      description,
-      context: {
-        filesTouched: session.metadata.filesTouched,
-        branch: session.metadata.branch,
-      },
-      metadata: {},
-      createdAt: session.metadata.createdAt,
-    };
-  }
-
-  private extractSteps(session: SessionRecord): Step[] {
-    const steps: Step[] = [];
-
-    for (const msg of session.transcript) {
-      if (msg.role !== 'assistant') continue;
-
-      const textBlocks = msg.content.filter((b) => b.type === 'text');
-      const thought = textBlocks
-        .map((b) => (b as { type: 'text'; text: string }).text)
-        .join('\n');
-
-      const toolBlocks = msg.content.filter((b) => b.type === 'tool_use');
-
-      if (toolBlocks.length === 0) {
-        // Pure reasoning step
-        if (thought) {
-          steps.push({
-            thought,
-            action: '',
-            observation: '',
-            timestamp: session.metadata.createdAt,
-            metadata: { messageUuid: msg.uuid },
-          });
-        }
-      } else {
-        for (const tool of toolBlocks) {
-          const t = tool as {
-            type: 'tool_use';
-            id: string;
-            name: string;
-            input: Record<string, unknown>;
-          };
-          const observation = this.findToolResult(
-            session.transcript,
-            t.id,
-          );
-
-          steps.push({
-            thought:
-              steps.length === 0 || thought ? thought : undefined,
-            action: `${t.name}(${JSON.stringify(t.input)})`,
-            observation: observation ?? '',
-            timestamp: session.metadata.createdAt,
-            metadata: {
-              messageUuid: msg.uuid,
-              toolName: t.name,
-              toolUseId: t.id,
-            },
-          });
-        }
-      }
-    }
-
-    return steps;
-  }
-
-  private inferOutcome(session: SessionRecord): Outcome {
-    const strategy = this.options?.outcomeStrategy ?? 'summary';
-
-    if (strategy === 'summary' && session.summary) {
-      const outcome = session.summary.outcome.toLowerCase();
-      const success =
-        !outcome.includes('fail') &&
-        !outcome.includes('error') &&
-        !outcome.includes('unable') &&
-        !outcome.includes('could not');
-      return {
-        success,
-        partialScore: success ? 1.0 : 0.0,
-        verificationDetails: {
-          sessionOutcome: session.summary.outcome,
-          frictionPoints: session.summary.frictionPoints,
-          openItems: session.summary.openItems,
-        },
-      };
-    }
-
-    // Heuristic fallback
-    const hasFiles = session.metadata.filesTouched.length > 0;
-    return {
-      success: hasFiles,
-      partialScore: hasFiles ? 0.7 : 0.3,
-      verificationDetails: { strategy: 'heuristic' },
-    };
-  }
-
-  private inferDomain(session: SessionRecord): string {
-    const files = session.metadata.filesTouched;
-    if (files.some((f) => /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(f)))
-      return 'testing';
-    if (files.some((f) => /\.(ts|tsx)$/.test(f))) return 'typescript';
-    if (files.some((f) => /\.py$/.test(f))) return 'python';
-    if (files.some((f) => /\.go$/.test(f))) return 'go';
-    if (files.some((f) => /\.rs$/.test(f))) return 'rust';
-    return 'code';
-  }
-
-  private getFirstUserMessage(
-    session: SessionRecord,
-  ): string | undefined {
-    const firstUser = session.transcript.find((m) => m.role === 'user');
-    if (!firstUser) return undefined;
-    const textBlock = firstUser.content.find((b) => b.type === 'text');
-    return textBlock
-      ? (textBlock as { type: 'text'; text: string }).text
-      : undefined;
-  }
-
-  private findToolResult(
-    messages: SessionRecord['transcript'],
-    toolUseId: string,
-  ): string | undefined {
-    for (const msg of messages) {
-      if (msg.role !== 'user') continue;
-      for (const block of msg.content) {
-        if (
-          block.type === 'tool_result' &&
-          (block as { toolUseId: string }).toolUseId === toolUseId
-        ) {
-          return (block as { content: string }).content;
-        }
-      }
-    }
-    return undefined;
-  }
-}