@f5xc-salesdemos/xcsh 17.1.4 → 17.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5xc-salesdemos/xcsh",
-	"version": "17.1.4",
+	"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.1.4",
-		"@f5xc-salesdemos/pi-agent-core": "17.1.4",
-		"@f5xc-salesdemos/pi-ai": "17.1.4",
-		"@f5xc-salesdemos/pi-natives": "17.1.4",
-		"@f5xc-salesdemos/pi-tui": "17.1.4",
-		"@f5xc-salesdemos/pi-utils": "17.1.4",
+		"@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/prompts/system/system-prompt.md

@@ -114,7 +114,7 @@ happens under load, in a degraded state, or with an adversarial payload?"
 
 <stakes>
 The operator works in live infrastructure. Routing changes, firewall rules, TLS configurations,
-API deployments, traffic policies... Misconfigurations → outages, security exposures, or
+API deployments, traffic policies… Misconfigurations → outages, security exposures, or
 systems that fail under adversarial conditions.
 - You **MUST NOT** yield incomplete or unvalidated configurations.
 - You **MUST** only recommend operations and configurations you can defend.
@@ -322,7 +322,6 @@ These are inviolable. Violation is system failure.
 
 Configuration integrity means infrastructure tells the truth about what is actually deployed.
 Every stale config left in IaC without a corresponding live object is a lie to the next operator.
-
 - **The unit of change is the infrastructure decision, not the ticket.** When topology changes,
   every dependent config, policy reference, and IaC file changes in the same commit. Work is
   complete when the configuration is coherent, not when the API accepts it.

package/src/web/search/index.ts

@@ -38,6 +38,21 @@ export const webSearchSchema = Type.Object({
 	max_tokens: Type.Optional(Type.Number({ description: "Maximum output tokens" })),
 	temperature: Type.Optional(Type.Number({ description: "Sampling temperature" })),
 	num_search_results: Type.Optional(Type.Number({ description: "Number of search results to retrieve" })),
+	allowed_domains: Type.Optional(Type.Array(Type.String(), { description: "Only return results from these domains" })),
+	blocked_domains: Type.Optional(Type.Array(Type.String(), { description: "Exclude results from these domains" })),
+	max_uses: Type.Optional(Type.Number({ description: "Maximum number of web searches per request" })),
+	user_location: Type.Optional(
+		Type.Object(
+			{
+				type: Type.Literal("approximate"),
+				city: Type.Optional(Type.String()),
+				region: Type.Optional(Type.String()),
+				country: Type.Optional(Type.String()),
+				timezone: Type.Optional(Type.String()),
+			},
+			{ description: "Approximate user location for localized results" },
+		),
+	),
 });
 
 export type SearchToolParams = {
@@ -50,6 +65,16 @@ export type SearchToolParams = {
 	temperature?: number;
 	/** Number of search results to retrieve. Defaults to 10. */
 	num_search_results?: number;
+	allowed_domains?: string[];
+	blocked_domains?: string[];
+	max_uses?: number;
+	user_location?: {
+		type: "approximate";
+		city?: string;
+		region?: string;
+		country?: string;
+		timezone?: string;
+	};
 };
 
 export interface SearchQueryParams extends SearchToolParams {
@@ -143,10 +168,14 @@ async function executeSearch(
 	_toolCallId: string,
 	params: SearchQueryParams,
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
+	const hasAnthropicOnlyParams =
+		params.allowed_domains?.length || params.blocked_domains?.length || params.max_uses || params.user_location;
+	const effectiveProvider =
+		hasAnthropicOnlyParams && (!params.provider || params.provider === "auto") ? "anthropic" : params.provider;
 	const providers =
-		params.provider && params.provider !== "auto"
-			? (await getSearchProvider(params.provider).isAvailable())
-				? [getSearchProvider(params.provider)]
+		effectiveProvider && effectiveProvider !== "auto"
+			? (await getSearchProvider(effectiveProvider).isAvailable())
+				? [getSearchProvider(effectiveProvider)]
 				: await resolveProviderChain("auto")
 			: await resolveProviderChain();
 	if (providers.length === 0) {
@@ -171,6 +200,10 @@ async function executeSearch(
 				maxOutputTokens: params.max_tokens,
 				numSearchResults: params.num_search_results,
 				temperature: params.temperature,
+				allowedDomains: params.allowed_domains,
+				blockedDomains: params.blocked_domains,
+				maxUses: params.max_uses,
+				userLocation: params.user_location,
 			});
 
 			const text = formatForLLM(response);

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

@@ -27,9 +27,18 @@ 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";
 
+export interface AnthropicUserLocation {
+	type: "approximate";
+	city?: string;
+	region?: string;
+	country?: string;
+	timezone?: string;
+}
+
 export interface AnthropicSearchParams {
 	query: string;
 	system_prompt?: string;
@@ -38,6 +47,31 @@ export interface AnthropicSearchParams {
 	max_tokens?: number;
 	/** Sampling temperature (0–1). Lower = more focused/factual. */
 	temperature?: number;
+	allowed_domains?: string[];
+	blocked_domains?: string[];
+	max_uses?: number;
+	user_location?: AnthropicUserLocation;
+}
+
+interface WebSearchToolConfig {
+	allowed_domains?: string[];
+	blocked_domains?: string[];
+	max_uses?: number;
+	user_location?: AnthropicUserLocation;
+}
+
+export function extractSiteOperators(query: string): { cleanQuery: string; domains: string[] } {
+	const sitePattern = /\bsite:(\S+)/gi;
+	const domains: string[] = [];
+	const cleanQuery = query
+		.replace(sitePattern, (_, domain) => {
+			domains.push(domain);
+			return "";
+		})
+		.replace(/\s{2,}/g, " ")
+		.trim();
+	const fallback = domains.length > 0 ? domains.join(" ") : query;
+	return { cleanQuery: cleanQuery || fallback, domains };
 }
 
 /**
@@ -86,22 +120,27 @@ async function callSearch(
 	systemPrompt?: string,
 	maxTokens?: number,
 	temperature?: number,
+	toolConfig?: WebSearchToolConfig,
 ): Promise<AnthropicApiResponse> {
 	const url = buildAnthropicUrl(auth);
 	const headers = buildAnthropicSearchHeaders(auth);
 
 	const systemBlocks = buildSystemBlocks(auth, model, systemPrompt);
 
+	const tool: Record<string, unknown> = {
+		type: WEB_SEARCH_TOOL_TYPE,
+		name: WEB_SEARCH_TOOL_NAME,
+	};
+	if (toolConfig?.allowed_domains?.length) tool.allowed_domains = toolConfig.allowed_domains;
+	if (toolConfig?.blocked_domains?.length) tool.blocked_domains = toolConfig.blocked_domains;
+	tool.max_uses = toolConfig?.max_uses ?? DEFAULT_MAX_USES;
+	if (toolConfig?.user_location) tool.user_location = toolConfig.user_location;
+
 	const body: Record<string, unknown> = {
 		model,
 		max_tokens: maxTokens ?? DEFAULT_MAX_TOKENS,
 		messages: [{ role: "user", content: query }],
-		tools: [
-			{
-				type: WEB_SEARCH_TOOL_TYPE,
-				name: WEB_SEARCH_TOOL_NAME,
-			},
-		],
+		tools: [tool],
 	};
 
 	if (temperature !== undefined) {
@@ -246,13 +285,23 @@ export async function searchAnthropic(params: AnthropicSearchParams): Promise<Se
 	}
 
 	const model = getModel();
+
+	const { cleanQuery, domains: siteDomains } = extractSiteOperators(params.query);
+	const allAllowedDomains = [...(params.allowed_domains ?? []), ...siteDomains];
+
 	const response = await callSearch(
 		auth,
 		model,
-		params.query,
+		cleanQuery,
 		params.system_prompt,
 		params.max_tokens,
 		params.temperature,
+		{
+			allowed_domains: allAllowedDomains.length > 0 ? allAllowedDomains : undefined,
+			blocked_domains: params.blocked_domains,
+			max_uses: params.max_uses,
+			user_location: params.user_location,
+		},
 	);
 
 	const result = parseResponse(response);
@@ -281,6 +330,10 @@ export class AnthropicProvider extends SearchProvider {
 			num_results: params.numSearchResults ?? params.limit,
 			max_tokens: params.maxOutputTokens,
 			temperature: params.temperature,
+			allowed_domains: params.allowedDomains,
+			blocked_domains: params.blockedDomains,
+			max_uses: params.maxUses,
+			user_location: params.userLocation,
 		});
 	}
 }

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

@@ -10,6 +10,16 @@ export interface SearchParams {
 	maxOutputTokens?: number;
 	numSearchResults?: number;
 	temperature?: number;
+	allowedDomains?: string[];
+	blockedDomains?: string[];
+	maxUses?: number;
+	userLocation?: {
+		type: "approximate";
+		city?: string;
+		region?: string;
+		country?: string;
+		timezone?: string;
+	};
 	googleSearch?: Record<string, unknown>;
 	codeExecution?: Record<string, unknown>;
 	urlContext?: Record<string, unknown>;