@nghyane/arcane 0.1.0

package/src/commit/git/index.ts

@@ -0,0 +1,211 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { logger, Snowflake } from "@nghyane/arcane-utils";
+import type { FileDiff, FileHunks, NumstatEntry } from "../../commit/types";
+import { parseDiffHunks, parseFileDiffs, parseFileHunks, parseNumstat } from "./diff";
+import { GitError } from "./errors";
+import { commit, push, resetStaging, runGitCommand, stageFiles } from "./operations";
+
+export type HunkSelection = {
+	path: string;
+	hunks: { type: "all" } | { type: "indices"; indices: number[] } | { type: "lines"; start: number; end: number };
+};
+
+export class ControlledGit {
+	constructor(private readonly cwd: string) {}
+
+	async getDiff(staged: boolean): Promise<string> {
+		const args = staged ? ["diff", "--cached"] : ["diff"];
+		const result = await runGitCommand(this.cwd, args);
+		this.#ensureSuccess(result, "git diff");
+		return result.stdout;
+	}
+
+	async getDiffForFiles(files: string[], staged = true): Promise<string> {
+		const args = staged ? ["diff", "--cached", "--", ...files] : ["diff", "--", ...files];
+		const result = await runGitCommand(this.cwd, args);
+		this.#ensureSuccess(result, "git diff (files)");
+		return result.stdout;
+	}
+
+	async getChangedFiles(staged: boolean): Promise<string[]> {
+		const args = staged ? ["diff", "--cached", "--name-only"] : ["diff", "--name-only"];
+		const result = await runGitCommand(this.cwd, args);
+		this.#ensureSuccess(result, "git diff --name-only");
+		return result.stdout
+			.split("\n")
+			.map(line => line.trim())
+			.filter(Boolean);
+	}
+
+	async getStat(staged: boolean): Promise<string> {
+		const args = staged ? ["diff", "--cached", "--stat"] : ["diff", "--stat"];
+		const result = await runGitCommand(this.cwd, args);
+		this.#ensureSuccess(result, "git diff --stat");
+		return result.stdout;
+	}
+
+	async getStatForFiles(files: string[], staged = true): Promise<string> {
+		const args = staged ? ["diff", "--cached", "--stat", "--", ...files] : ["diff", "--stat", "--", ...files];
+		const result = await runGitCommand(this.cwd, args);
+		this.#ensureSuccess(result, "git diff --stat (files)");
+		return result.stdout;
+	}
+
+	async getNumstat(staged: boolean): Promise<NumstatEntry[]> {
+		const args = staged ? ["diff", "--cached", "--numstat"] : ["diff", "--numstat"];
+		const result = await runGitCommand(this.cwd, args);
+		this.#ensureSuccess(result, "git diff --numstat");
+		return parseNumstat(result.stdout);
+	}
+
+	async getRecentCommits(count: number): Promise<string[]> {
+		const result = await runGitCommand(this.cwd, ["log", `-n${count}`, "--pretty=format:%s"]);
+		this.#ensureSuccess(result, "git log");
+		return result.stdout
+			.split("\n")
+			.map(line => line.trim())
+			.filter(Boolean);
+	}
+
+	async getStagedFiles(): Promise<string[]> {
+		const result = await runGitCommand(this.cwd, ["diff", "--cached", "--name-only"]);
+		this.#ensureSuccess(result, "git diff --cached --name-only");
+		return result.stdout
+			.split("\n")
+			.map(line => line.trim())
+			.filter(Boolean);
+	}
+
+	async getUntrackedFiles(): Promise<string[]> {
+		const result = await runGitCommand(this.cwd, ["ls-files", "--others", "--exclude-standard"]);
+		this.#ensureSuccess(result, "git ls-files --others --exclude-standard");
+		return result.stdout
+			.split("\n")
+			.map(line => line.trim())
+			.filter(Boolean);
+	}
+
+	async stageAll(): Promise<void> {
+		const result = await stageFiles(this.cwd, []);
+		this.#ensureSuccess(result, "git add -A");
+	}
+
+	async stageFiles(files: string[]): Promise<void> {
+		const result = await stageFiles(this.cwd, files);
+		this.#ensureSuccess(result, "git add");
+	}
+
+	async stageHunks(selections: HunkSelection[]): Promise<void> {
+		if (selections.length === 0) return;
+		const diff = await this.getDiff(false);
+		const fileDiffs = parseFileDiffs(diff);
+		const fileDiffMap = new Map(fileDiffs.map(entry => [entry.filename, entry]));
+		const patchParts: string[] = [];
+		for (const selection of selections) {
+			const fileDiff = fileDiffMap.get(selection.path);
+			if (!fileDiff) {
+				throw new GitError("git apply --cached", `No diff found for ${selection.path}`);
+			}
+			if (fileDiff.isBinary) {
+				if (selection.hunks.type !== "all") {
+					throw new GitError("git apply --cached", `Cannot select hunks for binary file ${selection.path}`);
+				}
+				patchParts.push(fileDiff.content);
+				continue;
+			}
+
+			if (selection.hunks.type === "all") {
+				patchParts.push(fileDiff.content);
+				continue;
+			}
+
+			const fileHunks = parseFileHunks(fileDiff);
+			const selectedHunks = selectHunks(fileHunks, selection.hunks);
+			if (selectedHunks.length === 0) {
+				throw new GitError("git apply --cached", `No hunks selected for ${selection.path}`);
+			}
+			const header = extractFileHeader(fileDiff.content);
+			const filePatch = [header, ...selectedHunks.map(hunk => hunk.content)].join("\n");
+			patchParts.push(filePatch);
+		}
+
+		const patch = joinPatch(patchParts);
+		if (!patch.trim()) return;
+		const tempPath = path.join(os.tmpdir(), `omp-hunks-${Snowflake.next()}.patch`);
+		try {
+			await Bun.write(tempPath, patch);
+			const result = await runGitCommand(this.cwd, ["apply", "--cached", "--binary", tempPath]);
+			this.#ensureSuccess(result, "git apply --cached");
+		} finally {
+			await fs.rm(tempPath, { force: true });
+		}
+	}
+
+	async resetStaging(files: string[] = []): Promise<void> {
+		const result = await resetStaging(this.cwd, files);
+		this.#ensureSuccess(result, "git reset");
+	}
+
+	async commit(message: string): Promise<void> {
+		const result = await commit(this.cwd, message);
+		this.#ensureSuccess(result, "git commit");
+	}
+
+	async push(): Promise<void> {
+		const result = await push(this.cwd);
+		this.#ensureSuccess(result, "git push");
+	}
+
+	parseDiffFiles(diff: string): FileDiff[] {
+		return parseFileDiffs(diff);
+	}
+
+	parseDiffHunks(diff: string): FileHunks[] {
+		return parseDiffHunks(diff);
+	}
+
+	async getHunks(files: string[], staged = true): Promise<FileHunks[]> {
+		const diff = await this.getDiffForFiles(files, staged);
+		return this.parseDiffHunks(diff);
+	}
+
+	#ensureSuccess(result: { exitCode: number; stderr: string }, label: string): void {
+		if (result.exitCode !== 0) {
+			logger.error("commit git command failed", { label, stderr: result.stderr });
+			throw new GitError(label, result.stderr);
+		}
+	}
+}
+
+function extractFileHeader(diff: string): string {
+	const lines = diff.split("\n");
+	const headerLines: string[] = [];
+	for (const line of lines) {
+		if (line.startsWith("@@")) break;
+		headerLines.push(line);
+	}
+	return headerLines.join("\n");
+}
+
+function joinPatch(parts: string[]): string {
+	return parts
+		.map(part => (part.endsWith("\n") ? part : `${part}\n`))
+		.join("\n")
+		.trimEnd()
+		.concat("\n");
+}
+
+function selectHunks(file: FileHunks, selector: HunkSelection["hunks"]): FileHunks["hunks"] {
+	if (selector.type === "indices") {
+		const wanted = new Set(selector.indices.map(value => Math.max(1, Math.floor(value))));
+		return file.hunks.filter(hunk => wanted.has(hunk.index + 1));
+	}
+	if (selector.type === "lines") {
+		const start = Math.floor(selector.start);
+		const end = Math.floor(selector.end);
+		return file.hunks.filter(hunk => hunk.newStart <= end && hunk.newStart + hunk.newLines - 1 >= start);
+	}
+	return file.hunks;
+}

package/src/commit/git/operations.ts

@@ -0,0 +1,54 @@
+import { $ } from "bun";
+
+interface GitResult {
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+}
+
+export async function runGitCommand(cwd: string, args: string[]): Promise<GitResult> {
+	const result = await $`git ${args}`.cwd(cwd).quiet().nothrow();
+	const stdout = result.text();
+	const stderr = result.stderr?.toString() ?? "";
+	return {
+		exitCode: result.exitCode ?? 0,
+		stdout,
+		stderr,
+	};
+}
+
+export async function stageFiles(cwd: string, files: string[]): Promise<GitResult> {
+	const args = files.length === 0 ? ["add", "-A"] : ["add", "--", ...files];
+	return runGitCommand(cwd, args);
+}
+
+export async function resetStaging(cwd: string, files: string[]): Promise<GitResult> {
+	const args = files.length === 0 ? ["reset"] : ["reset", "--", ...files];
+	return runGitCommand(cwd, args);
+}
+
+export async function push(cwd: string): Promise<GitResult> {
+	return runGitCommand(cwd, ["push"]);
+}
+
+export async function commit(cwd: string, message: string): Promise<GitResult> {
+	const child = Bun.spawn(["git", "commit", "-F", "-"], {
+		cwd,
+		stdin: Buffer.from(message),
+		stdout: "pipe",
+		stderr: "pipe",
+		windowsHide: true,
+	});
+
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(child.stdout).text(),
+		new Response(child.stderr).text(),
+		child.exited,
+	]);
+
+	return {
+		exitCode: exitCode ?? 0,
+		stdout: stdout.trim(),
+		stderr: stderr.trim(),
+	};
+}

package/src/commit/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Entry points for the arcane commit command.
+ */
+
+export { runCommitCommand } from "./pipeline";

package/src/commit/map-reduce/index.ts

@@ -0,0 +1,64 @@
+import type { Api, Model } from "@nghyane/arcane-ai";
+import { $env } from "@nghyane/arcane-utils";
+import { parseFileDiffs } from "../../commit/git/diff";
+import type { ConventionalAnalysis } from "../../commit/types";
+import { isExcludedFile } from "../../commit/utils/exclusions";
+import { runMapPhase } from "./map-phase";
+import { runReducePhase } from "./reduce-phase";
+import { estimateTokens } from "./utils";
+
+const MIN_FILES_FOR_MAP_REDUCE = 4;
+const MAX_FILE_TOKENS = 50_000;
+
+export interface MapReduceSettings {
+	enabled?: boolean;
+	minFiles?: number;
+	maxFileTokens?: number;
+	maxConcurrency?: number;
+	timeoutMs?: number;
+}
+
+export interface MapReduceInput {
+	model: Model<Api>;
+	apiKey: string;
+	fastModel: Model<Api>;
+	fastApiKey: string;
+	diff: string;
+	stat: string;
+	scopeCandidates: string;
+	typesDescription?: string;
+	settings?: MapReduceSettings;
+}
+
+export function shouldUseMapReduce(diff: string, settings?: MapReduceSettings): boolean {
+	if ($env.ARCANE_COMMIT_MAP_REDUCE?.toLowerCase() === "false") return false;
+	if (settings?.enabled === false) return false;
+	const minFiles = settings?.minFiles ?? MIN_FILES_FOR_MAP_REDUCE;
+	const maxFileTokens = settings?.maxFileTokens ?? MAX_FILE_TOKENS;
+	const files = parseFileDiffs(diff).filter(file => !isExcludedFile(file.filename));
+	const fileCount = files.length;
+	if (fileCount >= minFiles) return true;
+	return files.some(file => estimateTokens(file.content) > maxFileTokens);
+}
+
+/**
+ * Run map-reduce analysis for large diffs using fast + primary models.
+ */
+
+export async function runMapReduceAnalysis(input: MapReduceInput): Promise<ConventionalAnalysis> {
+	const fileDiffs = parseFileDiffs(input.diff).filter(file => !isExcludedFile(file.filename));
+	const observations = await runMapPhase({
+		model: input.fastModel,
+		apiKey: input.fastApiKey,
+		files: fileDiffs,
+		config: input.settings,
+	});
+	return runReducePhase({
+		model: input.model,
+		apiKey: input.apiKey,
+		observations,
+		stat: input.stat,
+		scopeCandidates: input.scopeCandidates,
+		typesDescription: input.typesDescription,
+	});
+}

package/src/commit/map-reduce/map-phase.ts

@@ -0,0 +1,178 @@
+import type { Api, AssistantMessage, Message, Model } from "@nghyane/arcane-ai";
+import { completeSimple } from "@nghyane/arcane-ai";
+import fileObserverSystemPrompt from "../../commit/prompts/file-observer-system.md" with { type: "text" };
+import fileObserverUserPrompt from "../../commit/prompts/file-observer-user.md" with { type: "text" };
+import type { FileDiff, FileObservation } from "../../commit/types";
+import { isExcludedFile } from "../../commit/utils/exclusions";
+import { renderPromptTemplate } from "../../config/prompt-templates";
+import { truncateToTokenLimit } from "./utils";
+
+const MAX_FILE_TOKENS = 50_000;
+const MAX_CONTEXT_FILES = 20;
+const MAX_CONCURRENCY = 5;
+const MAP_PHASE_TIMEOUT_MS = 120_000;
+const MAX_RETRIES = 3;
+const RETRY_BACKOFF_MS = 1000;
+
+export interface MapPhaseInput {
+	model: Model<Api>;
+	apiKey: string;
+	files: FileDiff[];
+	config?: {
+		maxFileTokens?: number;
+		maxConcurrency?: number;
+		timeoutMs?: number;
+		maxRetries?: number;
+		retryBackoffMs?: number;
+	};
+}
+
+export async function runMapPhase({ model, apiKey, files, config }: MapPhaseInput): Promise<FileObservation[]> {
+	const filtered = files.filter(file => !isExcludedFile(file.filename));
+	const systemPrompt = renderPromptTemplate(fileObserverSystemPrompt);
+	const maxFileTokens = config?.maxFileTokens ?? MAX_FILE_TOKENS;
+	const maxConcurrency = config?.maxConcurrency ?? MAX_CONCURRENCY;
+	const timeoutMs = config?.timeoutMs ?? MAP_PHASE_TIMEOUT_MS;
+	const maxRetries = config?.maxRetries ?? MAX_RETRIES;
+	const retryBackoffMs = config?.retryBackoffMs ?? RETRY_BACKOFF_MS;
+	return runWithConcurrency(filtered, maxConcurrency, async file => {
+		if (file.isBinary) {
+			return {
+				file: file.filename,
+				observations: ["Binary file changed."],
+				additions: file.additions,
+				deletions: file.deletions,
+			};
+		}
+
+		const contextHeader = generateContextHeader(filtered, file.filename);
+		const truncated = truncateToTokenLimit(file.content, maxFileTokens);
+		const prompt = renderPromptTemplate(fileObserverUserPrompt, {
+			filename: file.filename,
+			diff: truncated,
+			context_header: contextHeader,
+		});
+		const request = {
+			systemPrompt,
+			messages: [{ role: "user", content: prompt, timestamp: Date.now() }] as Message[],
+		};
+
+		const response = await withRetry(
+			() => completeSimple(model, request, { apiKey, maxTokens: 400, signal: AbortSignal.timeout(timeoutMs) }),
+			maxRetries,
+			retryBackoffMs,
+		);
+
+		const observations = parseObservations(response);
+		return {
+			file: file.filename,
+			observations,
+			additions: file.additions,
+			deletions: file.deletions,
+		};
+	});
+}
+
+function parseObservations(message: AssistantMessage): string[] {
+	const text = message.content
+		.filter(content => content.type === "text")
+		.map(content => content.text)
+		.join("")
+		.trim();
+
+	if (!text) return [];
+
+	const lines = text
+		.split("\n")
+		.map(line => line.trim())
+		.filter(Boolean)
+		.map(line => line.replace(/^[-*]\s+/, ""))
+		.filter(Boolean);
+
+	return lines.slice(0, 5);
+}
+
+function generateContextHeader(files: FileDiff[], currentFile: string): string {
+	if (files.length > 100) {
+		return `(Large commit with ${files.length} total files)`;
+	}
+
+	const otherFiles = files.filter(file => file.filename !== currentFile);
+	if (otherFiles.length === 0) return "";
+
+	const sorted = [...otherFiles].sort((a, b) => b.additions + b.deletions - (a.additions + a.deletions));
+	const toShow = sorted.length > MAX_CONTEXT_FILES ? sorted.slice(0, MAX_CONTEXT_FILES) : sorted;
+
+	const lines = ["OTHER FILES IN THIS CHANGE:"];
+	for (const file of toShow) {
+		const lineCount = file.additions + file.deletions;
+		const description = inferFileDescription(file);
+		lines.push(`- ${file.filename} (${lineCount} lines): ${description}`);
+	}
+
+	if (toShow.length < sorted.length) {
+		lines.push(`... and ${sorted.length - toShow.length} more files`);
+	}
+
+	return lines.join("\n");
+}
+
+function inferFileDescription(file: FileDiff): string {
+	const filenameLower = file.filename.toLowerCase();
+	if (filenameLower.includes("test")) return "test file";
+	if (filenameLower.endsWith(".md")) return "documentation";
+	if (
+		filenameLower.includes("config") ||
+		filenameLower.endsWith(".toml") ||
+		filenameLower.endsWith(".yaml") ||
+		filenameLower.endsWith(".yml")
+	) {
+		return "configuration";
+	}
+	if (filenameLower.includes("error")) return "error definitions";
+	if (filenameLower.includes("type")) return "type definitions";
+	if (filenameLower.endsWith("mod.rs") || filenameLower.endsWith("lib.rs")) return "module exports";
+	if (filenameLower.endsWith("main.rs") || filenameLower.endsWith("main.go") || filenameLower.endsWith("main.py")) {
+		return "entry point";
+	}
+
+	const content = file.content;
+	if (content.includes("interface ") || content.includes("type ")) return "type definitions";
+	if (content.includes("class ") || content.includes("function ") || content.includes("fn ")) return "implementation";
+	if (content.includes("async ") || content.includes("await")) return "async code";
+	return "source code";
+}
+
+async function runWithConcurrency<T, R>(
+	items: T[],
+	limit: number,
+	worker: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+	const results = new Array<R>(items.length);
+	let nextIndex = 0;
+	const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
+		while (true) {
+			const current = nextIndex;
+			nextIndex += 1;
+			if (current >= items.length) return;
+			results[current] = await worker(items[current] as T, current);
+		}
+	});
+	await Promise.all(runners);
+	return results;
+}
+
+async function withRetry<T>(fn: () => Promise<T>, attempts: number, backoffMs: number): Promise<T> {
+	let lastError: unknown;
+	for (let attempt = 0; attempt < attempts; attempt += 1) {
+		try {
+			return await fn();
+		} catch (error) {
+			lastError = error;
+			if (attempt < attempts - 1) {
+				await Bun.sleep(backoffMs * (attempt + 1));
+			}
+		}
+	}
+	throw lastError;
+}

package/src/commit/map-reduce/reduce-phase.ts

@@ -0,0 +1,145 @@
+import type { Api, AssistantMessage, Model, ToolCall } from "@nghyane/arcane-ai";
+import { completeSimple, validateToolCall } from "@nghyane/arcane-ai";
+import { Type } from "@sinclair/typebox";
+import reduceSystemPrompt from "../../commit/prompts/reduce-system.md" with { type: "text" };
+import reduceUserPrompt from "../../commit/prompts/reduce-user.md" with { type: "text" };
+import type { ChangelogCategory, ConventionalAnalysis, FileObservation } from "../../commit/types";
+import { renderPromptTemplate } from "../../config/prompt-templates";
+
+const ReduceTool = {
+	name: "create_conventional_analysis",
+	description: "Synthesize file observations into a conventional commit analysis.",
+	parameters: Type.Object({
+		type: Type.Union([
+			Type.Literal("feat"),
+			Type.Literal("fix"),
+			Type.Literal("refactor"),
+			Type.Literal("docs"),
+			Type.Literal("test"),
+			Type.Literal("chore"),
+			Type.Literal("style"),
+			Type.Literal("perf"),
+			Type.Literal("build"),
+			Type.Literal("ci"),
+			Type.Literal("revert"),
+		]),
+		scope: Type.Union([Type.String(), Type.Null()]),
+		details: Type.Array(
+			Type.Object({
+				text: Type.String(),
+				changelog_category: Type.Optional(
+					Type.Union([
+						Type.Literal("Added"),
+						Type.Literal("Changed"),
+						Type.Literal("Fixed"),
+						Type.Literal("Deprecated"),
+						Type.Literal("Removed"),
+						Type.Literal("Security"),
+						Type.Literal("Breaking Changes"),
+					]),
+				),
+				user_visible: Type.Optional(Type.Boolean()),
+			}),
+		),
+		issue_refs: Type.Array(Type.String()),
+	}),
+};
+
+export interface ReducePhaseInput {
+	model: Model<Api>;
+	apiKey: string;
+	observations: FileObservation[];
+	stat: string;
+	scopeCandidates: string;
+	typesDescription?: string;
+}
+
+export async function runReducePhase({
+	model,
+	apiKey,
+	observations,
+	stat,
+	scopeCandidates,
+	typesDescription,
+}: ReducePhaseInput): Promise<ConventionalAnalysis> {
+	const prompt = renderPromptTemplate(reduceUserPrompt, {
+		types_description: typesDescription,
+		observations: observations.flatMap(obs => obs.observations.map(line => `- ${obs.file}: ${line}`)).join("\n"),
+		stat,
+		scope_candidates: scopeCandidates,
+	});
+	const response = await completeSimple(
+		model,
+		{
+			systemPrompt: renderPromptTemplate(reduceSystemPrompt),
+			messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+			tools: [ReduceTool],
+		},
+		{ apiKey, maxTokens: 2400 },
+	);
+
+	return parseAnalysisResponse(response);
+}
+
+function parseAnalysisResponse(message: AssistantMessage): ConventionalAnalysis {
+	const toolCall = extractToolCall(message, "create_conventional_analysis");
+	if (toolCall) {
+		const parsed = validateToolCall([ReduceTool], toolCall) as {
+			type: ConventionalAnalysis["type"];
+			scope: string | null;
+			details: Array<{ text: string; changelog_category?: ChangelogCategory; user_visible?: boolean }>;
+			issue_refs: string[];
+		};
+		return normalizeAnalysis(parsed);
+	}
+	const text = extractTextContent(message);
+	const parsed = parseJsonPayload(text) as {
+		type: ConventionalAnalysis["type"];
+		scope: string | null;
+		details: Array<{ text: string; changelog_category?: ChangelogCategory; user_visible?: boolean }>;
+		issue_refs: string[];
+	};
+	return normalizeAnalysis(parsed);
+}
+
+function parseJsonPayload(text: string): unknown {
+	const trimmed = text.trim();
+	if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+		return JSON.parse(trimmed) as unknown;
+	}
+	const match = trimmed.match(/\{[\s\S]*\}/);
+	if (!match) {
+		throw new Error("No JSON payload found in reduce response");
+	}
+	return JSON.parse(match[0]) as unknown;
+}
+
+function normalizeAnalysis(parsed: {
+	type: ConventionalAnalysis["type"];
+	scope: string | null;
+	details: Array<{ text: string; changelog_category?: ChangelogCategory; user_visible?: boolean }>;
+	issue_refs: string[];
+}): ConventionalAnalysis {
+	return {
+		type: parsed.type,
+		scope: parsed.scope?.trim() || null,
+		details: parsed.details.map(detail => ({
+			text: detail.text.trim(),
+			changelogCategory: detail.user_visible ? detail.changelog_category : undefined,
+			userVisible: detail.user_visible ?? false,
+		})),
+		issueRefs: parsed.issue_refs ?? [],
+	};
+}
+
+function extractToolCall(message: AssistantMessage, name: string): ToolCall | undefined {
+	return message.content.find(content => content.type === "toolCall" && content.name === name) as ToolCall | undefined;
+}
+
+function extractTextContent(message: AssistantMessage): string {
+	return message.content
+		.filter(content => content.type === "text")
+		.map(content => content.text)
+		.join("")
+		.trim();
+}

package/src/commit/map-reduce/utils.ts

@@ -0,0 +1,9 @@
+export function estimateTokens(text: string): number {
+	return Math.ceil(text.length / 4);
+}
+
+export function truncateToTokenLimit(text: string, maxTokens: number): string {
+	const maxChars = maxTokens * 4;
+	if (text.length <= maxChars) return text;
+	return `${text.slice(0, maxChars)}\n... (truncated)`;
+}

package/src/commit/message.ts

@@ -0,0 +1,11 @@
+import type { ConventionalAnalysis } from "./types";
+
+export function formatCommitMessage(analysis: ConventionalAnalysis, summary: string): string {
+	const scopePart = analysis.scope ? `(${analysis.scope})` : "";
+	const header = `${analysis.type}${scopePart}: ${summary}`;
+	const bodyLines = analysis.details.map(detail => `- ${detail.text.trim()}`);
+	if (bodyLines.length === 0) {
+		return header;
+	}
+	return `${header}\n\n${bodyLines.join("\n")}`;
+}