@f5xc-salesdemos/xcsh 2.2.0 → 14.0.2

package/src/commit/agentic/tools/analyze-file.ts

@@ -0,0 +1,128 @@
+import { prompt } from "@f5xc-salesdemos/pi-utils";
+import { Type } from "@sinclair/typebox";
+import analyzeFilePrompt from "../../../commit/agentic/prompts/analyze-file.md" with { type: "text" };
+import type { CommitAgentState } from "../../../commit/agentic/state";
+import type { NumstatEntry } from "../../../commit/types";
+import type { ModelRegistry } from "../../../config/model-registry";
+import type { Settings } from "../../../config/settings";
+import type { CustomTool, CustomToolContext } from "../../../extensibility/custom-tools/types";
+import type { AuthStorage } from "../../../session/auth-storage";
+import { TaskTool } from "../../../task";
+import type { TaskParams } from "../../../task/types";
+import type { ToolSession } from "../../../tools";
+import { getFilePriority } from "./git-file-diff";
+
+const analyzeFileSchema = Type.Object({
+	files: Type.Array(Type.String({ description: "File path" }), { minItems: 1 }),
+	goal: Type.Optional(Type.String({ description: "Optional analysis focus" })),
+});
+
+const analyzeFileOutputSchema = {
+	properties: {
+		summary: { type: "string" },
+		highlights: { elements: { type: "string" } },
+		risks: { elements: { type: "string" } },
+	},
+};
+
+function buildToolSession(
+	ctx: CustomToolContext,
+	options: {
+		cwd: string;
+		authStorage: AuthStorage;
+		modelRegistry: ModelRegistry;
+		settings: Settings;
+		spawns: string;
+	},
+): ToolSession {
+	return {
+		cwd: options.cwd,
+		hasUI: false,
+		getSessionFile: () => ctx.sessionManager.getSessionFile() ?? null,
+		getSessionSpawns: () => options.spawns,
+		settings: options.settings,
+		authStorage: options.authStorage,
+		modelRegistry: options.modelRegistry,
+		searchDb: ctx.searchDb,
+	};
+}
+
+export function createAnalyzeFileTool(options: {
+	cwd: string;
+	authStorage: AuthStorage;
+	modelRegistry: ModelRegistry;
+	settings: Settings;
+	spawns: string;
+	state: CommitAgentState;
+}): CustomTool<typeof analyzeFileSchema> {
+	return {
+		name: "analyze_files",
+		label: "Analyze Files",
+		description: "Spawn quick_task agents to analyze files.",
+		parameters: analyzeFileSchema,
+		async execute(toolCallId, params, onUpdate, ctx, signal) {
+			const toolSession = buildToolSession(ctx, options);
+			const taskTool = await TaskTool.create(toolSession);
+			const numstat = options.state.overview?.numstat ?? [];
+			const tasks = params.files.map((file, index) => {
+				const relatedFiles = formatRelatedFiles(params.files, file, numstat);
+				const assignment = prompt.render(analyzeFilePrompt, {
+					file,
+					goal: params.goal,
+					related_files: relatedFiles,
+				});
+				return {
+					id: `AnalyzeFile${index + 1}`,
+					description: `Analyze ${file}`,
+					assignment,
+				};
+			});
+			const taskParams: TaskParams = {
+				agent: "quick_task",
+				schema: analyzeFileOutputSchema,
+				tasks,
+			};
+			return taskTool.execute(toolCallId, taskParams, signal, onUpdate);
+		},
+	};
+}
+
+function inferFileType(path: string): string {
+	const priority = getFilePriority(path);
+	const lowerPath = path.toLowerCase();
+
+	if (priority === -100) return "binary file";
+	if (priority === 10) return "test file";
+	if (lowerPath.endsWith(".md") || lowerPath.endsWith(".txt")) return "documentation";
+	if (
+		lowerPath.endsWith(".json") ||
+		lowerPath.endsWith(".yaml") ||
+		lowerPath.endsWith(".yml") ||
+		lowerPath.endsWith(".toml")
+	)
+		return "configuration";
+	if (priority === 70) return "dependency manifest";
+	if (priority === 80) return "script";
+	if (priority === 100) return "implementation";
+
+	return "source file";
+}
+
+function formatRelatedFiles(files: string[], currentFile: string, numstat: NumstatEntry[]): string | undefined {
+	const others = files.filter(file => file !== currentFile);
+	if (others.length === 0) return undefined;
+
+	const numstatMap = new Map(numstat.map(entry => [entry.path, entry]));
+
+	const lines = others.map(file => {
+		const entry = numstatMap.get(file);
+		const fileType = inferFileType(file);
+		if (entry) {
+			const lineCount = entry.additions + entry.deletions;
+			return `- ${file} (${lineCount} lines): ${fileType}`;
+		}
+		return `- ${file}: ${fileType}`;
+	});
+
+	return `OTHER FILES IN THIS CHANGE:\n${lines.join("\n")}`;
+}

package/src/commit/agentic/tools/git-file-diff.ts

@@ -0,0 +1,191 @@
+import { Type } from "@sinclair/typebox";
+import type { CommitAgentState } from "../../../commit/agentic/state";
+import type { CustomTool } from "../../../extensibility/custom-tools/types";
+import * as git from "../../../utils/git";
+
+const TARGET_TOKENS = 30000;
+const CHARS_PER_TOKEN = 4;
+const MAX_CHARS = TARGET_TOKENS * CHARS_PER_TOKEN;
+const TRUNCATE_THRESHOLD_LINES = 30;
+const KEEP_HEAD_LINES = 15;
+const KEEP_TAIL_LINES = 10;
+
+const HIGH_PRIORITY_EXTENSIONS = new Set([
+	".rs",
+	".go",
+	".py",
+	".js",
+	".ts",
+	".tsx",
+	".jsx",
+	".java",
+	".c",
+	".cpp",
+	".h",
+	".hpp",
+]);
+const SHELL_SQL_EXTENSIONS = new Set([".sh", ".bash", ".zsh", ".sql"]);
+const MANIFEST_FILES = new Set([
+	"Cargo.toml",
+	"package.json",
+	"go.mod",
+	"pyproject.toml",
+	"requirements.txt",
+	"Gemfile",
+	"build.gradle",
+	"pom.xml",
+]);
+const LOW_PRIORITY_EXTENSIONS = new Set([".md", ".txt", ".json", ".yaml", ".yml", ".toml", ".xml", ".csv"]);
+const BINARY_EXTENSIONS = new Set([
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".ico",
+	".woff",
+	".woff2",
+	".ttf",
+	".eot",
+	".pdf",
+	".zip",
+	".tar",
+	".gz",
+	".exe",
+	".dll",
+	".so",
+	".dylib",
+]);
+const TEST_PATTERNS = ["/test/", "/tests/", "/__tests__/", "_test.", ".test.", ".spec.", "_spec."];
+
+export function getFilePriority(filename: string): number {
+	const basename = filename.split("/").pop() ?? filename;
+	const ext = basename.includes(".") ? `.${basename.split(".").pop()}` : "";
+
+	if (BINARY_EXTENSIONS.has(ext)) return -100;
+
+	const lowerPath = filename.toLowerCase();
+	for (const pattern of TEST_PATTERNS) {
+		if (lowerPath.includes(pattern)) return 10;
+	}
+
+	if (LOW_PRIORITY_EXTENSIONS.has(ext) && !MANIFEST_FILES.has(basename)) return 20;
+	if (MANIFEST_FILES.has(basename)) return 70;
+	if (SHELL_SQL_EXTENSIONS.has(ext)) return 80;
+	if (HIGH_PRIORITY_EXTENSIONS.has(ext)) return 100;
+
+	return 50;
+}
+
+function truncateDiffContent(diff: string): { content: string; truncated: boolean } {
+	const lines = diff.split("\n");
+	if (lines.length <= TRUNCATE_THRESHOLD_LINES) {
+		return { content: diff, truncated: false };
+	}
+
+	const head = lines.slice(0, KEEP_HEAD_LINES);
+	const tail = lines.slice(-KEEP_TAIL_LINES);
+	const truncatedCount = lines.length - KEEP_HEAD_LINES - KEEP_TAIL_LINES;
+
+	return {
+		content: [...head, `\n... (truncated ${truncatedCount} lines) ...\n`, ...tail].join("\n"),
+		truncated: true,
+	};
+}
+
+function processDiffs(files: string[], diffs: Map<string, string>): { result: string; truncatedFiles: string[] } {
+	const sortedFiles = [...files].sort((a, b) => getFilePriority(b) - getFilePriority(a));
+
+	const truncatedFiles: string[] = [];
+	const parts: string[] = [];
+	let totalChars = 0;
+
+	for (const file of sortedFiles) {
+		const diff = diffs.get(file);
+		if (!diff) continue;
+
+		const remaining = MAX_CHARS - totalChars;
+		if (remaining <= 0) {
+			truncatedFiles.push(file);
+			continue;
+		}
+
+		let content = diff;
+		if (content.length > remaining || content.split("\n").length > TRUNCATE_THRESHOLD_LINES) {
+			const { content: truncated, truncated: wasTruncated } = truncateDiffContent(content);
+			if (wasTruncated) {
+				truncatedFiles.push(file);
+			}
+			content = truncated;
+			if (content.length > remaining) {
+				content = `${content.slice(0, remaining)}\n... (diff truncated due to size) ...`;
+				if (!truncatedFiles.includes(file)) {
+					truncatedFiles.push(file);
+				}
+			}
+		}
+
+		parts.push(`=== ${file} ===\n${content}`);
+		totalChars += content.length;
+	}
+
+	return { result: parts.join("\n\n"), truncatedFiles };
+}
+
+const gitFileDiffSchema = Type.Object({
+	files: Type.Array(Type.String({ description: "Files to diff" }), { minItems: 1, maxItems: 10 }),
+	staged: Type.Optional(Type.Boolean({ description: "Use staged changes (default: true)" })),
+});
+
+export function createGitFileDiffTool(cwd: string, state: CommitAgentState): CustomTool<typeof gitFileDiffSchema> {
+	return {
+		name: "git_file_diff",
+		label: "Git File Diff",
+		description: "Return the diff for specific files.",
+		parameters: gitFileDiffSchema,
+		async execute(_toolCallId, params) {
+			const staged = params.staged ?? true;
+			const cacheKey = (file: string) => `${file}:${staged}`;
+
+			if (!state.diffCache) {
+				state.diffCache = new Map();
+			}
+
+			const diffs = new Map<string, string>();
+			const uncachedFiles: string[] = [];
+
+			for (const file of params.files) {
+				const cached = state.diffCache.get(cacheKey(file));
+				if (cached !== undefined) {
+					diffs.set(file, cached);
+				} else {
+					uncachedFiles.push(file);
+				}
+			}
+
+			if (uncachedFiles.length > 0) {
+				for (const file of uncachedFiles) {
+					const diff = await git.diff(cwd, { cached: staged, files: [file] });
+					if (diff) {
+						diffs.set(file, diff);
+						state.diffCache.set(cacheKey(file), diff);
+					} else {
+						state.diffCache.set(cacheKey(file), "");
+					}
+				}
+			}
+
+			const { result, truncatedFiles } = processDiffs(params.files, diffs);
+			const output = result || "(no diff)";
+
+			return {
+				content: [{ type: "text", text: output }],
+				details: {
+					files: params.files,
+					staged,
+					truncatedFiles: truncatedFiles.length > 0 ? truncatedFiles : undefined,
+					cacheHits: params.files.length - uncachedFiles.length,
+				},
+			};
+		},
+	};
+}

package/src/commit/agentic/tools/git-hunk.ts

@@ -0,0 +1,50 @@
+import { Type } from "@sinclair/typebox";
+import type { DiffHunk, FileHunks } from "../../../commit/types";
+import type { CustomTool } from "../../../extensibility/custom-tools/types";
+import * as git from "../../../utils/git";
+
+const gitHunkSchema = Type.Object({
+	file: Type.String({ description: "File path" }),
+	hunks: Type.Optional(Type.Array(Type.Number({ description: "1-based hunk indices" }), { minItems: 1 })),
+	staged: Type.Optional(Type.Boolean({ description: "Use staged changes (default: true)" })),
+});
+
+function selectHunks(fileHunks: FileHunks, requested?: number[]): DiffHunk[] {
+	if (!requested || requested.length === 0) return fileHunks.hunks;
+	const wanted = new Set(requested.map(value => Math.max(1, Math.floor(value))));
+	return fileHunks.hunks.filter(hunk => wanted.has(hunk.index + 1));
+}
+
+export function createGitHunkTool(cwd: string): CustomTool<typeof gitHunkSchema> {
+	return {
+		name: "git_hunk",
+		label: "Git Hunk",
+		description: "Return specific hunks from a file diff.",
+		parameters: gitHunkSchema,
+		async execute(_toolCallId, params) {
+			const staged = params.staged ?? true;
+			const hunks = await git.diff.hunks(cwd, [params.file], { cached: staged });
+			const fileHunks = hunks.find(entry => entry.filename === params.file) ?? {
+				filename: params.file,
+				isBinary: false,
+				hunks: [],
+			};
+			if (fileHunks.isBinary) {
+				return {
+					content: [{ type: "text", text: "Binary file diff; no hunks available." }],
+					details: { file: params.file, staged, hunks: [] },
+				};
+			}
+			const selected = selectHunks(fileHunks, params.hunks);
+			const text = selected.length ? selected.map(hunk => hunk.content).join("\n\n") : "(no matching hunks)";
+			return {
+				content: [{ type: "text", text }],
+				details: {
+					file: params.file,
+					staged,
+					hunks: selected,
+				},
+			};
+		},
+	};
+}

package/src/commit/agentic/tools/git-overview.ts

@@ -0,0 +1,81 @@
+import { Type } from "@sinclair/typebox";
+import type { CommitAgentState, GitOverviewSnapshot } from "../../../commit/agentic/state";
+import { extractScopeCandidates } from "../../../commit/analysis/scope";
+import type { CustomTool } from "../../../extensibility/custom-tools/types";
+import * as git from "../../../utils/git";
+
+const EXCLUDED_LOCK_FILES = new Set([
+	"Cargo.lock",
+	"package-lock.json",
+	"yarn.lock",
+	"pnpm-lock.yaml",
+	"bun.lock",
+	"bun.lockb",
+	"go.sum",
+	"poetry.lock",
+	"Pipfile.lock",
+	"uv.lock",
+	"composer.lock",
+	"Gemfile.lock",
+	"flake.lock",
+	"pubspec.lock",
+	"Podfile.lock",
+	"mix.lock",
+	"gradle.lockfile",
+]);
+
+function isExcludedFile(path: string): boolean {
+	const basename = path.split("/").pop() ?? path;
+	return EXCLUDED_LOCK_FILES.has(basename);
+}
+
+function filterExcludedFiles(files: string[]): { filtered: string[]; excluded: string[] } {
+	const filtered: string[] = [];
+	const excluded: string[] = [];
+	for (const file of files) {
+		if (isExcludedFile(file)) {
+			excluded.push(file);
+		} else {
+			filtered.push(file);
+		}
+	}
+	return { filtered, excluded };
+}
+
+const gitOverviewSchema = Type.Object({
+	staged: Type.Optional(Type.Boolean({ description: "Use staged changes (default: true)" })),
+	include_untracked: Type.Optional(Type.Boolean({ description: "Include untracked files when staged=false" })),
+});
+
+export function createGitOverviewTool(cwd: string, state: CommitAgentState): CustomTool<typeof gitOverviewSchema> {
+	return {
+		name: "git_overview",
+		label: "Git Overview",
+		description: "Return staged files, diff stat summary, and numstat entries.",
+		parameters: gitOverviewSchema,
+		async execute(_toolCallId, params) {
+			const staged = params.staged ?? true;
+			const allFiles = await git.diff.changedFiles(cwd, { cached: staged });
+			const { filtered: files, excluded } = filterExcludedFiles(allFiles);
+			const stat = await git.diff(cwd, { stat: true, cached: staged });
+			const allNumstat = await git.diff.numstat(cwd, { cached: staged });
+			const numstat = allNumstat.filter(entry => !isExcludedFile(entry.path));
+			const scopeResult = extractScopeCandidates(numstat);
+			const untrackedFiles = !staged && params.include_untracked ? await git.ls.untracked(cwd) : undefined;
+			const snapshot: GitOverviewSnapshot = {
+				files,
+				stat,
+				numstat,
+				scopeCandidates: scopeResult.scopeCandidates,
+				isWideScope: scopeResult.isWide,
+				untrackedFiles,
+				excludedFiles: excluded.length > 0 ? excluded : undefined,
+			};
+			state.overview = snapshot;
+			return {
+				content: [{ type: "text", text: JSON.stringify(snapshot, null, 2) }],
+				details: snapshot,
+			};
+		},
+	};
+}

package/src/commit/agentic/tools/index.ts

@@ -0,0 +1,54 @@
+import type { CommitAgentState } from "../../../commit/agentic/state";
+import type { ModelRegistry } from "../../../config/model-registry";
+import type { Settings } from "../../../config/settings";
+import type { CustomTool } from "../../../extensibility/custom-tools/types";
+import type { AuthStorage } from "../../../session/auth-storage";
+import { createAnalyzeFileTool } from "./analyze-file";
+import { createGitFileDiffTool } from "./git-file-diff";
+import { createGitHunkTool } from "./git-hunk";
+import { createGitOverviewTool } from "./git-overview";
+import { createProposeChangelogTool } from "./propose-changelog";
+import { createProposeCommitTool } from "./propose-commit";
+import { createRecentCommitsTool } from "./recent-commits";
+import { createSplitCommitTool } from "./split-commit";
+
+export interface CommitToolOptions {
+	cwd: string;
+	authStorage: AuthStorage;
+	modelRegistry: ModelRegistry;
+	settings: Settings;
+	spawns: string;
+	state: CommitAgentState;
+	changelogTargets: string[];
+	enableAnalyzeFiles?: boolean;
+}
+
+export function createCommitTools(options: CommitToolOptions): Array<CustomTool<any, any>> {
+	const tools: Array<CustomTool<any, any>> = [
+		createGitOverviewTool(options.cwd, options.state),
+		createGitFileDiffTool(options.cwd, options.state),
+		createGitHunkTool(options.cwd),
+		createRecentCommitsTool(options.cwd),
+	];
+
+	if (options.enableAnalyzeFiles ?? true) {
+		tools.push(
+			createAnalyzeFileTool({
+				cwd: options.cwd,
+				authStorage: options.authStorage,
+				modelRegistry: options.modelRegistry,
+				settings: options.settings,
+				spawns: options.spawns,
+				state: options.state,
+			}),
+		);
+	}
+
+	tools.push(
+		createProposeChangelogTool(options.state, options.changelogTargets),
+		createProposeCommitTool(options.cwd, options.state),
+		createSplitCommitTool(options.cwd, options.state, options.changelogTargets),
+	);
+
+	return tools;
+}

package/src/commit/agentic/tools/propose-changelog.ts

@@ -0,0 +1,139 @@
+import { type TSchema, Type } from "@sinclair/typebox";
+import type { CommitAgentState } from "../../../commit/agentic/state";
+import { CHANGELOG_CATEGORIES, type ChangelogCategory } from "../../../commit/types";
+import type { CustomTool } from "../../../extensibility/custom-tools/types";
+
+const changelogEntryProperties = CHANGELOG_CATEGORIES.reduce<Record<ChangelogCategory, TSchema>>(
+	(acc, category) => {
+		acc[category] = Type.Optional(Type.Array(Type.String()));
+		return acc;
+	},
+	{} as Record<ChangelogCategory, TSchema>,
+);
+
+const changelogEntriesSchema = Type.Object(changelogEntryProperties);
+const changelogDeletionsSchema = Type.Object(changelogEntryProperties, {
+	description: "Entries to remove from existing changelog sections (case-insensitive match)",
+});
+
+const changelogEntrySchema = Type.Object({
+	path: Type.String(),
+	entries: changelogEntriesSchema,
+	deletions: Type.Optional(changelogDeletionsSchema),
+});
+
+const proposeChangelogSchema = Type.Object({
+	entries: Type.Array(changelogEntrySchema),
+});
+
+interface ChangelogResponse {
+	valid: boolean;
+	errors: string[];
+	warnings: string[];
+}
+
+const allowedCategories = new Set<ChangelogCategory>(CHANGELOG_CATEGORIES);
+
+export function createProposeChangelogTool(
+	state: CommitAgentState,
+	changelogTargets: string[],
+): CustomTool<typeof proposeChangelogSchema> {
+	return {
+		name: "propose_changelog",
+		label: "Propose Changelog",
+		description: "Provide changelog entries for targeted CHANGELOG.md files.",
+		parameters: proposeChangelogSchema,
+		async execute(_toolCallId, params) {
+			const errors: string[] = [];
+			const warnings: string[] = [];
+			const targets = new Set(changelogTargets);
+			const seen = new Set<string>();
+
+			const normalized = params.entries.map(entry => {
+				const cleaned: Record<string, string[]> = {};
+				const entries = entry.entries as Record<string, string[]>;
+				for (const [category, values] of Object.entries(entries)) {
+					if (!allowedCategories.has(category as ChangelogCategory)) {
+						errors.push(`Unknown changelog category for ${entry.path}: ${category}`);
+						continue;
+					}
+					if (!Array.isArray(values)) {
+						errors.push(`Invalid changelog entries for ${entry.path}: ${category}`);
+						continue;
+					}
+					const items = values.map(value => value.trim().replace(/\.$/, "")).filter(value => value.length > 0);
+					if (items.length > 0) {
+						cleaned[category] = Array.from(new Set(items));
+					}
+				}
+
+				let cleanedDeletions: Record<string, string[]> | undefined;
+				if (entry.deletions) {
+					cleanedDeletions = {};
+					const deletions = entry.deletions as Record<string, string[]>;
+					for (const [category, values] of Object.entries(deletions)) {
+						if (!allowedCategories.has(category as ChangelogCategory)) {
+							errors.push(`Unknown deletion category for ${entry.path}: ${category}`);
+							continue;
+						}
+						if (!Array.isArray(values)) {
+							errors.push(`Invalid deletion entries for ${entry.path}: ${category}`);
+							continue;
+						}
+						const items = values.map(value => value.trim()).filter(value => value.length > 0);
+						if (items.length > 0) {
+							cleanedDeletions[category] = Array.from(new Set(items));
+						}
+					}
+					if (Object.keys(cleanedDeletions).length === 0) {
+						cleanedDeletions = undefined;
+					}
+				}
+
+				if (Object.keys(cleaned).length === 0 && !cleanedDeletions) {
+					warnings.push(`No changelog entries provided for ${entry.path}.`);
+				}
+				return {
+					path: entry.path,
+					entries: cleaned,
+					deletions: cleanedDeletions,
+				};
+			});
+
+			for (const entry of normalized) {
+				if (targets.size > 0 && !targets.has(entry.path)) {
+					errors.push(`Changelog not expected: ${entry.path}`);
+					continue;
+				}
+				if (seen.has(entry.path)) {
+					errors.push(`Duplicate changelog entry for ${entry.path}`);
+					continue;
+				}
+				seen.add(entry.path);
+			}
+
+			if (targets.size > 0) {
+				for (const target of targets) {
+					if (!seen.has(target)) {
+						errors.push(`Missing changelog entries for ${target}`);
+					}
+				}
+			}
+
+			const response: ChangelogResponse = {
+				valid: errors.length === 0,
+				errors,
+				warnings,
+			};
+
+			if (response.valid) {
+				state.changelogProposal = { entries: normalized };
+			}
+
+			return {
+				content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+				details: response,
+			};
+		},
+	};
+}