@f5xc-salesdemos/xcsh 17.2.0 → 17.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5xc-salesdemos/xcsh",
-	"version": "17.2.0",
+	"version": "17.3.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5xc-salesdemos/xcsh",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.16.1",
 		"@mozilla/readability": "^0.6",
-		"@f5xc-salesdemos/xcsh-stats": "17.2.0",
-		"@f5xc-salesdemos/pi-agent-core": "17.2.0",
-		"@f5xc-salesdemos/pi-ai": "17.2.0",
-		"@f5xc-salesdemos/pi-natives": "17.2.0",
-		"@f5xc-salesdemos/pi-tui": "17.2.0",
-		"@f5xc-salesdemos/pi-utils": "17.2.0",
+		"@f5xc-salesdemos/xcsh-stats": "17.3.0",
+		"@f5xc-salesdemos/pi-agent-core": "17.3.0",
+		"@f5xc-salesdemos/pi-ai": "17.3.0",
+		"@f5xc-salesdemos/pi-natives": "17.3.0",
+		"@f5xc-salesdemos/pi-tui": "17.3.0",
+		"@f5xc-salesdemos/pi-utils": "17.3.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/cli/web-search-cli.ts

@@ -4,13 +4,14 @@
  * Handles `xcsh q`/`xcsh web-search` subcommands for testing web search providers.
  */
 
-import { APP_NAME } from "@f5xc-salesdemos/pi-utils";
+import { buildAnthropicSearchHeaders, buildAnthropicUrl, findAnthropicAuth } from "@f5xc-salesdemos/pi-ai";
+import { $env, APP_NAME } from "@f5xc-salesdemos/pi-utils";
 import chalk from "chalk";
 import { initTheme, theme } from "../modes/theme/theme";
 import { runSearchQuery, type SearchQueryParams } from "../web/search/index";
 import { SEARCH_PROVIDER_ORDER } from "../web/search/provider";
 import { renderSearchResult } from "../web/search/render";
-import type { SearchProviderId } from "../web/search/types";
+import type { SearchProviderId, SearchResponse } from "../web/search/types";
 
 export interface SearchCommandArgs {
 	query: string;
@@ -18,6 +19,8 @@ export interface SearchCommandArgs {
 	recency?: "day" | "week" | "month" | "year";
 	limit?: number;
 	expanded: boolean;
+	synthesize: boolean;
+	synthesizeModel?: string;
 }
 
 const PROVIDERS: Array<SearchProviderId | "auto"> = ["auto", ...SEARCH_PROVIDER_ORDER];
@@ -36,6 +39,7 @@ export function parseSearchArgs(args: string[]): SearchCommandArgs | undefined {
 	const result: SearchCommandArgs = {
 		query: "",
 		expanded: true,
+		synthesize: true,
 	};
 
 	const positional: string[] = [];
@@ -50,6 +54,10 @@ export function parseSearchArgs(args: string[]): SearchCommandArgs | undefined {
 			result.limit = Number.parseInt(args[++i], 10);
 		} else if (arg === "--compact") {
 			result.expanded = false;
+		} else if (arg === "--no-synthesize") {
+			result.synthesize = false;
+		} else if (arg === "--model") {
+			result.synthesizeModel = args[++i];
 		} else if (!arg.startsWith("-")) {
 			positional.push(arg);
 		}
@@ -62,6 +70,54 @@ export function parseSearchArgs(args: string[]): SearchCommandArgs | undefined {
 	return result;
 }
 
+async function synthesizeResponse(
+	query: string,
+	searchResponse: SearchResponse,
+	model?: string,
+): Promise<string | undefined> {
+	const auth = await findAnthropicAuth();
+	if (!auth) return undefined;
+
+	const sourcesContext = searchResponse.sources
+		.map((s, i) => `[${i + 1}] ${s.title}\n    ${s.url}${s.snippet ? `\n    ${s.snippet}` : ""}`)
+		.join("\n");
+
+	const citationsContext =
+		searchResponse.citations?.map((c, i) => `[${i + 1}] ${c.title}: "${c.citedText}"`).join("\n") ?? "";
+
+	const synthesisPrompt = `Based on the following web search results for the query "${query}", provide a comprehensive, well-structured answer. Cite sources by number.
+
+## Search Results
+${searchResponse.answer ? `### Initial Answer\n${searchResponse.answer}\n` : ""}
+### Sources
+${sourcesContext}
+${citationsContext ? `\n### Citations\n${citationsContext}` : ""}
+
+Provide a thorough answer with key facts, numbers, and source citations.`;
+
+	const url = buildAnthropicUrl(auth);
+	const headers = buildAnthropicSearchHeaders(auth);
+	const selectedModel = model ?? $env.ANTHROPIC_SEARCH_MODEL ?? "claude-haiku-4-5";
+
+	const response = await fetch(url, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			model: selectedModel,
+			max_tokens: 4096,
+			messages: [{ role: "user", content: synthesisPrompt }],
+		}),
+	});
+
+	if (!response.ok) return undefined;
+
+	const data = (await response.json()) as { content?: Array<{ type: string; text?: string }> };
+	return data.content
+		?.filter(b => b.type === "text" && b.text)
+		.map(b => b.text)
+		.join("\n\n");
+}
+
 export async function runSearchCommand(cmd: SearchCommandArgs): Promise<void> {
 	if (!cmd.query) {
 		process.stderr.write(`${chalk.red("Error: Query is required")}\n`);
@@ -104,6 +160,18 @@ export async function runSearchCommand(cmd: SearchCommandArgs): Promise<void> {
 	const width = Math.max(60, process.stdout.columns ?? 100);
 	process.stdout.write(`${component.render(width).join("\n")}\n`);
 
+	if (cmd.synthesize && result.details?.response && result.details.response.sources.length > 0) {
+		try {
+			process.stderr.write(chalk.dim("\nSynthesizing response...\n"));
+			const synthesized = await synthesizeResponse(cmd.query, result.details.response, cmd.synthesizeModel);
+			if (synthesized) {
+				process.stdout.write(`\n${chalk.bold("Synthesized Answer:")}\n\n${synthesized}\n`);
+			}
+		} catch {
+			process.stderr.write(chalk.dim("Synthesis unavailable — showing raw search results only.\n"));
+		}
+	}
+
 	if (result.details?.error) {
 		process.exitCode = 1;
 	}
@@ -124,6 +192,8 @@ ${chalk.bold("Options:")}
   --recency <value>   Recency filter (Brave/Perplexity): ${RECENCY_OPTIONS.join(", ")}
   -l, --limit <n>     Max results to return
   --compact           Render condensed output
+  --no-synthesize     Skip synthesis step (raw search only)
+  --model <name>      Model for synthesis (default: ANTHROPIC_SEARCH_MODEL or claude-haiku-4-5)
   -h, --help          Show this help
 
 ${chalk.bold("Examples:")}

package/src/commands/web-search.ts

@@ -23,6 +23,8 @@ export default class Search extends Command {
 		recency: Flags.string({ description: "Recency filter", options: RECENCY }),
 		limit: Flags.integer({ char: "l", description: "Max results to return" }),
 		compact: Flags.boolean({ description: "Render condensed output" }),
+		"no-synthesize": Flags.boolean({ description: "Skip synthesis step (raw search only)" }),
+		model: Flags.string({ description: "Model for synthesis (default: claude-haiku-4-5)" }),
 	};
 
 	async run(): Promise<void> {
@@ -35,6 +37,8 @@ export default class Search extends Command {
 			recency: flags.recency as SearchCommandArgs["recency"],
 			limit: flags.limit,
 			expanded: !flags.compact,
+			synthesize: !flags["no-synthesize"],
+			synthesizeModel: flags.model,
 		};
 
 		await runSearchCommand(cmd);

package/src/web/search/index.ts

@@ -168,9 +168,10 @@ async function executeSearch(
 	_toolCallId: string,
 	params: SearchQueryParams,
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
-	const hasDomainFilter = params.allowed_domains?.length || params.blocked_domains?.length;
+	const hasAnthropicOnlyParams =
+		params.allowed_domains?.length || params.blocked_domains?.length || params.max_uses || params.user_location;
 	const effectiveProvider =
-		hasDomainFilter && (!params.provider || params.provider === "auto") ? "anthropic" : params.provider;
+		hasAnthropicOnlyParams && (!params.provider || params.provider === "auto") ? "anthropic" : params.provider;
 	const providers =
 		effectiveProvider && effectiveProvider !== "auto"
 			? (await getSearchProvider(effectiveProvider).isAvailable())

package/src/web/search/providers/anthropic.ts

@@ -27,6 +27,7 @@ import { SearchProvider } from "./base";
 
 const DEFAULT_MODEL = "claude-haiku-4-5";
 const DEFAULT_MAX_TOKENS = 4096;
+const DEFAULT_MAX_USES = 8;
 const WEB_SEARCH_TOOL_NAME = "web_search";
 const WEB_SEARCH_TOOL_TYPE = "web_search_20250305";
 
@@ -132,7 +133,7 @@ async function callSearch(
 	};
 	if (toolConfig?.allowed_domains?.length) tool.allowed_domains = toolConfig.allowed_domains;
 	if (toolConfig?.blocked_domains?.length) tool.blocked_domains = toolConfig.blocked_domains;
-	if (toolConfig?.max_uses) tool.max_uses = toolConfig.max_uses;
+	tool.max_uses = toolConfig?.max_uses ?? DEFAULT_MAX_USES;
 	if (toolConfig?.user_location) tool.user_location = toolConfig.user_location;
 
 	const body: Record<string, unknown> = {