@payconductor/houndsman 0.2.0 → 0.4.0

package/src/core/engine/review-session.ts

@@ -0,0 +1,79 @@
+/**
+ * Sessão de uma run (engine) — amarra opções, branch, storage e staging.
+ *
+ * É o ponto de entrada do `prepare`/`finalize` para o CLI e para o engine.
+ */
+
+import type { HoundsmanConfig } from "../config";
+import {
+	type FinalizeResult,
+	finalize,
+	type PrepareResult,
+	prepare,
+	type ReviewContext,
+	type ReviewOptions,
+	resolveBranch,
+	reviewContext,
+} from "../orchestrator";
+import { sanitizeBranch } from "../report-builder";
+import type { RepoIdentity, StorageProvider } from "../storage/types";
+
+/** Uma revisão em andamento (prepare ou finalize). */
+export class ReviewSession {
+	readonly config: HoundsmanConfig;
+	readonly options: ReviewOptions;
+	readonly branch: string;
+	readonly context: ReviewContext;
+
+	constructor(
+		config: HoundsmanConfig,
+		options: ReviewOptions,
+		branch: string,
+		storage: StorageProvider,
+		repo: RepoIdentity,
+	) {
+		this.config = config;
+		this.options = options;
+		this.branch = branch;
+		const review = options.finalize
+			? storage.findReview(repo.key, branch)
+			: storage.getOrCreateReview({
+					repo,
+					branch,
+					slug: sanitizeBranch(branch),
+					base: options.base,
+					head: options.head,
+				});
+		if (!review) {
+			throw new Error(
+				`Nenhuma revisão para '${branch}'. Rode \`houndsman\` (preparar) primeiro.`,
+			);
+		}
+		this.context = reviewContext(storage, review);
+	}
+
+	/** Resolve a branch (opção explícita ou a atual do git). */
+	static from(
+		config: HoundsmanConfig,
+		options: ReviewOptions,
+		storage: StorageProvider,
+		repo: RepoIdentity,
+	): ReviewSession {
+		return new ReviewSession(config, options, resolveBranch(options), storage, repo);
+	}
+
+	/** Passo 1 — preparar. */
+	prepare(): Promise<PrepareResult> {
+		return prepare(this.options, this.branch, this.config, this.context);
+	}
+
+	/** Passo 3 — finalizar. */
+	finalize(): FinalizeResult {
+		return finalize(this.options, this.branch, this.config, this.context);
+	}
+
+	/** Executa o passo escolhido em `--finalize`. */
+	run(): Promise<PrepareResult | FinalizeResult> {
+		return this.options.finalize ? Promise.resolve(this.finalize()) : this.prepare();
+	}
+}

package/src/core/file-classifier.ts

@@ -8,7 +8,9 @@
 import { readFileSync } from "node:fs";
 import type { HoundsmanConfig } from "./config";
 import { churnToRecord, collectChurn, type DiffSource } from "./diff-source";
-import type { ChurnMap, ClassifyRule, WatchdogDefinition } from "./types";
+import { matchesClassifyRule } from "./domain/watchdog";
+import { runGit } from "./git-runner";
+import type { ChurnMap, WatchdogDefinition } from "./types";
 
 type FileStatus = "added" | "modified" | "deleted" | "renamed" | "copied" | "unknown";
 
@@ -42,9 +44,6 @@ export type ClassificationResult = {
 // Matchers genéricos (reutilizados pelo projeto)
 // ---------------------------------------------------------------------------
 
-/** Tipo de classificação assumido quando `type` é omitido. */
-const DEFAULT_CLASSIFY_TYPE: NonNullable<ClassifyRule["type"]> = "filename";
-
 /** `true` se há entradas de conteúdo (as únicas que exigem ler o arquivo). */
 function hasContentRules<TId extends string>(
 	watchdogs: Record<TId, WatchdogDefinition>,
@@ -64,18 +63,6 @@ function readFileContent(filePath: string): string | undefined {
 	}
 }
 
-/** `true` se o arquivo casa a entrada de classificação. */
-function matchesClassifyRule(
-	filePath: string,
-	rule: ClassifyRule,
-	content: string | undefined,
-): boolean {
-	if ((rule.type ?? DEFAULT_CLASSIFY_TYPE) === "content") {
-		return content !== undefined && new RegExp(rule.value).test(content);
-	}
-	return new RegExp(rule.value).test(filePath);
-}
-
 /** Watchdogs que declaram o arquivo (união dos `classify`). */
 export function matchWatchdogs<TId extends string>(
 	filePath: string,
@@ -101,22 +88,6 @@ export function isExcludedPath(filePath: string, patterns: readonly RegExp[]): b
 	return patterns.some((pattern) => pattern.test(filePath));
 }
 
-// ---------------------------------------------------------------------------
-// Execução do git diff
-// ---------------------------------------------------------------------------
-
-function runGitDiff(base: string, head: string): string {
-	const result = Bun.spawnSync(["git", "diff", `${base}...${head}`, "--name-status"], {
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-	if (result.exitCode !== 0) {
-		const stderr = new TextDecoder().decode(result.stderr).trim();
-		throw new Error(`git diff falhou (base='${base}', head='${head}'): ${stderr}`);
-	}
-	return new TextDecoder().decode(result.stdout);
-}
-
 // ---------------------------------------------------------------------------
 // Parsing de `git diff --name-status`
 // ---------------------------------------------------------------------------
@@ -248,7 +219,7 @@ export function classifyRange<TId extends string>(
 	config: HoundsmanConfig<TId>,
 	diff?: DiffSource,
 ): ClassificationResult {
-	const entries = parseEntries(runGitDiff(base, head));
+	const entries = parseEntries(runGit(["diff", `${base}...${head}`, "--name-status"]));
 	const churn = diff?.churn ?? collectChurn(base, head);
 	const result = classifyEntries(entries, config, churnToRecord(churn));
 	result.base = base;
@@ -257,39 +228,12 @@ export function classifyRange<TId extends string>(
 }
 
 // ---------------------------------------------------------------------------
-// Triage (PRs grandes)
+// Triage (PRs grandes) — reexportado do domínio
 // ---------------------------------------------------------------------------
 
-/** Churn total (adições + remoções) de um arquivo; 0 quando ausente. */
-export function churnOf(filePath: string, churn: ChurnMap | undefined): number {
-	const entry = churn?.[filePath];
-	return entry ? entry.additions + entry.deletions : 0;
-}
-
-/** Ordena os arquivos por risco (churn desc; empate pelo caminho). */
-export function sortByRisk(files: readonly string[], churn?: ChurnMap): string[] {
-	return [...files].sort((a, b) => {
-		const delta = churnOf(b, churn) - churnOf(a, churn);
-		return delta !== 0 ? delta : a.localeCompare(b);
-	});
-}
-
-/** Resultado da aplicação do orçamento: o que revisar e o que ficou de fora. */
-export type BudgetSelection = { selected: string[]; overflow: string[] };
-
-/**
- * Aplica o orçamento por brief: mantém os `maxFiles` de maior risco e devolve o
- * restante em `overflow` (nunca descarta silenciosamente). `maxFiles` não-positivo
- * ou não-finito desativa o orçamento.
- */
-export function selectByBudget(
-	files: readonly string[],
-	churn: ChurnMap | undefined,
-	maxFiles: number,
-): BudgetSelection {
-	const ordered = sortByRisk(files, churn);
-	if (!Number.isFinite(maxFiles) || maxFiles <= 0 || ordered.length <= maxFiles) {
-		return { selected: ordered, overflow: [] };
-	}
-	return { selected: ordered.slice(0, maxFiles), overflow: ordered.slice(maxFiles) };
-}
+export {
+	type BudgetSelection,
+	churnOf,
+	selectByBudget,
+	sortByRisk,
+} from "./domain/budget";

package/src/core/findings-state.ts

@@ -1,18 +1,16 @@
 /**
  * Estado de triagem dos findings (biblioteca).
  *
- * Persistido em `.houndsman/.runs/<slug>/state.json` (local — coberto pelo
- * `.gitignore` gerado, que ignora `.runs/`). Cada finding tem um `id` curto e um
- * `fingerprint` de conteúdo: nas re-execuções do `--finalize` o estado é
- * preservado casando por fingerprint.
+ * O dump (`state.json`) é um detalhe do provider de arquivos; no SQLite o
+ * estado é reconstruído de `findings` + `finding_history`. Cada finding tem um
+ * `id` curto e um `fingerprint` de conteúdo: nas re-execuções do `--finalize`
+ * o estado é preservado casando por fingerprint.
  *
  * A `line` é cache — `syncState` a recalcula após edições (auto-fix) e marca
  * `stale` quando a âncora some.
  */
 
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
 import {
 	buildAnchor,
 	type FindingAnchor,
@@ -20,16 +18,13 @@ import {
 	locateAnchor,
 	reanchor,
 } from "./finding-anchor";
-import { STATE_FILE } from "./paths";
-import {
-	dedupeFindings,
-	type MergedFinding,
-	parseWatchdogReport,
-	sanitizeBranch,
-	type WatchdogReport,
-} from "./report-builder";
+import { type MergedFinding, sanitizeBranch } from "./report-builder";
+import { systemClock } from "./services/clock";
+import { type FileReader, ProjectFiles } from "./services/project-files";
 import { SEVERITY_ORDER, type Severity, severityRank } from "./types";
 
+export type { FileReader };
+
 // ---------------------------------------------------------------------------
 // Tipos
 // ---------------------------------------------------------------------------
@@ -138,29 +133,9 @@ export const FINDINGS_STATE_VERSION = 2;
 // Caminhos
 // ---------------------------------------------------------------------------
 
-/** Diretório de artefatos da run (branch-slug). */
-export function runDir(artifactDir: string, branch: string): string {
-	return join(artifactDir, sanitizeBranch(branch));
-}
-
-/** Caminho do `state.json` da run. */
-export function stateFile(artifactDir: string, branch: string): string {
-	return join(runDir(artifactDir, branch), STATE_FILE);
-}
-
-/** Leitor de arquivos relativos à raiz do projeto (injetável nos testes). */
-export type FileReader = (relativePath: string) => string | null;
-
 /** Leitor padrão a partir do cwd (null se ausente/ilegível). */
 export function fileReader(cwd: string): FileReader {
-	return (relativePath: string) => {
-		try {
-			const full = join(cwd, relativePath);
-			return existsSync(full) ? readFileSync(full, "utf8") : null;
-		} catch {
-			return null;
-		}
-	};
+	return new ProjectFiles(cwd).reader();
 }
 
 /** Id curto aleatório (hex) para um finding novo. */
@@ -174,7 +149,7 @@ export function emptyState(branch: string): FindingsStateFile {
 		version: FINDINGS_STATE_VERSION,
 		branch,
 		slug: sanitizeBranch(branch),
-		updatedAt: new Date().toISOString(),
+		updatedAt: systemClock(),
 		order: [],
 		findings: {},
 	};
@@ -270,6 +245,32 @@ export function filterFindings(
 		.sort(compareFindings);
 }
 
+/** Resultado da resolução de um id (completo ou prefixo único). */
+export type FindingIdResolution =
+	| { status: "found"; id: string }
+	| { status: "ambiguous"; matches: string[] }
+	| { status: "missing" };
+
+/**
+ * Resolve um id de finding: exato primeiro, depois prefixo único.
+ * Ambíguo devolve os candidatos para a mensagem de erro.
+ */
+export function resolveFindingId(
+	state: FindingsStateFile,
+	input: string,
+): FindingIdResolution {
+	const needle = input.trim();
+	if (needle.length === 0) return { status: "missing" };
+	if (state.findings[needle]) return { status: "found", id: needle };
+
+	const matches = Object.keys(state.findings).filter((id) =>
+		id.toLowerCase().startsWith(needle.toLowerCase()),
+	);
+	if (matches.length === 1) return { status: "found", id: matches[0] };
+	if (matches.length > 1) return { status: "ambiguous", matches };
+	return { status: "missing" };
+}
+
 // ---------------------------------------------------------------------------
 // Construção (finalize)
 // ---------------------------------------------------------------------------
@@ -297,7 +298,7 @@ export function buildStateFromFindings(
 	merged: readonly MergedFinding[],
 	options: BuildStateOptions,
 ): FindingsStateFile {
-	const now = options.now ?? new Date().toISOString();
+	const now = options.now ?? systemClock();
 	const previous = options.previous ?? null;
 
 	const result: Record<string, FindingState> = {};
@@ -383,47 +384,6 @@ export function buildStateFromFindings(
 	return state;
 }
 
-/**
- * Reconstrói o estado a partir dos artefatos da run (`classification.json` +
- * `findings/<id>.json`), sem exigir `--finalize`. Devolve null se não houver
- * findings gravados.
- */
-export function buildStateFromRunDir(
-	outDir: string,
-	branch: string,
-	readFile: FileReader,
-): FindingsStateFile | null {
-	const classificationPath = join(outDir, "classification.json");
-	if (!existsSync(classificationPath)) return null;
-
-	let activeIds: string[] = [];
-	try {
-		const classification = JSON.parse(readFileSync(classificationPath, "utf8")) as {
-			watchdogs?: Record<string, string[]>;
-		};
-		activeIds = Object.keys(classification.watchdogs ?? {});
-	} catch {
-		return null;
-	}
-
-	const reports: WatchdogReport[] = [];
-	for (const id of activeIds) {
-		const path = join(outDir, "findings", `${id}.json`);
-		if (!existsSync(path)) continue;
-		try {
-			const report = parseWatchdogReport(
-				JSON.parse(readFileSync(path, "utf8")),
-				path,
-			);
-			if (report) reports.push(report);
-		} catch {
-			// Ignora findings ilegíveis — reconstrução best-effort.
-		}
-	}
-	if (reports.length === 0) return null;
-
-	return buildStateFromFindings(dedupeFindings(reports), { branch, readFile });
-}
 // ---------------------------------------------------------------------------
 
 export type FindingUpdate = {
@@ -437,7 +397,7 @@ export type FindingUpdate = {
 export function applyFindingUpdate(
 	finding: FindingState,
 	update: FindingUpdate,
-	now: string = new Date().toISOString(),
+	now: string = systemClock(),
 ): FindingState {
 	if (update.decision && DECISION_SET.has(update.decision)) {
 		finding.decision = update.decision;
@@ -471,7 +431,7 @@ export type SyncResult = {
 export function syncState(
 	state: FindingsStateFile,
 	readFile: FileReader,
-	now: string = new Date().toISOString(),
+	now: string = systemClock(),
 ): SyncResult {
 	const moved: string[] = [];
 	const stale: string[] = [];
@@ -521,55 +481,188 @@ export function occurrenceCount(
 }
 
 // ---------------------------------------------------------------------------
-// Store (I/O atômico)
+// Domínio (classes)
+// ---------------------------------------------------------------------------
+
+/** Um finding triável, com comportamento sobre o DTO serializável. */
+export class Finding {
+	readonly state: FindingState;
+
+	constructor(state: FindingState) {
+		this.state = state;
+	}
+
+	static from(state: FindingState): Finding {
+		return new Finding(state);
+	}
+
+	get id(): string {
+		return this.state.id;
+	}
+
+	get file(): string {
+		return this.state.file;
+	}
+
+	get line(): number | null {
+		return this.state.line;
+	}
+
+	get severity(): Severity {
+		return this.state.severity;
+	}
+
+	get decision(): FindingDecision {
+		return this.state.decision;
+	}
+
+	get execState(): FindingExecState {
+		return this.state.execState;
+	}
+
+	get present(): boolean {
+		return this.state.present;
+	}
+
+	get isDone(): boolean {
+		return this.state.execState === "done";
+	}
+
+	/** Aplica uma atualização (com histórico) e devolve o próprio finding. */
+	apply(update: FindingUpdate, now: string = systemClock()): Finding {
+		applyFindingUpdate(this.state, update, now);
+		return this;
+	}
+
+	/** Payload serializável (mesmo shape do `state.json`). */
+	toJSON(): FindingState {
+		return this.state;
+	}
+}
+
+/** Coleção de triagem de uma run — superfície OO sobre o dump persistido. */
+export class FindingsState {
+	readonly file: FindingsStateFile;
+
+	constructor(file: FindingsStateFile) {
+		this.file = file;
+	}
+
+	static from(file: FindingsStateFile): FindingsState {
+		return new FindingsState(file);
+	}
+
+	static empty(branch: string): FindingsState {
+		return new FindingsState(emptyState(branch));
+	}
+
+	get branch(): string {
+		return this.file.branch;
+	}
+
+	get reviewed(): FindingsReviewed | undefined {
+		return this.file.reviewed;
+	}
+
+	/** Findings na ordem de exibição (`order`). */
+	list(): Finding[] {
+		return this.file.order
+			.map((id) => this.file.findings[id])
+			.filter((state): state is FindingState => Boolean(state))
+			.map((state) => Finding.from(state));
+	}
+
+	/** Busca por id. */
+	get(id: string): Finding | null {
+		const state = this.file.findings[id];
+		return state ? Finding.from(state) : null;
+	}
+
+	/** Todos os findings (ordem de inserção, sem o `order`). */
+	values(): Finding[] {
+		return Object.values(this.file.findings).map((state) => Finding.from(state));
+	}
+
+	/** Somente os presentes no último relatório. */
+	present(): Finding[] {
+		return this.values().filter((finding) => finding.present);
+	}
+
+	/** Filtra pela ordem canônica (presentes → severidade → arquivo → linha). */
+	filter(filter: FindingsFilter = {}): Finding[] {
+		return filterFindings(this.file, filter).map((state) => Finding.from(state));
+	}
+
+	/** Contagens por decisão, execução e severidade. */
+	summarize(): FindingsSummary {
+		return summarize(this.file);
+	}
+
+	/** Reordena os ids pela ordenação canônica. */
+	reorder(): void {
+		reorder(this.file);
+	}
+
+	/** Aplica uma atualização a um finding e devolve-o (null se ausente). */
+	apply(id: string, update: FindingUpdate, now?: string): Finding | null {
+		const state = this.file.findings[id];
+		if (!state) return null;
+		applyFindingUpdate(state, update, now);
+		return Finding.from(state);
+	}
+
+	/** Reancora os presentes contra os arquivos atuais. */
+	sync(readFile: FileReader, now?: string): SyncResult {
+		return syncState(this.file, readFile, now);
+	}
+
+	/** Payload serializável (mesmo shape do `state.json`). */
+	toJSON(): FindingsStateFile {
+		return this.file;
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Repository (I/O atômico)
 // ---------------------------------------------------------------------------
 
 /** Persistência do `state.json` — escrita atômica (tmp + rename). */
-export class FindingsStateStore {
+export class FindingsRepository {
 	private readonly path: string;
 	private readonly branch: string;
+	private readonly files = new ProjectFiles();
 
 	constructor(path: string, branch: string) {
 		this.path = path;
 		this.branch = branch;
 	}
 
-	/** Store para a run de uma branch. */
-	static at(artifactDir: string, branch: string): FindingsStateStore {
-		return new FindingsStateStore(stateFile(artifactDir, branch), branch);
-	}
-
 	get filePath(): string {
 		return this.path;
 	}
 
 	/** Lê o estado; null se ausente/inválido. */
 	read(): FindingsStateFile | null {
-		if (!existsSync(this.path)) return null;
-		try {
-			const raw = JSON.parse(readFileSync(this.path, "utf8")) as FindingsStateFile;
-			if (raw?.version !== FINDINGS_STATE_VERSION || !raw.findings) return null;
-			return raw;
-		} catch {
-			return null;
-		}
+		const raw = this.files.readJson<FindingsStateFile>(this.path);
+		if (!raw || raw.version !== FINDINGS_STATE_VERSION || !raw.findings) return null;
+		return raw;
 	}
 
 	/** Grava o estado de forma atômica. */
 	write(state: FindingsStateFile): void {
-		mkdirSync(dirname(this.path), { recursive: true });
-		const tmp = `${this.path}.${process.pid}.tmp`;
-		writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
-		renameSync(tmp, this.path);
+		this.files.writeAtomic(this.path, `${JSON.stringify(state, null, 2)}\n`);
 	}
 
 	/** Lê-modifica-grava; parte de um estado vazio se não existir. */
 	update(mutator: (state: FindingsStateFile) => void): FindingsStateFile {
 		const state = this.read() ?? emptyState(this.branch);
 		mutator(state);
-		state.updatedAt = new Date().toISOString();
+		state.updatedAt = systemClock();
 		reorder(state);
 		this.write(state);
 		return state;
 	}
 }
+
+/** Nome anterior do repository (compatibilidade da API pública). */
+export { FindingsRepository as FindingsStateStore };

package/src/core/git-revision.ts

@@ -11,31 +11,20 @@
  * (`parseEntries`) — não reimplementa leitura de diff.
  */
 
-import {
-	DEFAULT_MAX_PER_FILE_CHARS,
-	type DiffSource,
-	parseDiffIndex,
-	parseNumstat,
-} from "./diff-source";
+import { DEFAULT_MAX_PER_FILE_CHARS, type DiffSource } from "./diff-source";
 import { parseEntries } from "./file-classifier";
+import { runGit } from "./git-runner";
+import { GitRepository } from "./services/git-repository";
 import type { FileChurn } from "./types";
 
-/** Executa `git` (paths literais) e devolve o stdout; lança se falhar. */
-export function runGit(args: string[]): string {
-	const result = Bun.spawnSync(["git", "-c", "core.quotepath=false", ...args], {
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-	if (result.exitCode !== 0) {
-		const stderr = new TextDecoder().decode(result.stderr).trim();
-		throw new Error(`git ${args.join(" ")} falhou: ${stderr}`);
-	}
-	return new TextDecoder().decode(result.stdout);
-}
+export { runGit };
+
+/** Repositório padrão (runner real) usado pelos helpers funcionais. */
+const git = new GitRepository();
 
 /** SHA completo de uma ref (`git rev-parse`). Lança se a ref não resolver. */
 export function resolveSha(ref: string): string {
-	return runGit(["rev-parse", ref]).trim();
+	return git.resolveSha(ref);
 }
 
 /** SHA do commit atual (`HEAD`). */
@@ -50,31 +39,22 @@ export function currentHeadSha(): string {
  * comportamento seguro.
  */
 export function isAncestor(ancestor: string, descendant: string): boolean {
-	const result = Bun.spawnSync(
-		["git", "merge-base", "--is-ancestor", ancestor, descendant],
-		{ stdout: "ignore", stderr: "ignore" },
-	);
-	return result.exitCode === 0;
+	return git.isAncestor(ancestor, descendant);
 }
 
 /** Conteúdo de um arquivo num commit (`git show sha:path`); null se ausente. */
 export function readFileAt(sha: string, path: string): string | null {
-	const result = Bun.spawnSync(
-		["git", "-c", "core.quotepath=false", "show", `${sha}:${path}`],
-		{ stdout: "pipe", stderr: "ignore" },
-	);
-	if (result.exitCode !== 0) return null;
-	return new TextDecoder().decode(result.stdout);
+	return git.readFileAt(sha, path);
 }
 
 /** Arquivos alterados num intervalo (`git diff range --name-status`). */
 export function diffEntries(range: string): ReturnType<typeof parseEntries> {
-	return parseEntries(runGit(["diff", range, "--name-status"]));
+	return parseEntries(git.run(["diff", range, "--name-status"]));
 }
 
 /** Churn por arquivo de um intervalo (`git diff --numstat -z range`). */
 export function diffNumstat(range: string): Map<string, FileChurn> {
-	return parseNumstat(runGit(["diff", "--numstat", "-z", range]));
+	return git.diffNumstat(range);
 }
 
 /**
@@ -86,9 +66,7 @@ export function diffPatch(
 	paths?: readonly string[],
 	maxPerFileChars: number = DEFAULT_MAX_PER_FILE_CHARS,
 ): Map<string, string> {
-	const args = ["diff", range];
-	if (paths && paths.length > 0) args.push("--", ...paths);
-	return parseDiffIndex(runGit(args), maxPerFileChars);
+	return git.diffPatch(range, paths, maxPerFileChars);
 }
 
 /** Diff (patch + churn) de `from..to` — 2 spawns, base do review incremental. */
@@ -97,9 +75,5 @@ export function collectDiffSince(
 	to: string,
 	maxPerFileChars: number = DEFAULT_MAX_PER_FILE_CHARS,
 ): DiffSource {
-	const range = `${from}..${to}`;
-	return {
-		byFile: parseDiffIndex(runGit(["diff", range]), maxPerFileChars),
-		churn: diffNumstat(range),
-	};
+	return git.collectDiffSince(from, to, maxPerFileChars);
 }