feat: implement PI-090 product tools
This commit is contained in:
357
electron/coding-projects/conversation-change-tracker.ts
Normal file
357
electron/coding-projects/conversation-change-tracker.ts
Normal file
@@ -0,0 +1,357 @@
|
||||
import { spawn } from 'node:child_process';
|
||||
import { readFile, stat } from 'node:fs/promises';
|
||||
import path from 'node:path';
|
||||
|
||||
const MAX_CHANGED_FILES = 200;
|
||||
const MAX_DIFF_BYTES = 64 * 1024;
|
||||
const MAX_UNTRACKED_PREVIEW_BYTES = 8 * 1024;
|
||||
const MAX_GIT_OUTPUT_BYTES = 8 * 1024 * 1024;
|
||||
|
||||
export type ConversationChangedFileStatus = 'added' | 'modified' | 'deleted' | 'renamed' | 'untracked';
|
||||
|
||||
export interface ConversationChangedFile {
|
||||
path: string;
|
||||
status: ConversationChangedFileStatus;
|
||||
diff?: string;
|
||||
preview?: string;
|
||||
truncated?: boolean;
|
||||
}
|
||||
|
||||
export interface ConversationChangesSnapshot {
|
||||
conversationId: string;
|
||||
runId: string;
|
||||
git: boolean;
|
||||
baselineHead: string | null;
|
||||
files: ConversationChangedFile[];
|
||||
}
|
||||
|
||||
export interface GitCommandResult {
|
||||
code: number;
|
||||
stdout: string;
|
||||
}
|
||||
|
||||
export interface ConversationGitAdapter {
|
||||
run(projectPath: string, args: readonly string[], signal?: AbortSignal): Promise<GitCommandResult>;
|
||||
}
|
||||
|
||||
export class ProcessConversationGitAdapter implements ConversationGitAdapter {
|
||||
run(projectPath: string, args: readonly string[], signal?: AbortSignal): Promise<GitCommandResult> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const child = spawn('git', ['-C', projectPath, '--literal-pathspecs', ...args], {
|
||||
windowsHide: true,
|
||||
stdio: ['ignore', 'pipe', 'pipe'],
|
||||
signal,
|
||||
env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', GIT_PAGER: 'cat' },
|
||||
});
|
||||
const chunks: Buffer[] = [];
|
||||
let bytes = 0;
|
||||
const collect = (chunk: Buffer) => {
|
||||
bytes += chunk.byteLength;
|
||||
if (bytes > MAX_GIT_OUTPUT_BYTES) {
|
||||
child.kill();
|
||||
reject(new Error('Git output is too large'));
|
||||
return;
|
||||
}
|
||||
chunks.push(chunk);
|
||||
};
|
||||
child.stdout.on('data', collect);
|
||||
child.stderr.on('data', () => undefined);
|
||||
child.once('error', reject);
|
||||
child.once('close', (code) => resolve({
|
||||
code: code ?? 1,
|
||||
stdout: Buffer.concat(chunks).toString('utf8'),
|
||||
}));
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
interface StatusEntry {
|
||||
path: string;
|
||||
status: ConversationChangedFileStatus;
|
||||
signature: string;
|
||||
}
|
||||
|
||||
interface FileState extends StatusEntry {
|
||||
content: string;
|
||||
preview?: string;
|
||||
truncated?: boolean;
|
||||
}
|
||||
|
||||
interface ChangeBaseline {
|
||||
git: boolean;
|
||||
head: string | null;
|
||||
files: Map<string, FileState>;
|
||||
}
|
||||
|
||||
interface ChangeRunRecord {
|
||||
conversationId: string;
|
||||
runId: string;
|
||||
projectPath: string;
|
||||
baseline: ChangeBaseline;
|
||||
touchedPaths: Set<string>;
|
||||
projectRefresh: boolean;
|
||||
snapshot: ConversationChangesSnapshot;
|
||||
}
|
||||
|
||||
function normalizeRelativePath(value: string): string {
|
||||
const raw = value.trim();
|
||||
const trimmed = raw.replaceAll('\\', '/');
|
||||
if (!trimmed || trimmed.includes('\0') || path.isAbsolute(raw) || path.win32.isAbsolute(raw)
|
||||
|| path.posix.isAbsolute(trimmed)) {
|
||||
throw new Error('Changed file path must be project-relative');
|
||||
}
|
||||
const normalized = path.posix.normalize(trimmed).replace(/^\.\//, '');
|
||||
if (!normalized || normalized === '.' || normalized === '..' || normalized.startsWith('../')) {
|
||||
throw new Error('Changed file path escapes the project');
|
||||
}
|
||||
return normalized;
|
||||
}
|
||||
|
||||
function statusFromSignature(signature: string, renamed: boolean): ConversationChangedFileStatus {
|
||||
if (signature === '??') return 'untracked';
|
||||
if (renamed || signature.includes('R')) return 'renamed';
|
||||
if (signature.includes('D')) return 'deleted';
|
||||
if (signature.includes('A')) return 'added';
|
||||
return 'modified';
|
||||
}
|
||||
|
||||
function parsePorcelainV2(value: string): StatusEntry[] {
|
||||
const records = value.split('\0');
|
||||
const entries: StatusEntry[] = [];
|
||||
for (let index = 0; index < records.length; index += 1) {
|
||||
const record = records[index];
|
||||
if (!record || record.startsWith('! ')) continue;
|
||||
if (record.startsWith('? ')) {
|
||||
const filePath = normalizeRelativePath(record.slice(2));
|
||||
entries.push({ path: filePath, status: 'untracked', signature: '??' });
|
||||
continue;
|
||||
}
|
||||
const renamed = record.startsWith('2 ');
|
||||
const match = renamed
|
||||
? record.match(/^2 ([^ ]+) [^ ]+ [^ ]+ [^ ]+ [^ ]+ [^ ]+ [^ ]+ [^ ]+ (.*)$/s)
|
||||
: record.match(/^1 ([^ ]+) [^ ]+ [^ ]+ [^ ]+ [^ ]+ [^ ]+ [^ ]+ (.*)$/s);
|
||||
if (!match) continue;
|
||||
const signature = match[1];
|
||||
const filePath = normalizeRelativePath(match[2]);
|
||||
entries.push({
|
||||
path: filePath,
|
||||
status: statusFromSignature(signature, renamed),
|
||||
signature,
|
||||
});
|
||||
if (renamed) index += 1;
|
||||
}
|
||||
return entries.slice(0, MAX_CHANGED_FILES);
|
||||
}
|
||||
|
||||
function boundedText(value: string, maxBytes: number): { text: string; truncated: boolean } {
|
||||
const data = Buffer.from(value, 'utf8');
|
||||
if (data.byteLength <= maxBytes) return { text: value, truncated: false };
|
||||
return { text: data.subarray(0, maxBytes).toString('utf8'), truncated: true };
|
||||
}
|
||||
|
||||
async function untrackedPreview(
|
||||
projectPath: string,
|
||||
relativePath: string,
|
||||
): Promise<{ preview?: string; content: string; truncated?: boolean }> {
|
||||
const target = path.resolve(projectPath, ...relativePath.split('/'));
|
||||
const relative = path.relative(path.resolve(projectPath), target);
|
||||
if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
|
||||
throw new Error('Changed file path escapes the project');
|
||||
}
|
||||
try {
|
||||
const file = await stat(target);
|
||||
if (!file.isFile()) return { content: 'not-file' };
|
||||
const data = await readFile(target);
|
||||
const bounded = data.subarray(0, MAX_UNTRACKED_PREVIEW_BYTES);
|
||||
if (bounded.includes(0)) return { content: `binary:${data.byteLength}` };
|
||||
const preview = bounded.toString('utf8');
|
||||
return {
|
||||
preview,
|
||||
content: `text:${data.byteLength}:${preview}`,
|
||||
...(data.byteLength > bounded.byteLength ? { truncated: true } : {}),
|
||||
};
|
||||
} catch (error) {
|
||||
if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
|
||||
return { content: 'missing' };
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
export class ConversationChangeTracker {
|
||||
private readonly records = new Map<string, ChangeRunRecord>();
|
||||
private readonly queues = new Map<string, Promise<void>>();
|
||||
|
||||
constructor(private readonly git: ConversationGitAdapter = new ProcessConversationGitAdapter()) {}
|
||||
|
||||
async beginRun(input: {
|
||||
conversationId: string;
|
||||
runId: string;
|
||||
projectPath: string;
|
||||
}): Promise<ConversationChangesSnapshot> {
|
||||
return await this.lock(input.conversationId, async () => {
|
||||
const current = this.records.get(input.conversationId);
|
||||
if (current?.runId === input.runId) return structuredClone(current.snapshot);
|
||||
const baseline = await this.capture(input.projectPath);
|
||||
const snapshot: ConversationChangesSnapshot = {
|
||||
conversationId: input.conversationId,
|
||||
runId: input.runId,
|
||||
git: baseline.git,
|
||||
baselineHead: baseline.head,
|
||||
files: [],
|
||||
};
|
||||
this.records.set(input.conversationId, {
|
||||
...input,
|
||||
baseline,
|
||||
touchedPaths: new Set(),
|
||||
projectRefresh: false,
|
||||
snapshot,
|
||||
});
|
||||
return structuredClone(snapshot);
|
||||
});
|
||||
}
|
||||
|
||||
async recordTouchedPaths(
|
||||
conversationId: string,
|
||||
runId: string,
|
||||
paths: readonly string[],
|
||||
refresh = true,
|
||||
): Promise<ConversationChangesSnapshot> {
|
||||
return await this.lock(conversationId, async () => {
|
||||
const record = this.requireRun(conversationId, runId);
|
||||
for (const filePath of paths) record.touchedPaths.add(normalizeRelativePath(filePath));
|
||||
if (refresh) record.snapshot = await this.refresh(record, false);
|
||||
return structuredClone(record.snapshot);
|
||||
});
|
||||
}
|
||||
|
||||
async markProjectRefresh(conversationId: string, runId: string): Promise<void> {
|
||||
await this.lock(conversationId, async () => {
|
||||
this.requireRun(conversationId, runId).projectRefresh = true;
|
||||
});
|
||||
}
|
||||
|
||||
async settleRun(conversationId: string, runId: string): Promise<ConversationChangesSnapshot | null> {
|
||||
return await this.lock(conversationId, async () => {
|
||||
const record = this.records.get(conversationId);
|
||||
if (!record || record.runId !== runId) return null;
|
||||
record.snapshot = await this.refresh(record, record.projectRefresh || record.touchedPaths.size === 0);
|
||||
return structuredClone(record.snapshot);
|
||||
});
|
||||
}
|
||||
|
||||
getSnapshot(conversationId: string): ConversationChangesSnapshot | null {
|
||||
const snapshot = this.records.get(conversationId)?.snapshot;
|
||||
return snapshot ? structuredClone(snapshot) : null;
|
||||
}
|
||||
|
||||
private async capture(projectPath: string): Promise<ChangeBaseline> {
|
||||
const repository = await this.git.run(projectPath, ['rev-parse', '--is-inside-work-tree']);
|
||||
if (repository.code !== 0 || repository.stdout.trim() !== 'true') {
|
||||
return { git: false, head: null, files: new Map() };
|
||||
}
|
||||
const [headResult, statusResult] = await Promise.all([
|
||||
this.git.run(projectPath, ['rev-parse', 'HEAD']),
|
||||
this.git.run(projectPath, ['status', '--porcelain=v2', '-z', '--untracked-files=all', '--', '.']),
|
||||
]);
|
||||
if (statusResult.code !== 0) return { git: false, head: null, files: new Map() };
|
||||
const entries = parsePorcelainV2(statusResult.stdout);
|
||||
const files = new Map<string, FileState>();
|
||||
for (const entry of entries) files.set(entry.path, await this.readState(projectPath, entry));
|
||||
return {
|
||||
git: true,
|
||||
head: headResult.code === 0 ? headResult.stdout.trim() || null : null,
|
||||
files,
|
||||
};
|
||||
}
|
||||
|
||||
private async currentStates(projectPath: string): Promise<Map<string, FileState>> {
|
||||
const status = await this.git.run(
|
||||
projectPath,
|
||||
['status', '--porcelain=v2', '-z', '--untracked-files=all', '--', '.'],
|
||||
);
|
||||
if (status.code !== 0) return new Map();
|
||||
const result = new Map<string, FileState>();
|
||||
for (const entry of parsePorcelainV2(status.stdout)) {
|
||||
result.set(entry.path, await this.readState(projectPath, entry));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private async readState(projectPath: string, entry: StatusEntry): Promise<FileState> {
|
||||
if (entry.status === 'untracked') {
|
||||
return { ...entry, ...await untrackedPreview(projectPath, entry.path) };
|
||||
}
|
||||
const [working, staged] = await Promise.all([
|
||||
this.git.run(projectPath, ['diff', '--no-ext-diff', '--no-color', '--relative', '--', entry.path]),
|
||||
this.git.run(projectPath, ['diff', '--cached', '--no-ext-diff', '--no-color', '--relative', '--', entry.path]),
|
||||
]);
|
||||
const bounded = boundedText(`${staged.stdout}${working.stdout}`, MAX_DIFF_BYTES);
|
||||
return {
|
||||
...entry,
|
||||
content: bounded.text,
|
||||
...(bounded.truncated ? { truncated: true } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
private async refresh(record: ChangeRunRecord, projectWide: boolean): Promise<ConversationChangesSnapshot> {
|
||||
if (!record.baseline.git) {
|
||||
const files: ConversationChangedFile[] = [];
|
||||
for (const filePath of [...record.touchedPaths].sort().slice(0, MAX_CHANGED_FILES)) {
|
||||
const current = await untrackedPreview(record.projectPath, filePath);
|
||||
files.push({
|
||||
path: filePath,
|
||||
status: current.content === 'missing' ? 'deleted' : 'modified',
|
||||
...(current.preview !== undefined ? { preview: current.preview } : {}),
|
||||
...(current.truncated ? { truncated: true } : {}),
|
||||
});
|
||||
}
|
||||
return { ...record.snapshot, files };
|
||||
}
|
||||
const current = await this.currentStates(record.projectPath);
|
||||
const candidates = projectWide
|
||||
? [...current.keys(), ...record.baseline.files.keys()]
|
||||
: [...record.touchedPaths];
|
||||
const files: ConversationChangedFile[] = [];
|
||||
for (const filePath of [...new Set(candidates)].sort().slice(0, MAX_CHANGED_FILES)) {
|
||||
const next = current.get(filePath);
|
||||
const baseline = record.baseline.files.get(filePath);
|
||||
if (!next) {
|
||||
if (baseline) {
|
||||
files.push({
|
||||
path: filePath,
|
||||
status: baseline.status === 'untracked' ? 'deleted' : 'modified',
|
||||
});
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (baseline?.signature === next.signature && baseline.content === next.content) continue;
|
||||
files.push({
|
||||
path: next.path,
|
||||
status: next.status,
|
||||
...(next.status === 'untracked' && next.preview !== undefined ? { preview: next.preview } : {}),
|
||||
...(next.status !== 'untracked' && next.content ? { diff: next.content } : {}),
|
||||
...(next.truncated ? { truncated: true } : {}),
|
||||
});
|
||||
}
|
||||
return { ...record.snapshot, files };
|
||||
}
|
||||
|
||||
private requireRun(conversationId: string, runId: string): ChangeRunRecord {
|
||||
const record = this.records.get(conversationId);
|
||||
if (!record || record.runId !== runId) throw new Error('Conversation change run is stale');
|
||||
return record;
|
||||
}
|
||||
|
||||
private async lock<T>(conversationId: string, operation: () => Promise<T>): Promise<T> {
|
||||
const previous = this.queues.get(conversationId) ?? Promise.resolve();
|
||||
const flight = previous.catch(() => undefined).then(operation);
|
||||
const tail = flight.then(() => undefined, () => undefined);
|
||||
this.queues.set(conversationId, tail);
|
||||
try {
|
||||
return await flight;
|
||||
} finally {
|
||||
if (this.queues.get(conversationId) === tail) this.queues.delete(conversationId);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user