jawere 1.4.0 → 1.5.0

package/dist/index.js

@@ -13339,6 +13339,30 @@ var TOOL_DEFS = [
       }
     }
   },
+  {
+    type: "function",
+    function: {
+      name: "diff",
+      description: "Show a git diff of changes. Useful for reviewing what changed before committing. Supports --staged for staged changes, and optional path/file and base ref.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Specific file or directory to diff (optional \u2014 diffs everything if omitted)"
+          },
+          staged: {
+            type: "boolean",
+            description: "Show staged changes (git diff --staged). Default: false (working tree)"
+          },
+          base: {
+            type: "string",
+            description: "Base ref to diff against (e.g. HEAD~1, main). Default: HEAD for staged, working tree otherwise"
+          }
+        }
+      }
+    }
+  },
   {
     type: "function",
     function: {
@@ -13757,6 +13781,14 @@ async function statTool(path, workDir) {
     return `Error: [stat-failed] ${fullPath}: ${err.message}`;
   }
 }
+async function diffTool(path, staged, base, workDir) {
+  const args = ["diff"];
+  if (staged) args.push("--staged");
+  if (base) args.push(base);
+  if (path) args.push("--", path);
+  else args.push("--", ".");
+  return execBash(`git ${args.join(" ")}`, workDir, 30);
+}
 async function executeTool(call, workDir) {
   const { id, function: fn } = call;
   let args;
@@ -13799,6 +13831,14 @@ async function executeTool(call, workDir) {
       case "find":
         result = await findTool(args.pattern, args.path, workDir);
         break;
+      case "diff":
+        result = await diffTool(
+          args.path,
+          args.staged,
+          args.base,
+          workDir
+        );
+        break;
       case "grep":
         result = await grepTool(
           args.pattern,
@@ -14265,13 +14305,14 @@ async function listSessions(convexUrl) {
 
 // src/agent.ts
 var MAX_TURNS = 500;
-var MAX_OUTPUT_TOKENS = 3e5;
+var MAX_OUTPUT_TOKENS = 393216;
 var COL = () => process.stdout.columns || 80;
 var GRUVBOX_GREEN = "\x1B[38;2;184;187;3m";
 var GRUVBOX_GRAY = "\x1B[38;2;146;131;116m";
 var GRUVBOX_RED = "\x1B[38;2;251;73;52m";
 var RESET2 = "\x1B[0m";
 var FILE_TOOLS = /* @__PURE__ */ new Set(["read", "write", "edit", "stat"]);
+var SILENT_TOOLS = /* @__PURE__ */ new Set(["diff"]);
 function toolDetail(name, args) {
   switch (name) {
     case "read": {
@@ -14296,6 +14337,7 @@ function toolDetail(name, args) {
   }
 }
 function displayToolLine(name, args, ok, spin) {
+  if (SILENT_TOOLS.has(name)) return;
   if (spin?.running) {
     spin.stop();
   }
@@ -14463,86 +14505,120 @@ async function runAgent(userMessage, options = {}) {
       return { text: msg2, sessionId, history: messages };
     }
     spin.update("Thinking\u2026");
-    const response = await withRetry(() => {
-      return client.chat.completions.create({
-        model: config.model,
-        messages,
-        tools: TOOL_DEFS,
-        tool_choice: "auto",
-        temperature: 0.2,
-        max_tokens: MAX_OUTPUT_TOKENS,
-        // Enable thinking/reasoning — DeepSeek specific params
-        ...{
-          thinking: { type: "enabled" },
-          reasoning_effort: "max"
-        }
+    let streamedContent = "";
+    const streamedToolCalls = /* @__PURE__ */ new Map();
+    let streamUsage;
+    try {
+      const stream = await withRetry(async () => {
+        return client.chat.completions.create({
+          model: config.model,
+          messages,
+          tools: TOOL_DEFS,
+          tool_choice: "auto",
+          temperature: 0.2,
+          max_tokens: MAX_OUTPUT_TOKENS,
+          stream: true,
+          stream_options: { include_usage: true },
+          // Enable thinking/reasoning — DeepSeek specific params
+          ...{
+            thinking: { type: "enabled" },
+            reasoning_effort: "max"
+          }
+        });
       });
-    }).catch((err) => {
+      for await (const chunk of stream) {
+        if (options.signal?.aborted) break;
+        const delta = chunk.choices?.[0]?.delta;
+        if (!delta) {
+          if (chunk.usage) {
+            streamUsage = {
+              input: chunk.usage.prompt_tokens || 0,
+              output: chunk.usage.completion_tokens || 0,
+              total: chunk.usage.total_tokens || 0
+            };
+          }
+          continue;
+        }
+        if (delta.content) {
+          streamedContent += delta.content;
+        }
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            const idx = tc.index ?? 0;
+            if (!streamedToolCalls.has(idx)) {
+              streamedToolCalls.set(idx, { id: "", name: "", arguments: "" });
+            }
+            const entry = streamedToolCalls.get(idx);
+            if (tc.id) entry.id = tc.id;
+            if (tc.function?.name) entry.name += tc.function.name;
+            if (tc.function?.arguments) entry.arguments += tc.function.arguments;
+          }
+        }
+        spin.update("Thinking\u2026");
+      }
+    } catch (err) {
       if (err.name === "AbortError" || err.name === "Canceled") {
-        return null;
+        spin.stop();
+        const msg2 = "\n[Cancelled by user]";
+        return { text: msg2, sessionId, history: messages };
       }
       throw err;
-    });
-    if (!response) {
+    }
+    if (options.signal?.aborted) {
       spin.stop();
       const msg2 = "\n[Cancelled by user]";
       return { text: msg2, sessionId, history: messages };
     }
-    const choice = response.choices[0];
-    if (!choice) {
-      spin.stop();
-      safeCall(
-        () => appendAssistantMessage(config.convexUrl, sessionId, "(error: no response)", null),
-        "appendAssistantMessage"
-      );
-      return { text: "Error: No response from model.", sessionId, history: messages };
-    }
-    const { message } = choice;
-    const usage = response.usage ? {
-      input: response.usage.prompt_tokens || 0,
-      output: response.usage.completion_tokens || 0,
-      total: response.usage.total_tokens || 0
-    } : void 0;
-    if (message.tool_calls && message.tool_calls.length > 0) {
-      const toolCallsMeta = message.tool_calls.map((tc) => ({
+    const hasToolCalls = streamedToolCalls.size > 0;
+    if (hasToolCalls) {
+      const toolCallArray = Array.from(streamedToolCalls.entries()).sort(([a2], [b2]) => a2 - b2).map(([_2, tc]) => tc);
+      const toolCallsMeta = toolCallArray.map((tc) => ({
         id: tc.id,
-        name: tc.function.name,
-        arguments: tc.function.arguments
+        name: tc.name,
+        arguments: tc.arguments
       }));
       safeCall(
         () => appendAssistantMessage(
           config.convexUrl,
           sessionId,
-          message.content || null,
+          streamedContent || null,
           toolCallsMeta.length > 0 ? toolCallsMeta : null,
-          usage
+          streamUsage
         ),
         "appendAssistantMessage"
       );
+      const openaiToolCalls = toolCallArray.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.name,
+          arguments: tc.arguments
+        }
+      }));
       messages.push({
         role: "assistant",
-        content: message.content || null,
-        tool_calls: message.tool_calls
+        content: streamedContent || null,
+        tool_calls: openaiToolCalls
       });
-      for (const tc of message.tool_calls) {
+      for (const tc of toolCallArray) {
         let args = {};
         try {
-          args = JSON.parse(tc.function.arguments);
+          args = JSON.parse(tc.arguments);
         } catch {
         }
-        spin.update(`Running ${tc.function.name}\u2026`);
+        spin.update(`Running ${tc.name}\u2026`);
         const result = await executeTool(
           {
             id: tc.id,
             function: {
-              name: tc.function.name,
-              arguments: tc.function.arguments
+              name: tc.name,
+              arguments: tc.arguments
             }
           },
           config.workDir
         );
         const ok = !result.content.startsWith("Error");
-        displayToolLine(tc.function.name, args, ok, spin);
+        displayToolLine(tc.name, args, ok, spin);
         messages.push({
           role: "tool",
           tool_call_id: result.tool_call_id,
@@ -14554,7 +14630,7 @@ async function runAgent(userMessage, options = {}) {
             config.convexUrl,
             sessionId,
             result.tool_call_id,
-            tc.function.name,
+            tc.name,
             result.content,
             isError
           ),
@@ -14564,10 +14640,9 @@ async function runAgent(userMessage, options = {}) {
       continue;
     }
     spin.stop();
-    const rawText = message.content || "";
-    const text = stripThinking(rawText) || "(empty response)";
+    const text = stripThinking(streamedContent) || "(empty response)";
     safeCall(
-      () => appendAssistantMessage(config.convexUrl, sessionId, text, null, usage),
+      () => appendAssistantMessage(config.convexUrl, sessionId, text, null, streamUsage),
       "appendAssistantMessage"
     );
     console.log("");
@@ -14871,20 +14946,32 @@ function getProjectInfo(workDir) {
   }
   return { name, version };
 }
-async function scanCodebase(workDir) {
+async function scanCodebase(workDir, onProgress) {
   const codebaseDir = resolve2(workDir, CODEBASE_DIR);
   await mkdir3(codebaseDir, { recursive: true });
+  onProgress?.("listing files");
   const allFiles = await getAllFiles(workDir, workDir);
   const files = allFiles.sort();
+  onProgress?.(`found ${files.length} files`);
+  onProgress?.("building tree");
   const tree = buildTree(files);
+  onProgress?.(`summarizing ${files.length} files`);
   const summaries = {};
-  for (const file of files) {
-    const summary = await summarizeFile(resolve2(workDir, file));
+  let lastReport = 0;
+  for (let i2 = 0; i2 < files.length; i2++) {
+    const summary = await summarizeFile(resolve2(workDir, files[i2]));
     if (summary) {
-      summaries[file] = summary;
+      summaries[files[i2]] = summary;
+    }
+    const now = Date.now();
+    if (i2 - lastReport >= 10 || now - lastReport > 200) {
+      onProgress?.(`summarizing ${i2 + 1}/${files.length}`);
+      lastReport = i2;
     }
   }
+  onProgress?.("reading project info");
   const { name, version } = getProjectInfo(workDir);
+  onProgress?.("hashing files");
   const gitHash = await getGitHash(workDir);
   const checksums = {
     scannedAt: Date.now(),
@@ -14902,9 +14989,12 @@ async function scanCodebase(workDir) {
       }
     }
   }
+  onProgress?.("writing checksums");
   await writeFile3(resolve2(workDir, CHECKSUMS_FILE), JSON.stringify(checksums, null, 2) + "\n", "utf-8");
+  onProgress?.("writing tree.yaml");
   const treeYaml = generateTreeYaml(name, version, tree, summaries);
   await writeFile3(resolve2(workDir, TREE_FILE), treeYaml, "utf-8");
+  onProgress?.("writing meta.json");
   const meta = {
     scannedAt: Date.now(),
     fileCount: files.length,
@@ -14992,11 +15082,18 @@ async function runScanner(workDir, force = false) {
       const meta = JSON.parse(
         await readFile3(resolve2(workDir, META_FILE), "utf-8")
       );
+      process.stderr.write(` (cached)`);
       return { fileCount: meta.fileCount, cached: true };
     } catch {
     }
   }
-  const { fileCount } = await scanCodebase(workDir);
+  const GRAY2 = "\x1B[38;2;146;131;116m";
+  const RESET3 = "\x1B[0m";
+  const { fileCount } = await scanCodebase(workDir, (phase, detail) => {
+    const msg = detail || phase;
+    process.stderr.write(`\r\x1B[K${GRAY2}  scanning: ${msg}${RESET3}`);
+  });
+  process.stderr.write(`\r\x1B[K`);
   return { fileCount, cached: false };
 }
 
@@ -15351,10 +15448,10 @@ async function main() {
   try {
     const scanResult = await runScanner(config.workDir);
     if (scanResult.cached) {
-      process.stderr.write(` ${G_GRAY2}(cached, ${scanResult.fileCount} files)${R3}
+      process.stderr.write(` ${G_GRAY2}(${scanResult.fileCount} files)${R3}
 `);
     } else {
-      process.stderr.write(` ${G_GRAY2}(${scanResult.fileCount} files)${R3}
+      process.stderr.write(`${G_GRAY2}Done \u2014 ${scanResult.fileCount} files indexed${R3}
 `);
     }
   } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jawere",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "type": "module",
   "bin": {
     "jawere": "bin/jawere.js"

package/dist/agent.d.ts

@@ -1,15 +0,0 @@
-import type { ChatCompletionMessageParam } from 'openai/resources/chat/completions';
-export interface AgentOptions {
-    sessionId?: string;
-    title?: string;
-    history?: ChatCompletionMessageParam[];
-    signal?: AbortSignal;
-}
-export interface AgentResult {
-    text: string;
-    sessionId: string;
-    history: ChatCompletionMessageParam[];
-}
-/** Print the assistant's FINAL response — the summary shown when all work is done. */
-export declare function printAssistantResponse(text: string): void;
-export declare function runAgent(userMessage: string, options?: AgentOptions): Promise<AgentResult>;