nairon-bench 0.0.28 → 0.0.30

package/dist/index.js

@@ -14665,13 +14665,14 @@ init_client();
 import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync2 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { join as join7, basename as basename2 } from "node:path";
-async function collectReportData(projectDir, since, until = new Date) {
+async function collectReportData(projectDir, since, until = new Date, harness) {
   const projectName = basename2(projectDir);
-  const [commits, sessions, mcpConfigs] = await Promise.all([
+  const [commits, allSessions, mcpConfigs] = await Promise.all([
     collectGitCommits(projectDir, since, until),
     collectAllSessions(since, until, projectDir),
     collectMCPConfigs()
   ]);
+  const sessions = harness && harness !== "all" ? allSessions.filter((s2) => s2.agent === harness) : allSessions;
   const allPrompts = sessions.flatMap((s2) => s2.prompts);
   const toolUsage = buildToolUsageMap(sessions);
   const stats = calculateStats(sessions, allPrompts);
@@ -14893,7 +14894,128 @@ function parseClaudeTranscript(filePath, fileName) {
   };
 }
 function collectOpenCodeSessions2(openCodeDir, since, until) {
-  return [];
+  const sessions = [];
+  const sessionDir = join7(openCodeDir, "storage", "session");
+  const messageDir = join7(openCodeDir, "storage", "message");
+  const partDir = join7(openCodeDir, "storage", "part");
+  if (!existsSync7(sessionDir))
+    return sessions;
+  try {
+    const projectDirs = readdirSync3(sessionDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join7(sessionDir, d2.name));
+    for (const projectDir of projectDirs) {
+      const sessionFiles = readdirSync3(projectDir).filter((f3) => f3.endsWith(".json"));
+      for (const sessionFile of sessionFiles) {
+        try {
+          const sessionPath = join7(projectDir, sessionFile);
+          const sessionData = JSON.parse(readFileSync6(sessionPath, "utf-8"));
+          const createdAt = new Date(sessionData.time?.created || 0);
+          const updatedAt = new Date(sessionData.time?.updated || sessionData.time?.created || 0);
+          if (updatedAt < since || createdAt > until)
+            continue;
+          const sessionId = sessionData.id;
+          const sessionMsgDir = join7(messageDir, sessionId);
+          const prompts = [];
+          const responses = [];
+          const toolsUsed = new Set;
+          const filesModified = new Set;
+          let totalTokens = 0;
+          let inputTokens = 0;
+          let outputTokens = 0;
+          let model = "unknown";
+          let startTime = createdAt;
+          let endTime = updatedAt;
+          if (existsSync7(sessionMsgDir)) {
+            const msgFiles = readdirSync3(sessionMsgDir).filter((f3) => f3.endsWith(".json")).sort();
+            for (const msgFile of msgFiles) {
+              try {
+                const msgPath = join7(sessionMsgDir, msgFile);
+                const msgData = JSON.parse(readFileSync6(msgPath, "utf-8"));
+                const msgId = msgData.id;
+                if (msgData.model?.modelID) {
+                  model = msgData.model.modelID;
+                }
+                const msgTime = new Date(msgData.time?.created || createdAt);
+                if (msgTime < startTime)
+                  startTime = msgTime;
+                if (msgTime > endTime)
+                  endTime = msgTime;
+                const msgPartDir = join7(partDir, msgId);
+                let messageText = "";
+                if (existsSync7(msgPartDir)) {
+                  const partFiles = readdirSync3(msgPartDir).filter((f3) => f3.endsWith(".json")).sort();
+                  for (const partFile of partFiles) {
+                    try {
+                      const partPath = join7(msgPartDir, partFile);
+                      const partData = JSON.parse(readFileSync6(partPath, "utf-8"));
+                      if (partData.type === "text" && partData.text && !partData.synthetic) {
+                        messageText += partData.text + `
+`;
+                      }
+                      if (partData.type === "tool-invocation" || partData.type === "tool-result") {
+                        const toolName = partData.toolName || partData.name;
+                        if (toolName)
+                          toolsUsed.add(toolName);
+                      }
+                    } catch {}
+                  }
+                }
+                if (msgData.role === "user" && messageText.trim()) {
+                  const prompt2 = analyzePrompt(messageText, sessionId, prompts.length, msgTime);
+                  prompts.push(prompt2);
+                }
+                if (msgData.role === "assistant" && messageText.trim()) {
+                  const response = analyzeResponse(messageText, sessionId, responses.length, prompts[prompts.length - 1]?.id ?? "", msgTime);
+                  responses.push(response);
+                  if (messageText.includes("Write ") || messageText.includes("Created ")) {
+                    const fileMatches = messageText.match(/(?:Write|Created|Updated)\s+(\S+\.\w+)/g);
+                    if (fileMatches) {
+                      fileMatches.forEach((m2) => {
+                        const file = m2.split(/\s+/)[1];
+                        if (file)
+                          filesModified.add(file);
+                      });
+                    }
+                  }
+                }
+                if (msgData.usage) {
+                  totalTokens += msgData.usage.totalTokens || 0;
+                  inputTokens += msgData.usage.inputTokens || 0;
+                  outputTokens += msgData.usage.outputTokens || 0;
+                }
+              } catch {}
+            }
+          }
+          if (prompts.length === 0)
+            continue;
+          const correctionCount = prompts.filter((p) => p.isCorrection).length;
+          const frustrationCount = prompts.filter((p) => p.isFrustrated).length;
+          if (sessionData.summary?.files) {
+            filesModified.add(`${sessionData.summary.files} files changed`);
+          }
+          sessions.push({
+            id: sessionId,
+            agent: "opencode",
+            model,
+            startTime,
+            endTime,
+            durationMinutes: Math.round((endTime.getTime() - startTime.getTime()) / 60000),
+            promptCount: prompts.length,
+            totalTokens,
+            inputTokens,
+            outputTokens,
+            prompts,
+            responses,
+            toolsUsed: Array.from(toolsUsed),
+            filesModified: Array.from(filesModified),
+            hadCompaction: false,
+            correctionCount,
+            frustrationCount
+          });
+        } catch {}
+      }
+    }
+  } catch {}
+  return sessions;
 }
 function analyzePrompt(text, sessionId, index, timestamp) {
   const lower = text.toLowerCase();
@@ -18360,8 +18482,8 @@ function renderGitBlameMarkdown(analysis) {
 }
 
 // src/lib/hackathon-report.ts
-async function generateHackathonReport(projectDir, since, until = new Date) {
-  const data = await collectReportData(projectDir, since, until);
+async function generateHackathonReport(projectDir, since, until = new Date, harness) {
+  const data = await collectReportData(projectDir, since, until, harness);
   const sdlcAnalysis = analyzeSDLC(data);
   const promptAnalysis = analyzePrompts(data);
   const effectivenessProfile = analyzeEffectiveness(data);
@@ -18873,6 +18995,10 @@ var reportCommand = defineCommand2({
       description: "Generate hackathon submission report (last 48 hours)",
       default: false
     },
+    harness: {
+      type: "string",
+      description: "AI harness to analyze: claude-code, opencode, cursor, or all"
+    },
     since: {
       type: "string",
       description: "Time range: 48h, 7d, 30d, or ISO date"
@@ -18933,6 +19059,16 @@ var reportCommand = defineCommand2({
           month: "30d"
         };
         args.since = sinceMap[choice];
+        const harness = await consola.prompt("Which AI harness did you use?", {
+          type: "select",
+          options: [
+            { value: "claude-code", label: "Claude Code" },
+            { value: "opencode", label: "OpenCode" },
+            { value: "cursor", label: "Cursor" },
+            { value: "all", label: "All (combine sessions from all harnesses)" }
+          ]
+        });
+        args.harness = harness;
         const format2 = await consola.prompt("Output format?", {
           type: "select",
           options: [
@@ -18983,12 +19119,25 @@ var reportCommand = defineCommand2({
 });
 async function runHackathonReport(args) {
   const projectDir = process.cwd();
+  let harness = args.harness;
+  if (!harness) {
+    harness = await consola.prompt("Which AI harness did you use?", {
+      type: "select",
+      options: [
+        { value: "claude-code", label: "Claude Code" },
+        { value: "opencode", label: "OpenCode" },
+        { value: "cursor", label: "Cursor" },
+        { value: "all", label: "All (combine sessions from all harnesses)" }
+      ]
+    });
+  }
   const since = parseSince2(args.since || (args.hackathon ? "48h" : "7d"));
   const until = new Date;
   const hoursAgo = Math.round((until.getTime() - since.getTime()) / (1000 * 60 * 60));
-  consola.start(`Generating AI-nativeness report for last ${hoursAgo} hours...`);
+  const harnessLabel = harness === "all" ? "all harnesses" : harness;
+  consola.start(`Generating AI-nativeness report for ${harnessLabel} (last ${hoursAgo} hours)...`);
   try {
-    const report = await generateHackathonReport(projectDir, since, until);
+    const report = await generateHackathonReport(projectDir, since, until, harness);
     if (args.publish) {
       await publishReport(report);
       return;
@@ -22848,7 +22997,7 @@ var setupCommand = defineCommand2({
 // package.json
 var package_default = {
   name: "nairon-bench",
-  version: "0.0.28",
+  version: "0.0.30",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nairon-bench",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "AI workflow benchmarking CLI",
   "type": "module",
   "bin": {