@hongymagic/q 0.3.2 → 0.5.0

package/README.md

@@ -35,7 +35,6 @@ export ANTHROPIC_API_KEY="your-key-here"
 
 ```bash
 q how do I restart docker
-q --stream explain git rebase
 q --copy what is a kubernetes pod
 ```
 
@@ -45,9 +44,7 @@ q --copy what is a kubernetes pod
 |--------|-------------|
 | `-p, --provider <name>` | Override the default provider |
 | `-m, --model <id>` | Override the default model |
-| `--stream` | Stream response as it arrives |
 | `--copy` | Copy answer to clipboard |
-| `--json` | Output structured JSON |
 | `-h, --help` | Show help message |
 
 ### Commands

package/dist/q.js

@@ -13301,6 +13301,73 @@ var clipboardy_default = clipboard7;
 
 // src/args.ts
 import { parseArgs } from "node:util";
+// package.json
+var package_default = {
+  name: "@hongymagic/q",
+  version: "0.5.0",
+  description: "Quick AI answers from the command line",
+  main: "dist/q.js",
+  type: "module",
+  bin: {
+    q: "dist/q.js"
+  },
+  files: [
+    "dist"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/hongymagic/q.git"
+  },
+  homepage: "https://github.com/hongymagic/q#readme",
+  bugs: {
+    url: "https://github.com/hongymagic/q/issues"
+  },
+  keywords: [
+    "cli",
+    "ai",
+    "llm",
+    "terminal",
+    "assistant"
+  ],
+  author: "hongymagic <packages@hon.gy>",
+  license: "MIT",
+  engines: {
+    node: ">=24"
+  },
+  scripts: {
+    start: "bun run src/cli.ts",
+    test: "vitest run",
+    "test:watch": "vitest",
+    typecheck: "tsc --noEmit",
+    lint: "biome check .",
+    fix: "biome check --write --unsafe .",
+    build: "bun build --compile --minify --sourcemap ./src/cli.ts --outfile dist/q",
+    "build:npm": "bun build ./src/cli.ts --outfile dist/q.js --target node",
+    "build:all": "bun run build:darwin-arm64 && bun run build:darwin-x64 && bun run build:linux-x64 && bun run build:linux-arm64 && bun run build:windows-x64",
+    "build:darwin-arm64": "bun build --compile --minify --target=bun-darwin-arm64 ./src/cli.ts --outfile dist/q-darwin-arm64",
+    "build:darwin-x64": "bun build --compile --minify --target=bun-darwin-x64 ./src/cli.ts --outfile dist/q-darwin-x64",
+    "build:linux-x64": "bun build --compile --minify --target=bun-linux-x64 ./src/cli.ts --outfile dist/q-linux-x64",
+    "build:linux-arm64": "bun build --compile --minify --target=bun-linux-arm64 ./src/cli.ts --outfile dist/q-linux-arm64",
+    "build:windows-x64": "bun build --compile --minify --target=bun-windows-x64 ./src/cli.ts --outfile dist/q-windows-x64.exe"
+  },
+  dependencies: {
+    ai: "^6.0.97",
+    "@ai-sdk/openai": "^3.0.31",
+    "@ai-sdk/anthropic": "^3.0.46",
+    "@ai-sdk/openai-compatible": "^2.0.30",
+    "ollama-ai-provider-v2": "^3.3.1",
+    zod: "^4.3.6",
+    clipboardy: "^5.3.0",
+    "@t3-oss/env-core": "^0.13.10"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.4.4",
+    "@types/bun": "latest",
+    lefthook: "^2.1.1",
+    typescript: "^5.9.3",
+    vitest: "^4.0.18"
+  }
+};
 
 // src/errors.ts
 class QError extends Error {
@@ -13396,9 +13463,7 @@ USAGE:
 OPTIONS:
   -p, --provider <name>        Override the default provider
   -m, --model <id>             Override the default model
-  --stream                     Stream response tokens as they arrive
   --copy                       Copy answer to clipboard
-  --json                       Output structured JSON
   --debug                      Enable debug logging to stderr
   -h, --help                   Show this help message
   -v, --version                Show version
@@ -13415,20 +13480,17 @@ CONFIG:
 
 EXAMPLES:
   q how do I restart docker
-  q --stream explain git rebase
   q -p openai --model gpt-4o what is recursion
   q config init
 `;
-var VERSION = "0.3.1";
+var VERSION = package_default.version;
 function parseCliArgs(argv = Bun.argv.slice(2)) {
   const { values, positionals } = parseArgs({
     args: argv,
     options: {
       provider: { type: "string", short: "p" },
       model: { type: "string", short: "m" },
-      stream: { type: "boolean", default: false },
       copy: { type: "boolean", default: false },
-      json: { type: "boolean", default: false },
       debug: { type: "boolean", default: false },
       help: { type: "boolean", short: "h", default: false },
       version: { type: "boolean", short: "v", default: false }
@@ -13439,9 +13501,7 @@ function parseCliArgs(argv = Bun.argv.slice(2)) {
   const options = {
     provider: values.provider,
     model: values.model,
-    stream: values.stream ?? false,
     copy: values.copy ?? false,
-    json: values.json ?? false,
     debug: values.debug ?? false,
     help: values.help ?? false,
     version: values.version ?? false
@@ -27462,19 +27522,6 @@ function logDebug2(message, debug) {
   }
 }
 
-// src/output.ts
-function formatOutput(options) {
-  if (options.json) {
-    const output = {
-      text: options.text,
-      provider: options.providerName,
-      model: options.modelId
-    };
-    return JSON.stringify(output, null, 2);
-  }
-  return options.text;
-}
-
 // src/env-info.ts
 import * as os3 from "node:os";
 function getEnvironmentInfo2() {
@@ -49525,18 +49572,6 @@ async function executeToolCall({
     }
   });
 }
-function extractReasoningContent(content) {
-  const parts = content.filter((content2) => content2.type === "reasoning");
-  return parts.length === 0 ? undefined : parts.map((content2) => content2.text).join(`
-`);
-}
-function extractTextContent(content) {
-  const parts = content.filter((content2) => content2.type === "text");
-  if (parts.length === 0) {
-    return;
-  }
-  return parts.map((content2) => content2.text).join("");
-}
 var DefaultGeneratedFile = class {
   constructor({
     data,
@@ -50574,763 +50609,6 @@ var originalGenerateId = createIdGenerator({
   prefix: "aitxt",
   size: 24
 });
-async function generateText({
-  model: modelArg,
-  tools,
-  toolChoice,
-  system,
-  prompt,
-  messages,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  timeout,
-  headers,
-  stopWhen = stepCountIs(1),
-  experimental_output,
-  output = experimental_output,
-  experimental_telemetry: telemetry,
-  providerOptions,
-  experimental_activeTools,
-  activeTools = experimental_activeTools,
-  experimental_prepareStep,
-  prepareStep = experimental_prepareStep,
-  experimental_repairToolCall: repairToolCall,
-  experimental_download: download2,
-  experimental_context,
-  experimental_include: include,
-  _internal: { generateId: generateId2 = originalGenerateId } = {},
-  experimental_onStart: onStart,
-  experimental_onStepStart: onStepStart,
-  experimental_onToolCallStart: onToolCallStart,
-  experimental_onToolCallFinish: onToolCallFinish,
-  onStepFinish,
-  onFinish,
-  ...settings
-}) {
-  const model = resolveLanguageModel(modelArg);
-  const stopConditions = asArray(stopWhen);
-  const totalTimeoutMs = getTotalTimeoutMs(timeout);
-  const stepTimeoutMs = getStepTimeoutMs(timeout);
-  const stepAbortController = stepTimeoutMs != null ? new AbortController : undefined;
-  const mergedAbortSignal = mergeAbortSignals(abortSignal, totalTimeoutMs != null ? AbortSignal.timeout(totalTimeoutMs) : undefined, stepAbortController == null ? undefined : stepAbortController.signal);
-  const { maxRetries, retry } = prepareRetries({
-    maxRetries: maxRetriesArg,
-    abortSignal: mergedAbortSignal
-  });
-  const callSettings = prepareCallSettings(settings);
-  const headersWithUserAgent = withUserAgentSuffix(headers != null ? headers : {}, `ai/${VERSION7}`);
-  const baseTelemetryAttributes = getBaseTelemetryAttributes({
-    model,
-    telemetry,
-    headers: headersWithUserAgent,
-    settings: { ...callSettings, maxRetries }
-  });
-  const modelInfo = { provider: model.provider, modelId: model.modelId };
-  const initialPrompt = await standardizePrompt({
-    system,
-    prompt,
-    messages
-  });
-  try {
-    await (onStart == null ? undefined : onStart({
-      model: modelInfo,
-      system,
-      prompt,
-      messages,
-      tools,
-      toolChoice,
-      activeTools,
-      maxOutputTokens: callSettings.maxOutputTokens,
-      temperature: callSettings.temperature,
-      topP: callSettings.topP,
-      topK: callSettings.topK,
-      presencePenalty: callSettings.presencePenalty,
-      frequencyPenalty: callSettings.frequencyPenalty,
-      stopSequences: callSettings.stopSequences,
-      seed: callSettings.seed,
-      maxRetries,
-      timeout,
-      headers,
-      providerOptions,
-      stopWhen,
-      output,
-      abortSignal,
-      include,
-      functionId: telemetry == null ? undefined : telemetry.functionId,
-      metadata: telemetry == null ? undefined : telemetry.metadata,
-      experimental_context
-    }));
-  } catch (_ignored) {}
-  const tracer = getTracer(telemetry);
-  try {
-    return await recordSpan({
-      name: "ai.generateText",
-      attributes: selectTelemetryAttributes({
-        telemetry,
-        attributes: {
-          ...assembleOperationName({
-            operationId: "ai.generateText",
-            telemetry
-          }),
-          ...baseTelemetryAttributes,
-          "ai.model.provider": model.provider,
-          "ai.model.id": model.modelId,
-          "ai.prompt": {
-            input: () => JSON.stringify({ system, prompt, messages })
-          }
-        }
-      }),
-      tracer,
-      fn: async (span) => {
-        var _a21, _b16, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
-        const initialMessages = initialPrompt.messages;
-        const responseMessages = [];
-        const { approvedToolApprovals, deniedToolApprovals } = collectToolApprovals({ messages: initialMessages });
-        const localApprovedToolApprovals = approvedToolApprovals.filter((toolApproval) => !toolApproval.toolCall.providerExecuted);
-        if (deniedToolApprovals.length > 0 || localApprovedToolApprovals.length > 0) {
-          const toolOutputs = await executeTools({
-            toolCalls: localApprovedToolApprovals.map((toolApproval) => toolApproval.toolCall),
-            tools,
-            tracer,
-            telemetry,
-            messages: initialMessages,
-            abortSignal: mergedAbortSignal,
-            experimental_context,
-            stepNumber: 0,
-            model: modelInfo,
-            onToolCallStart,
-            onToolCallFinish
-          });
-          const toolContent = [];
-          for (const output2 of toolOutputs) {
-            const modelOutput = await createToolModelOutput({
-              toolCallId: output2.toolCallId,
-              input: output2.input,
-              tool: tools == null ? undefined : tools[output2.toolName],
-              output: output2.type === "tool-result" ? output2.output : output2.error,
-              errorMode: output2.type === "tool-error" ? "json" : "none"
-            });
-            toolContent.push({
-              type: "tool-result",
-              toolCallId: output2.toolCallId,
-              toolName: output2.toolName,
-              output: modelOutput
-            });
-          }
-          for (const toolApproval of deniedToolApprovals) {
-            toolContent.push({
-              type: "tool-result",
-              toolCallId: toolApproval.toolCall.toolCallId,
-              toolName: toolApproval.toolCall.toolName,
-              output: {
-                type: "execution-denied",
-                reason: toolApproval.approvalResponse.reason,
-                ...toolApproval.toolCall.providerExecuted && {
-                  providerOptions: {
-                    openai: {
-                      approvalId: toolApproval.approvalResponse.approvalId
-                    }
-                  }
-                }
-              }
-            });
-          }
-          responseMessages.push({
-            role: "tool",
-            content: toolContent
-          });
-        }
-        const providerExecutedToolApprovals = [
-          ...approvedToolApprovals,
-          ...deniedToolApprovals
-        ].filter((toolApproval) => toolApproval.toolCall.providerExecuted);
-        if (providerExecutedToolApprovals.length > 0) {
-          responseMessages.push({
-            role: "tool",
-            content: providerExecutedToolApprovals.map((toolApproval) => ({
-              type: "tool-approval-response",
-              approvalId: toolApproval.approvalResponse.approvalId,
-              approved: toolApproval.approvalResponse.approved,
-              reason: toolApproval.approvalResponse.reason,
-              providerExecuted: true
-            }))
-          });
-        }
-        const callSettings2 = prepareCallSettings(settings);
-        let currentModelResponse;
-        let clientToolCalls = [];
-        let clientToolOutputs = [];
-        const steps = [];
-        const pendingDeferredToolCalls = /* @__PURE__ */ new Map;
-        do {
-          const stepTimeoutId = stepTimeoutMs != null ? setTimeout(() => stepAbortController.abort(), stepTimeoutMs) : undefined;
-          try {
-            const stepInputMessages = [...initialMessages, ...responseMessages];
-            const prepareStepResult = await (prepareStep == null ? undefined : prepareStep({
-              model,
-              steps,
-              stepNumber: steps.length,
-              messages: stepInputMessages,
-              experimental_context
-            }));
-            const stepModel = resolveLanguageModel((_a21 = prepareStepResult == null ? undefined : prepareStepResult.model) != null ? _a21 : model);
-            const stepModelInfo = {
-              provider: stepModel.provider,
-              modelId: stepModel.modelId
-            };
-            const promptMessages = await convertToLanguageModelPrompt({
-              prompt: {
-                system: (_b16 = prepareStepResult == null ? undefined : prepareStepResult.system) != null ? _b16 : initialPrompt.system,
-                messages: (_c = prepareStepResult == null ? undefined : prepareStepResult.messages) != null ? _c : stepInputMessages
-              },
-              supportedUrls: await stepModel.supportedUrls,
-              download: download2
-            });
-            experimental_context = (_d = prepareStepResult == null ? undefined : prepareStepResult.experimental_context) != null ? _d : experimental_context;
-            const stepActiveTools = (_e = prepareStepResult == null ? undefined : prepareStepResult.activeTools) != null ? _e : activeTools;
-            const { toolChoice: stepToolChoice, tools: stepTools } = await prepareToolsAndToolChoice({
-              tools,
-              toolChoice: (_f = prepareStepResult == null ? undefined : prepareStepResult.toolChoice) != null ? _f : toolChoice,
-              activeTools: stepActiveTools
-            });
-            const stepMessages = (_g = prepareStepResult == null ? undefined : prepareStepResult.messages) != null ? _g : stepInputMessages;
-            const stepSystem = (_h = prepareStepResult == null ? undefined : prepareStepResult.system) != null ? _h : initialPrompt.system;
-            const stepProviderOptions = mergeObjects(providerOptions, prepareStepResult == null ? undefined : prepareStepResult.providerOptions);
-            try {
-              await (onStepStart == null ? undefined : onStepStart({
-                stepNumber: steps.length,
-                model: stepModelInfo,
-                system: stepSystem,
-                messages: stepMessages,
-                tools,
-                toolChoice: stepToolChoice,
-                activeTools: stepActiveTools,
-                steps: [...steps],
-                providerOptions: stepProviderOptions,
-                timeout,
-                headers,
-                stopWhen,
-                output,
-                abortSignal,
-                include,
-                functionId: telemetry == null ? undefined : telemetry.functionId,
-                metadata: telemetry == null ? undefined : telemetry.metadata,
-                experimental_context
-              }));
-            } catch (_ignored) {}
-            currentModelResponse = await retry(() => {
-              var _a222;
-              return recordSpan({
-                name: "ai.generateText.doGenerate",
-                attributes: selectTelemetryAttributes({
-                  telemetry,
-                  attributes: {
-                    ...assembleOperationName({
-                      operationId: "ai.generateText.doGenerate",
-                      telemetry
-                    }),
-                    ...baseTelemetryAttributes,
-                    "ai.model.provider": stepModel.provider,
-                    "ai.model.id": stepModel.modelId,
-                    "ai.prompt.messages": {
-                      input: () => stringifyForTelemetry(promptMessages)
-                    },
-                    "ai.prompt.tools": {
-                      input: () => stepTools == null ? undefined : stepTools.map((tool2) => JSON.stringify(tool2))
-                    },
-                    "ai.prompt.toolChoice": {
-                      input: () => stepToolChoice != null ? JSON.stringify(stepToolChoice) : undefined
-                    },
-                    "gen_ai.system": stepModel.provider,
-                    "gen_ai.request.model": stepModel.modelId,
-                    "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
-                    "gen_ai.request.max_tokens": settings.maxOutputTokens,
-                    "gen_ai.request.presence_penalty": settings.presencePenalty,
-                    "gen_ai.request.stop_sequences": settings.stopSequences,
-                    "gen_ai.request.temperature": (_a222 = settings.temperature) != null ? _a222 : undefined,
-                    "gen_ai.request.top_k": settings.topK,
-                    "gen_ai.request.top_p": settings.topP
-                  }
-                }),
-                tracer,
-                fn: async (span2) => {
-                  var _a232, _b23, _c2, _d2, _e2, _f2, _g2, _h2;
-                  const result = await stepModel.doGenerate({
-                    ...callSettings2,
-                    tools: stepTools,
-                    toolChoice: stepToolChoice,
-                    responseFormat: await (output == null ? undefined : output.responseFormat),
-                    prompt: promptMessages,
-                    providerOptions: stepProviderOptions,
-                    abortSignal: mergedAbortSignal,
-                    headers: headersWithUserAgent
-                  });
-                  const responseData = {
-                    id: (_b23 = (_a232 = result.response) == null ? undefined : _a232.id) != null ? _b23 : generateId2(),
-                    timestamp: (_d2 = (_c2 = result.response) == null ? undefined : _c2.timestamp) != null ? _d2 : /* @__PURE__ */ new Date,
-                    modelId: (_f2 = (_e2 = result.response) == null ? undefined : _e2.modelId) != null ? _f2 : stepModel.modelId,
-                    headers: (_g2 = result.response) == null ? undefined : _g2.headers,
-                    body: (_h2 = result.response) == null ? undefined : _h2.body
-                  };
-                  span2.setAttributes(await selectTelemetryAttributes({
-                    telemetry,
-                    attributes: {
-                      "ai.response.finishReason": result.finishReason.unified,
-                      "ai.response.text": {
-                        output: () => extractTextContent(result.content)
-                      },
-                      "ai.response.reasoning": {
-                        output: () => extractReasoningContent(result.content)
-                      },
-                      "ai.response.toolCalls": {
-                        output: () => {
-                          const toolCalls = asToolCalls(result.content);
-                          return toolCalls == null ? undefined : JSON.stringify(toolCalls);
-                        }
-                      },
-                      "ai.response.id": responseData.id,
-                      "ai.response.model": responseData.modelId,
-                      "ai.response.timestamp": responseData.timestamp.toISOString(),
-                      "ai.response.providerMetadata": JSON.stringify(result.providerMetadata),
-                      "ai.usage.promptTokens": result.usage.inputTokens.total,
-                      "ai.usage.completionTokens": result.usage.outputTokens.total,
-                      "gen_ai.response.finish_reasons": [
-                        result.finishReason.unified
-                      ],
-                      "gen_ai.response.id": responseData.id,
-                      "gen_ai.response.model": responseData.modelId,
-                      "gen_ai.usage.input_tokens": result.usage.inputTokens.total,
-                      "gen_ai.usage.output_tokens": result.usage.outputTokens.total
-                    }
-                  }));
-                  return { ...result, response: responseData };
-                }
-              });
-            });
-            const stepToolCalls = await Promise.all(currentModelResponse.content.filter((part) => part.type === "tool-call").map((toolCall) => parseToolCall({
-              toolCall,
-              tools,
-              repairToolCall,
-              system,
-              messages: stepInputMessages
-            })));
-            const toolApprovalRequests = {};
-            for (const toolCall of stepToolCalls) {
-              if (toolCall.invalid) {
-                continue;
-              }
-              const tool2 = tools == null ? undefined : tools[toolCall.toolName];
-              if (tool2 == null) {
-                continue;
-              }
-              if ((tool2 == null ? undefined : tool2.onInputAvailable) != null) {
-                await tool2.onInputAvailable({
-                  input: toolCall.input,
-                  toolCallId: toolCall.toolCallId,
-                  messages: stepInputMessages,
-                  abortSignal: mergedAbortSignal,
-                  experimental_context
-                });
-              }
-              if (await isApprovalNeeded({
-                tool: tool2,
-                toolCall,
-                messages: stepInputMessages,
-                experimental_context
-              })) {
-                toolApprovalRequests[toolCall.toolCallId] = {
-                  type: "tool-approval-request",
-                  approvalId: generateId2(),
-                  toolCall
-                };
-              }
-            }
-            const invalidToolCalls = stepToolCalls.filter((toolCall) => toolCall.invalid && toolCall.dynamic);
-            clientToolOutputs = [];
-            for (const toolCall of invalidToolCalls) {
-              clientToolOutputs.push({
-                type: "tool-error",
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
-                input: toolCall.input,
-                error: getErrorMessage2(toolCall.error),
-                dynamic: true
-              });
-            }
-            clientToolCalls = stepToolCalls.filter((toolCall) => !toolCall.providerExecuted);
-            if (tools != null) {
-              clientToolOutputs.push(...await executeTools({
-                toolCalls: clientToolCalls.filter((toolCall) => !toolCall.invalid && toolApprovalRequests[toolCall.toolCallId] == null),
-                tools,
-                tracer,
-                telemetry,
-                messages: stepInputMessages,
-                abortSignal: mergedAbortSignal,
-                experimental_context,
-                stepNumber: steps.length,
-                model: stepModelInfo,
-                onToolCallStart,
-                onToolCallFinish
-              }));
-            }
-            for (const toolCall of stepToolCalls) {
-              if (!toolCall.providerExecuted)
-                continue;
-              const tool2 = tools == null ? undefined : tools[toolCall.toolName];
-              if ((tool2 == null ? undefined : tool2.type) === "provider" && tool2.supportsDeferredResults) {
-                const hasResultInResponse = currentModelResponse.content.some((part) => part.type === "tool-result" && part.toolCallId === toolCall.toolCallId);
-                if (!hasResultInResponse) {
-                  pendingDeferredToolCalls.set(toolCall.toolCallId, {
-                    toolName: toolCall.toolName
-                  });
-                }
-              }
-            }
-            for (const part of currentModelResponse.content) {
-              if (part.type === "tool-result") {
-                pendingDeferredToolCalls.delete(part.toolCallId);
-              }
-            }
-            const stepContent = asContent({
-              content: currentModelResponse.content,
-              toolCalls: stepToolCalls,
-              toolOutputs: clientToolOutputs,
-              toolApprovalRequests: Object.values(toolApprovalRequests),
-              tools
-            });
-            responseMessages.push(...await toResponseMessages({
-              content: stepContent,
-              tools
-            }));
-            const stepRequest = ((_i = include == null ? undefined : include.requestBody) != null ? _i : true) ? (_j = currentModelResponse.request) != null ? _j : {} : { ...currentModelResponse.request, body: undefined };
-            const stepResponse = {
-              ...currentModelResponse.response,
-              messages: structuredClone(responseMessages),
-              body: ((_k = include == null ? undefined : include.responseBody) != null ? _k : true) ? (_l = currentModelResponse.response) == null ? undefined : _l.body : undefined
-            };
-            const stepNumber = steps.length;
-            const currentStepResult = new DefaultStepResult({
-              stepNumber,
-              model: stepModelInfo,
-              functionId: telemetry == null ? undefined : telemetry.functionId,
-              metadata: telemetry == null ? undefined : telemetry.metadata,
-              experimental_context,
-              content: stepContent,
-              finishReason: currentModelResponse.finishReason.unified,
-              rawFinishReason: currentModelResponse.finishReason.raw,
-              usage: asLanguageModelUsage(currentModelResponse.usage),
-              warnings: currentModelResponse.warnings,
-              providerMetadata: currentModelResponse.providerMetadata,
-              request: stepRequest,
-              response: stepResponse
-            });
-            logWarnings({
-              warnings: (_m = currentModelResponse.warnings) != null ? _m : [],
-              provider: stepModelInfo.provider,
-              model: stepModelInfo.modelId
-            });
-            steps.push(currentStepResult);
-            await (onStepFinish == null ? undefined : onStepFinish(currentStepResult));
-          } finally {
-            if (stepTimeoutId != null) {
-              clearTimeout(stepTimeoutId);
-            }
-          }
-        } while ((clientToolCalls.length > 0 && clientToolOutputs.length === clientToolCalls.length || pendingDeferredToolCalls.size > 0) && !await isStopConditionMet({ stopConditions, steps }));
-        span.setAttributes(await selectTelemetryAttributes({
-          telemetry,
-          attributes: {
-            "ai.response.finishReason": currentModelResponse.finishReason.unified,
-            "ai.response.text": {
-              output: () => extractTextContent(currentModelResponse.content)
-            },
-            "ai.response.reasoning": {
-              output: () => extractReasoningContent(currentModelResponse.content)
-            },
-            "ai.response.toolCalls": {
-              output: () => {
-                const toolCalls = asToolCalls(currentModelResponse.content);
-                return toolCalls == null ? undefined : JSON.stringify(toolCalls);
-              }
-            },
-            "ai.response.providerMetadata": JSON.stringify(currentModelResponse.providerMetadata),
-            "ai.usage.promptTokens": currentModelResponse.usage.inputTokens.total,
-            "ai.usage.completionTokens": currentModelResponse.usage.outputTokens.total
-          }
-        }));
-        const lastStep = steps[steps.length - 1];
-        const totalUsage = steps.reduce((totalUsage2, step) => {
-          return addLanguageModelUsage(totalUsage2, step.usage);
-        }, {
-          inputTokens: undefined,
-          outputTokens: undefined,
-          totalTokens: undefined,
-          reasoningTokens: undefined,
-          cachedInputTokens: undefined
-        });
-        await (onFinish == null ? undefined : onFinish({
-          stepNumber: lastStep.stepNumber,
-          model: lastStep.model,
-          functionId: lastStep.functionId,
-          metadata: lastStep.metadata,
-          experimental_context: lastStep.experimental_context,
-          finishReason: lastStep.finishReason,
-          rawFinishReason: lastStep.rawFinishReason,
-          usage: lastStep.usage,
-          content: lastStep.content,
-          text: lastStep.text,
-          reasoningText: lastStep.reasoningText,
-          reasoning: lastStep.reasoning,
-          files: lastStep.files,
-          sources: lastStep.sources,
-          toolCalls: lastStep.toolCalls,
-          staticToolCalls: lastStep.staticToolCalls,
-          dynamicToolCalls: lastStep.dynamicToolCalls,
-          toolResults: lastStep.toolResults,
-          staticToolResults: lastStep.staticToolResults,
-          dynamicToolResults: lastStep.dynamicToolResults,
-          request: lastStep.request,
-          response: lastStep.response,
-          warnings: lastStep.warnings,
-          providerMetadata: lastStep.providerMetadata,
-          steps,
-          totalUsage
-        }));
-        let resolvedOutput;
-        if (lastStep.finishReason === "stop") {
-          const outputSpecification = output != null ? output : text();
-          resolvedOutput = await outputSpecification.parseCompleteOutput({ text: lastStep.text }, {
-            response: lastStep.response,
-            usage: lastStep.usage,
-            finishReason: lastStep.finishReason
-          });
-        }
-        return new DefaultGenerateTextResult({
-          steps,
-          totalUsage,
-          output: resolvedOutput
-        });
-      }
-    });
-  } catch (error48) {
-    throw wrapGatewayError(error48);
-  }
-}
-async function executeTools({
-  toolCalls,
-  tools,
-  tracer,
-  telemetry,
-  messages,
-  abortSignal,
-  experimental_context,
-  stepNumber,
-  model,
-  onToolCallStart,
-  onToolCallFinish
-}) {
-  const toolOutputs = await Promise.all(toolCalls.map(async (toolCall) => executeToolCall({
-    toolCall,
-    tools,
-    tracer,
-    telemetry,
-    messages,
-    abortSignal,
-    experimental_context,
-    stepNumber,
-    model,
-    onToolCallStart,
-    onToolCallFinish
-  })));
-  return toolOutputs.filter((output) => output != null);
-}
-var DefaultGenerateTextResult = class {
-  constructor(options) {
-    this.steps = options.steps;
-    this._output = options.output;
-    this.totalUsage = options.totalUsage;
-  }
-  get finalStep() {
-    return this.steps[this.steps.length - 1];
-  }
-  get content() {
-    return this.finalStep.content;
-  }
-  get text() {
-    return this.finalStep.text;
-  }
-  get files() {
-    return this.finalStep.files;
-  }
-  get reasoningText() {
-    return this.finalStep.reasoningText;
-  }
-  get reasoning() {
-    return this.finalStep.reasoning;
-  }
-  get toolCalls() {
-    return this.finalStep.toolCalls;
-  }
-  get staticToolCalls() {
-    return this.finalStep.staticToolCalls;
-  }
-  get dynamicToolCalls() {
-    return this.finalStep.dynamicToolCalls;
-  }
-  get toolResults() {
-    return this.finalStep.toolResults;
-  }
-  get staticToolResults() {
-    return this.finalStep.staticToolResults;
-  }
-  get dynamicToolResults() {
-    return this.finalStep.dynamicToolResults;
-  }
-  get sources() {
-    return this.finalStep.sources;
-  }
-  get finishReason() {
-    return this.finalStep.finishReason;
-  }
-  get rawFinishReason() {
-    return this.finalStep.rawFinishReason;
-  }
-  get warnings() {
-    return this.finalStep.warnings;
-  }
-  get providerMetadata() {
-    return this.finalStep.providerMetadata;
-  }
-  get response() {
-    return this.finalStep.response;
-  }
-  get request() {
-    return this.finalStep.request;
-  }
-  get usage() {
-    return this.finalStep.usage;
-  }
-  get experimental_output() {
-    return this.output;
-  }
-  get output() {
-    if (this._output == null) {
-      throw new NoOutputGeneratedError;
-    }
-    return this._output;
-  }
-};
-function asToolCalls(content) {
-  const parts = content.filter((part) => part.type === "tool-call");
-  if (parts.length === 0) {
-    return;
-  }
-  return parts.map((toolCall) => ({
-    toolCallId: toolCall.toolCallId,
-    toolName: toolCall.toolName,
-    input: toolCall.input
-  }));
-}
-function asContent({
-  content,
-  toolCalls,
-  toolOutputs,
-  toolApprovalRequests,
-  tools
-}) {
-  const contentParts = [];
-  for (const part of content) {
-    switch (part.type) {
-      case "text":
-      case "reasoning":
-      case "source":
-        contentParts.push(part);
-        break;
-      case "file": {
-        contentParts.push({
-          type: "file",
-          file: new DefaultGeneratedFile(part),
-          ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
-        });
-        break;
-      }
-      case "tool-call": {
-        contentParts.push(toolCalls.find((toolCall) => toolCall.toolCallId === part.toolCallId));
-        break;
-      }
-      case "tool-result": {
-        const toolCall = toolCalls.find((toolCall2) => toolCall2.toolCallId === part.toolCallId);
-        if (toolCall == null) {
-          const tool2 = tools == null ? undefined : tools[part.toolName];
-          const supportsDeferredResults = (tool2 == null ? undefined : tool2.type) === "provider" && tool2.supportsDeferredResults;
-          if (!supportsDeferredResults) {
-            throw new Error(`Tool call ${part.toolCallId} not found.`);
-          }
-          if (part.isError) {
-            contentParts.push({
-              type: "tool-error",
-              toolCallId: part.toolCallId,
-              toolName: part.toolName,
-              input: undefined,
-              error: part.result,
-              providerExecuted: true,
-              dynamic: part.dynamic
-            });
-          } else {
-            contentParts.push({
-              type: "tool-result",
-              toolCallId: part.toolCallId,
-              toolName: part.toolName,
-              input: undefined,
-              output: part.result,
-              providerExecuted: true,
-              dynamic: part.dynamic
-            });
-          }
-          break;
-        }
-        if (part.isError) {
-          contentParts.push({
-            type: "tool-error",
-            toolCallId: part.toolCallId,
-            toolName: part.toolName,
-            input: toolCall.input,
-            error: part.result,
-            providerExecuted: true,
-            dynamic: toolCall.dynamic
-          });
-        } else {
-          contentParts.push({
-            type: "tool-result",
-            toolCallId: part.toolCallId,
-            toolName: part.toolName,
-            input: toolCall.input,
-            output: part.result,
-            providerExecuted: true,
-            dynamic: toolCall.dynamic
-          });
-        }
-        break;
-      }
-      case "tool-approval-request": {
-        const toolCall = toolCalls.find((toolCall2) => toolCall2.toolCallId === part.toolCallId);
-        if (toolCall == null) {
-          throw new ToolCallNotFoundForApprovalError({
-            toolCallId: part.toolCallId,
-            approvalId: part.approvalId
-          });
-        }
-        contentParts.push({
-          type: "tool-approval-request",
-          approvalId: part.approvalId,
-          toolCall
-        });
-        break;
-      }
-    }
-  }
-  return [...contentParts, ...toolOutputs, ...toolApprovalRequests];
-}
 function prepareHeaders(headers, defaultHeaders) {
   const responseHeaders = new Headers(headers != null ? headers : {});
   for (const [key, value] of Object.entries(defaultHeaders)) {
@@ -54482,44 +53760,84 @@ var _a20;
 _a20 = symbol20;
 var defaultDownload2 = createDownload();
 
+// src/prompt.ts
+function buildUserPrompt(query, context2) {
+  if (!context2) {
+    return query;
+  }
+  return `Context:
+\`\`\`
+${context2}
+\`\`\`
+
+Question: ${query}`;
+}
+
 // src/run.ts
 async function runQuery(options) {
-  const { model, query, systemPrompt, stream } = options;
+  const { model, query, systemPrompt, context: context2 } = options;
+  const userPrompt = buildUserPrompt(query, context2);
   try {
-    if (stream) {
-      return await runStreamingQuery(model, query, systemPrompt);
+    const result = streamText({
+      model,
+      system: systemPrompt,
+      prompt: userPrompt
+    });
+    let fullText = "";
+    for await (const textPart of result.textStream) {
+      process.stdout.write(textPart);
+      fullText += textPart;
+    }
+    if (!fullText.endsWith(`
+`)) {
+      process.stdout.write(`
+`);
     }
-    return await runNonStreamingQuery(model, query, systemPrompt);
+    return { text: fullText };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new ProviderError(`AI request failed: ${message}`);
   }
 }
-async function runNonStreamingQuery(model, query, systemPrompt) {
-  const result = await generateText({
-    model,
-    system: systemPrompt,
-    prompt: query
-  });
-  return { text: result.text };
+
+// src/stdin.ts
+var MAX_QUERY_LENGTH = 5000;
+var MAX_CONTEXT_LENGTH = 50000;
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return { content: null, hasInput: false };
+  }
+  const chunks = [];
+  const decoder = new TextDecoder;
+  for await (const chunk of Bun.stdin.stream()) {
+    chunks.push(decoder.decode(chunk));
+  }
+  const content = chunks.join("").trim();
+  return {
+    content: content || null,
+    hasInput: content.length > 0
+  };
 }
-async function runStreamingQuery(model, query, systemPrompt) {
-  const result = streamText({
-    model,
-    system: systemPrompt,
-    prompt: query
-  });
-  let fullText = "";
-  for await (const textPart of result.textStream) {
-    process.stdout.write(textPart);
-    fullText += textPart;
+function resolveInput(stdinInput, argsQuery) {
+  if (stdinInput.hasInput && argsQuery.length > 0) {
+    return {
+      mode: "context",
+      query: argsQuery.join(" "),
+      context: stdinInput.content
+    };
   }
-  if (!fullText.endsWith(`
-`)) {
-    process.stdout.write(`
-`);
+  if (stdinInput.hasInput && stdinInput.content) {
+    return {
+      mode: "stdin",
+      query: stdinInput.content,
+      context: null
+    };
   }
-  return { text: fullText };
+  return {
+    mode: "args",
+    query: argsQuery.join(" "),
+    context: null
+  };
 }
 
 // src/cli.ts
@@ -54528,10 +53846,6 @@ async function main() {
   try {
     const args = parseCliArgs();
     debug = args.options.debug;
-    if (args.options.help) {
-      console.log(getHelpText());
-      process.exit(0);
-    }
     if (args.options.version) {
       console.log(getVersion());
       process.exit(0);
@@ -54552,11 +53866,19 @@ async function main() {
       console.log(listProviders(config3));
       process.exit(0);
     }
-    const query = args.query.join(" ");
-    const MAX_QUERY_LENGTH = 5000;
+    const stdinInput = await readStdin();
+    if (args.options.help && !stdinInput.hasInput && args.query.length === 0) {
+      console.log(getHelpText());
+      process.exit(0);
+    }
+    const { mode, query, context: context2 } = resolveInput(stdinInput, args.query);
+    logDebug2(`Mode: ${mode}`, debug);
     if (query.length > MAX_QUERY_LENGTH) {
       throw new UsageError2(`Query too long (${query.length} characters). Maximum is ${MAX_QUERY_LENGTH}.`);
     }
+    if (context2 && context2.length > MAX_CONTEXT_LENGTH) {
+      throw new UsageError2(`Context too long (${context2.length} characters). Maximum is ${MAX_CONTEXT_LENGTH}.`);
+    }
     logDebug2("Loading config...", debug);
     const config2 = await loadConfig();
     logDebug2(`Resolving provider: ${args.options.provider ?? config2.default.provider}`, debug);
@@ -54564,31 +53886,13 @@ async function main() {
     const envInfo = getEnvironmentInfo();
     logDebug2(`Query: ${query}`, debug);
     logDebug2(`Provider: ${providerName}, Model: ${modelId}`, debug);
-    logDebug2(`Stream: ${args.options.stream}`, debug);
     logDebug2(formatEnvForDebug(envInfo), debug);
     const result = await runQuery({
       model,
       query,
-      systemPrompt: buildSystemPrompt(envInfo),
-      stream: args.options.stream
-    });
-    if (!args.options.stream) {
-      const output = formatOutput({
-        text: result.text,
-        providerName,
-        modelId,
-        json: args.options.json
-      });
-      console.log(output);
-    } else if (args.options.json) {
-      const output = formatOutput({
-        text: result.text,
-        providerName,
-        modelId,
-        json: true
-      });
-      console.log(output);
-    }
+      context: context2,
+      systemPrompt: buildSystemPrompt(envInfo)
+    });
     if (args.options.copy) {
       await clipboardy_default.write(result.text);
       logDebug2("Copied to clipboard", debug);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hongymagic/q",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "Quick AI answers from the command line",
   "main": "dist/q.js",
   "type": "module",