cognitive-core 0.1.0 → 0.2.0

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

@@ -0,0 +1,403 @@
+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

@@ -0,0 +1,251 @@
+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;
+  }
+}