@eddacraft/anvil-core 0.1.0

package/dist/provenance/git-ai-standard/git-notes.js

@@ -0,0 +1,292 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { tmpdir } from 'node:os';
+import { serializeAuthorshipLog, parseAuthorshipLog } from './serializer.js';
+import { createDebugger } from '../../utils/debug.js';
+const debug = createDebugger('git-ai-notes');
+const execFileAsync = promisify(execFile);
+/**
+ * Validate a git commit SHA or ref to prevent shell injection
+ * Allows: hex characters (SHA), alphanumeric, dash, underscore, slash, tilde, caret, @, dot
+ */
+function isValidGitRef(ref) {
+    return /^[a-zA-Z0-9_.~^@/-]+$/.test(ref) && ref.length > 0 && ref.length <= 256;
+}
+/**
+ * Validate a git remote name to prevent shell injection
+ * Allows: alphanumeric, dash, underscore, dot
+ */
+function isValidRemoteName(remote) {
+    return /^[a-zA-Z0-9_.-]+$/.test(remote) && remote.length > 0 && remote.length <= 128;
+}
+/**
+ * Validate a git revision range to prevent shell injection
+ * Allows: hex characters, alphanumeric, dash, underscore, dot, tilde, caret, @, colon
+ */
+function isValidRevisionRange(range) {
+    return /^[a-zA-Z0-9_.~^@:-]+$/.test(range) && range.length > 0 && range.length <= 512;
+}
+/**
+ * Git Notes namespace for AI authorship logs
+ * Per Git AI Standard v3.0.0
+ */
+export const NOTES_REF = 'refs/notes/ai';
+/**
+ * Write an authorship log to Git Notes for a commit
+ *
+ * @param commitSha - The commit SHA to attach the note to
+ * @param log - The authorship log to write
+ * @param workspaceRoot - The repository root directory
+ */
+export async function writeAuthorshipNote(commitSha, log, workspaceRoot) {
+    if (!isValidGitRef(commitSha)) {
+        throw new Error(`Invalid commit SHA: ${commitSha}`);
+    }
+    const content = serializeAuthorshipLog(log);
+    // Write content to a temp file in OS temp directory to avoid issues with
+    // worktrees/submodules where .git may be a file, not a directory
+    const { writeFile, unlink } = await import('node:fs/promises');
+    const { join } = await import('node:path');
+    const { randomUUID } = await import('node:crypto');
+    const tempFile = join(tmpdir(), `anvil-note-${randomUUID()}.tmp`);
+    try {
+        await writeFile(tempFile, content, 'utf-8');
+        await execFileAsync('git', ['notes', `--ref=${NOTES_REF}`, 'add', '-f', '-F', tempFile, '--', commitSha], {
+            cwd: workspaceRoot,
+        });
+        debug(`Wrote authorship note for commit ${commitSha.slice(0, 8)}`);
+    }
+    catch (error) {
+        debug('Failed to write authorship note', error);
+        throw new Error(`Failed to write authorship note: ${error}`);
+    }
+    finally {
+        // Clean up temp file
+        try {
+            await unlink(tempFile);
+        }
+        catch (cleanupError) {
+            debug('Failed to clean up temp file', { tempFile, error: cleanupError });
+        }
+    }
+}
+/**
+ * Read an authorship log from Git Notes for a commit
+ *
+ * @param commitSha - The commit SHA to read the note from (or 'HEAD')
+ * @param workspaceRoot - The repository root directory
+ * @returns The parsed AuthorshipLog, or null if no note exists
+ */
+export async function readAuthorshipNote(commitSha, workspaceRoot) {
+    if (!isValidGitRef(commitSha)) {
+        throw new Error(`Invalid commit SHA: ${commitSha}`);
+    }
+    try {
+        const { stdout } = await execFileAsync('git', ['notes', `--ref=${NOTES_REF}`, 'show', '--', commitSha], {
+            cwd: workspaceRoot,
+        });
+        return parseAuthorshipLog(stdout);
+    }
+    catch (error) {
+        // Note doesn't exist or other error
+        debug(`No authorship note found for commit ${commitSha.slice(0, 8)}`, error);
+        return null;
+    }
+}
+/**
+ * List all commits with authorship notes
+ *
+ * @param workspaceRoot - The repository root directory
+ * @returns Array of commit SHAs that have authorship notes
+ */
+export async function listAuthorshipNotes(workspaceRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['notes', `--ref=${NOTES_REF}`, 'list'], {
+            cwd: workspaceRoot,
+        });
+        // Format: <note-sha> <commit-sha>
+        return stdout
+            .trim()
+            .split('\n')
+            .filter((line) => line)
+            .map((line) => line.split(' ')[1])
+            .filter((sha) => !!sha);
+    }
+    catch (error) {
+        debug('Failed to list authorship notes', error);
+        return [];
+    }
+}
+/**
+ * Remove an authorship note from a commit
+ *
+ * @param commitSha - The commit SHA to remove the note from
+ * @param workspaceRoot - The repository root directory
+ * @returns true if the note was removed, false if it didn't exist
+ */
+export async function removeAuthorshipNote(commitSha, workspaceRoot) {
+    if (!isValidGitRef(commitSha)) {
+        throw new Error(`Invalid commit SHA: ${commitSha}`);
+    }
+    try {
+        await execFileAsync('git', ['notes', `--ref=${NOTES_REF}`, 'remove', '--', commitSha], {
+            cwd: workspaceRoot,
+        });
+        debug(`Removed authorship note for commit ${commitSha.slice(0, 8)}`);
+        return true;
+    }
+    catch (error) {
+        debug('Failed to remove authorship note (may not exist)', error);
+        return false;
+    }
+}
+/**
+ * Copy authorship note when rebasing (from old SHA to new SHA)
+ *
+ * Updates the base_commit_sha in metadata to point to the new commit.
+ *
+ * @param fromSha - The original commit SHA
+ * @param toSha - The new commit SHA after rebase
+ * @param workspaceRoot - The repository root directory
+ * @returns true if the note was copied, false if source note didn't exist
+ */
+export async function copyAuthorshipNote(fromSha, toSha, workspaceRoot) {
+    if (!isValidGitRef(fromSha) || !isValidGitRef(toSha)) {
+        throw new Error(`Invalid commit SHA: fromSha=${fromSha}, toSha=${toSha}`);
+    }
+    try {
+        const existingLog = await readAuthorshipNote(fromSha, workspaceRoot);
+        if (!existingLog)
+            return false;
+        // Resolve toSha to full 40-character SHA
+        const { stdout } = await execFileAsync('git', ['rev-parse', '--', toSha], {
+            cwd: workspaceRoot,
+        });
+        const resolvedSha = stdout.trim();
+        // Update base_commit_sha in metadata to point to new commit
+        const updatedLog = {
+            ...existingLog,
+            metadata: {
+                ...existingLog.metadata,
+                base_commit_sha: resolvedSha,
+            },
+        };
+        await writeAuthorshipNote(toSha, updatedLog, workspaceRoot);
+        debug(`Copied authorship note from ${fromSha.slice(0, 8)} to ${toSha.slice(0, 8)}`);
+        return true;
+    }
+    catch (error) {
+        debug(`Failed to copy authorship note from ${fromSha} to ${toSha}`, error);
+        return false;
+    }
+}
+/**
+ * Push authorship notes to remote
+ *
+ * @param remote - Remote name (e.g., 'origin')
+ * @param workspaceRoot - The repository root directory
+ */
+export async function pushAuthorshipNotes(remote, workspaceRoot) {
+    if (!isValidRemoteName(remote)) {
+        throw new Error(`Invalid remote name: ${remote}`);
+    }
+    try {
+        await execFileAsync('git', ['push', remote, NOTES_REF], {
+            cwd: workspaceRoot,
+        });
+        debug(`Pushed authorship notes to ${remote}`);
+    }
+    catch (error) {
+        debug('Failed to push authorship notes', error);
+        throw new Error(`Failed to push authorship notes: ${error}`);
+    }
+}
+/**
+ * Fetch authorship notes from remote
+ *
+ * @param remote - Remote name (e.g., 'origin')
+ * @param workspaceRoot - The repository root directory
+ */
+export async function fetchAuthorshipNotes(remote, workspaceRoot) {
+    if (!isValidRemoteName(remote)) {
+        throw new Error(`Invalid remote name: ${remote}`);
+    }
+    try {
+        await execFileAsync('git', ['fetch', remote, `${NOTES_REF}:${NOTES_REF}`], {
+            cwd: workspaceRoot,
+        });
+        debug(`Fetched authorship notes from ${remote}`);
+    }
+    catch (error) {
+        debug('Failed to fetch authorship notes', error);
+        throw new Error(`Failed to fetch authorship notes: ${error}`);
+    }
+}
+/**
+ * Check if a commit has an authorship note
+ *
+ * @param commitSha - The commit SHA to check
+ * @param workspaceRoot - The repository root directory
+ * @returns true if the commit has an authorship note
+ */
+export async function hasAuthorshipNote(commitSha, workspaceRoot) {
+    if (!isValidGitRef(commitSha)) {
+        throw new Error(`Invalid commit SHA: ${commitSha}`);
+    }
+    try {
+        await execFileAsync('git', ['notes', `--ref=${NOTES_REF}`, 'show', '--', commitSha], {
+            cwd: workspaceRoot,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get summary statistics of AI authorship in a range of commits
+ *
+ * @param range - Git revision range (e.g., 'main..HEAD', 'HEAD~10..HEAD')
+ * @param workspaceRoot - The repository root directory
+ * @returns Summary object with counts
+ */
+export async function getAuthorshipStats(range, workspaceRoot) {
+    if (!isValidRevisionRange(range)) {
+        throw new Error(`Invalid revision range: ${range}`);
+    }
+    const stats = {
+        totalCommits: 0,
+        commitsWithAI: 0,
+        totalAdditions: 0,
+        totalDeletions: 0,
+        tools: {},
+    };
+    try {
+        // Get list of commits in range
+        const { stdout } = await execFileAsync('git', ['rev-list', '--', range], {
+            cwd: workspaceRoot,
+        });
+        const commits = stdout.trim().split('\n').filter(Boolean);
+        stats.totalCommits = commits.length;
+        // Batch: get all commits that have authorship notes in a single git command
+        const notedCommits = new Set(await listAuthorshipNotes(workspaceRoot));
+        // Only read notes for commits that are both in the range AND have notes
+        const commitsWithNotes = commits.filter((commit) => notedCommits.has(commit));
+        for (const commit of commitsWithNotes) {
+            const log = await readAuthorshipNote(commit, workspaceRoot);
+            if (log) {
+                stats.commitsWithAI++;
+                for (const prompt of Object.values(log.metadata.prompts)) {
+                    stats.totalAdditions += prompt.total_additions;
+                    stats.totalDeletions += prompt.total_deletions;
+                    const tool = prompt.agent_id.tool;
+                    stats.tools[tool] = (stats.tools[tool] || 0) + 1;
+                }
+            }
+        }
+    }
+    catch (error) {
+        debug('Failed to get authorship stats', error);
+    }
+    return stats;
+}

package/dist/provenance/git-ai-standard/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Git AI Standard v3.0.0 Implementation
+ *
+ * This module provides support for tracking AI-generated code contributions
+ * using Git Notes under the refs/notes/ai namespace.
+ *
+ * @see https://github.com/git-ai-project/git-ai/blob/main/specs/git_ai_standard_v3.0.0.md
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   writeAuthorshipNote,
+ *   readAuthorshipNote,
+ *   generateSessionHash,
+ *   SCHEMA_VERSION,
+ *   type AuthorshipLog,
+ * } from '@eddacraft/anvil-core';
+ *
+ * // Create an authorship log
+ * const log: AuthorshipLog = {
+ *   attestations: {
+ *     'src/feature.ts': [
+ *       { sessionHash: generateSessionHash('claude-code', 'session-123'), lineRanges: '1-50' }
+ *     ]
+ *   },
+ *   metadata: {
+ *     schema_version: SCHEMA_VERSION,
+ *     base_commit_sha: 'abc123...',
+ *     prompts: { ... }
+ *   }
+ * };
+ *
+ * // Attach to commit
+ * await writeAuthorshipNote(commitSha, log, workspaceRoot);
+ *
+ * // Read back
+ * const retrieved = await readAuthorshipNote(commitSha, workspaceRoot);
+ * ```
+ */
+export { SCHEMA_VERSION, SessionHashSchema, LineRangeSchema, FileAttestationSchema, AgentIdSchema, MessageTypeSchema, MessageSchema, PromptRecordSchema, AuthorshipMetadataSchema, AuthorshipLogSchema, type SessionHash, type LineRange, type FileAttestation, type AgentId, type MessageType, type Message, type PromptRecord, type AuthorshipMetadata, type AuthorshipLog, } from './types.js';
+export { serializeAuthorshipLog, parseAuthorshipLog, isAuthorshipLog, expandLineRanges, compactLineRanges, } from './serializer.js';
+export { generateSessionHash, sessionHashFromAgentId, createAgentId, detectCurrentAgent, createExplicitAgent, formatAgentId, } from './session.js';
+export { NOTES_REF, writeAuthorshipNote, readAuthorshipNote, listAuthorshipNotes, removeAuthorshipNote, copyAuthorshipNote, pushAuthorshipNotes, fetchAuthorshipNotes, hasAuthorshipNote, getAuthorshipStats, } from './git-notes.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/provenance/git-ai-standard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/provenance/git-ai-standard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,EACnB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,OAAO,EACZ,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,aAAa,GACnB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,GACd,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,SAAS,EACT,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC"}

package/dist/provenance/git-ai-standard/index.js

@@ -0,0 +1,47 @@
+/**
+ * Git AI Standard v3.0.0 Implementation
+ *
+ * This module provides support for tracking AI-generated code contributions
+ * using Git Notes under the refs/notes/ai namespace.
+ *
+ * @see https://github.com/git-ai-project/git-ai/blob/main/specs/git_ai_standard_v3.0.0.md
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   writeAuthorshipNote,
+ *   readAuthorshipNote,
+ *   generateSessionHash,
+ *   SCHEMA_VERSION,
+ *   type AuthorshipLog,
+ * } from '@eddacraft/anvil-core';
+ *
+ * // Create an authorship log
+ * const log: AuthorshipLog = {
+ *   attestations: {
+ *     'src/feature.ts': [
+ *       { sessionHash: generateSessionHash('claude-code', 'session-123'), lineRanges: '1-50' }
+ *     ]
+ *   },
+ *   metadata: {
+ *     schema_version: SCHEMA_VERSION,
+ *     base_commit_sha: 'abc123...',
+ *     prompts: { ... }
+ *   }
+ * };
+ *
+ * // Attach to commit
+ * await writeAuthorshipNote(commitSha, log, workspaceRoot);
+ *
+ * // Read back
+ * const retrieved = await readAuthorshipNote(commitSha, workspaceRoot);
+ * ```
+ */
+// Types
+export { SCHEMA_VERSION, SessionHashSchema, LineRangeSchema, FileAttestationSchema, AgentIdSchema, MessageTypeSchema, MessageSchema, PromptRecordSchema, AuthorshipMetadataSchema, AuthorshipLogSchema, } from './types.js';
+// Serialization
+export { serializeAuthorshipLog, parseAuthorshipLog, isAuthorshipLog, expandLineRanges, compactLineRanges, } from './serializer.js';
+// Session management
+export { generateSessionHash, sessionHashFromAgentId, createAgentId, detectCurrentAgent, createExplicitAgent, formatAgentId, } from './session.js';
+// Git Notes operations
+export { NOTES_REF, writeAuthorshipNote, readAuthorshipNote, listAuthorshipNotes, removeAuthorshipNote, copyAuthorshipNote, pushAuthorshipNotes, fetchAuthorshipNotes, hasAuthorshipNote, getAuthorshipStats, } from './git-notes.js';

package/dist/provenance/git-ai-standard/serializer.d.ts

@@ -0,0 +1,54 @@
+import type { AuthorshipLog } from './types.js';
+/**
+ * Serialize an AuthorshipLog to Git AI Standard format
+ *
+ * The format consists of two sections separated by "---":
+ *
+ * ```
+ * file/path.ts
+ *   a1b2c3d4e5f67890 1-50,55-60
+ * another/file.ts
+ *   b2c3d4e5f67890a1 1-100
+ * ---
+ * {"schema_version":"authorship/3.0.0",...}
+ * ```
+ *
+ * File paths with spaces or special characters are quoted.
+ *
+ * @param log - The authorship log to serialize
+ * @returns The serialized log string
+ */
+export declare function serializeAuthorshipLog(log: AuthorshipLog): string;
+/**
+ * Parse a Git AI Standard authorship log
+ *
+ * @param content - The raw log content from Git Notes
+ * @returns The parsed AuthorshipLog
+ * @throws Error if the content is malformed
+ */
+export declare function parseAuthorshipLog(content: string): AuthorshipLog;
+/**
+ * Check if content looks like an authorship log
+ *
+ * @param content - Content to check
+ * @returns true if the content appears to be a valid authorship log
+ */
+export declare function isAuthorshipLog(content: string): boolean;
+/**
+ * Parse line ranges into an array of line numbers
+ *
+ * Validates each part and skips invalid entries with a warning rather than
+ * throwing. Empty parts, NaN values, and ranges where start > end are skipped.
+ *
+ * @param ranges - Line range string (e.g., "1-10,15,20-25")
+ * @returns Array of individual line numbers
+ */
+export declare function expandLineRanges(ranges: string): number[];
+/**
+ * Compact an array of line numbers into ranges
+ *
+ * @param lines - Array of line numbers
+ * @returns Compact range string (e.g., "1-10,15,20-25")
+ */
+export declare function compactLineRanges(lines: number[]): string;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/provenance/git-ai-standard/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../../src/provenance/git-ai-standard/serializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAmB,MAAM,YAAY,CAAC;AAMjE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAyBjE;AASD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAuCjE;AAwDD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAMxD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CA+CzD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAsBzD"}

package/dist/provenance/git-ai-standard/serializer.js

@@ -0,0 +1,224 @@
+import { AuthorshipLogSchema, SCHEMA_VERSION } from './types.js';
+import { createDebugger } from '../../utils/debug.js';
+const debug = createDebugger('provenance');
+/**
+ * Serialize an AuthorshipLog to Git AI Standard format
+ *
+ * The format consists of two sections separated by "---":
+ *
+ * ```
+ * file/path.ts
+ *   a1b2c3d4e5f67890 1-50,55-60
+ * another/file.ts
+ *   b2c3d4e5f67890a1 1-100
+ * ---
+ * {"schema_version":"authorship/3.0.0",...}
+ * ```
+ *
+ * File paths with spaces or special characters are quoted.
+ *
+ * @param log - The authorship log to serialize
+ * @returns The serialized log string
+ */
+export function serializeAuthorshipLog(log) {
+    const lines = [];
+    // Attestation section
+    const sortedPaths = Object.keys(log.attestations).sort();
+    for (const filePath of sortedPaths) {
+        const attestations = log.attestations[filePath];
+        if (!attestations || attestations.length === 0)
+            continue;
+        // Quote paths with spaces or special characters
+        const quotedPath = needsQuoting(filePath) ? `"${filePath}"` : filePath;
+        lines.push(quotedPath);
+        for (const attestation of attestations) {
+            lines.push(`  ${attestation.sessionHash} ${attestation.lineRanges}`);
+        }
+    }
+    // Separator
+    lines.push('---');
+    // Metadata section (JSON, pretty-printed for readability)
+    lines.push(JSON.stringify(log.metadata, null, 2));
+    return lines.join('\n');
+}
+/**
+ * Check if a file path needs to be quoted
+ */
+function needsQuoting(path) {
+    return /[\s"'\\]/.test(path);
+}
+/**
+ * Parse a Git AI Standard authorship log
+ *
+ * @param content - The raw log content from Git Notes
+ * @returns The parsed AuthorshipLog
+ * @throws Error if the content is malformed
+ */
+export function parseAuthorshipLog(content) {
+    const separatorIndex = content.indexOf('\n---\n');
+    if (separatorIndex === -1) {
+        // Try alternate separator (just --- at start of line)
+        const altIndex = content.indexOf('\n---');
+        if (altIndex === -1) {
+            throw new Error('Invalid authorship log: missing --- separator');
+        }
+    }
+    const actualSeparatorIndex = content.indexOf('\n---\n') !== -1 ? content.indexOf('\n---\n') : content.indexOf('\n---');
+    const attestationSection = content.slice(0, actualSeparatorIndex);
+    const metadataSection = content.slice(actualSeparatorIndex).replace(/^\n---\n?/, '');
+    // Parse attestations
+    const attestations = parseAttestationSection(attestationSection);
+    // Parse metadata JSON
+    const metadataJson = metadataSection.trim();
+    if (!metadataJson) {
+        throw new Error('Invalid authorship log: empty metadata section');
+    }
+    let metadata;
+    try {
+        metadata = JSON.parse(metadataJson);
+    }
+    catch (e) {
+        throw new Error(`Invalid authorship log: malformed JSON in metadata section - ${e}`);
+    }
+    // Validate with Zod schema
+    const result = AuthorshipLogSchema.safeParse({ attestations, metadata });
+    if (!result.success) {
+        throw new Error(`Invalid authorship log: ${result.error.message}`);
+    }
+    return result.data;
+}
+/**
+ * Parse the attestation section of an authorship log
+ */
+function parseAttestationSection(section) {
+    const attestations = {};
+    let currentFile = null;
+    for (const line of section.split('\n')) {
+        if (!line.trim())
+            continue;
+        // Check if this is a file path line (not indented)
+        if (!line.startsWith(' ') && !line.startsWith('\t')) {
+            currentFile = parseFilePath(line);
+            attestations[currentFile] = [];
+        }
+        else if (currentFile) {
+            // This is an attestation entry line (indented)
+            const attestation = parseAttestationLine(line.trim());
+            if (attestation) {
+                attestations[currentFile].push(attestation);
+            }
+        }
+    }
+    return attestations;
+}
+/**
+ * Parse a file path, handling quoted paths
+ */
+function parseFilePath(line) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+/**
+ * Parse an attestation entry line
+ *
+ * Format: <session-hash> <line-ranges>
+ * Example: a1b2c3d4e5f67890 1-50,55-60
+ */
+function parseAttestationLine(line) {
+    // Match 7-16 hex characters followed by space and line ranges
+    const match = line.match(/^([a-f0-9]{7,16})\s+(.+)$/);
+    if (!match)
+        return null;
+    return {
+        sessionHash: match[1],
+        lineRanges: match[2],
+    };
+}
+/**
+ * Check if content looks like an authorship log
+ *
+ * @param content - Content to check
+ * @returns true if the content appears to be a valid authorship log
+ */
+export function isAuthorshipLog(content) {
+    return (content.includes('\n---\n') &&
+        content.includes(`"schema_version"`) &&
+        content.includes(SCHEMA_VERSION));
+}
+/**
+ * Parse line ranges into an array of line numbers
+ *
+ * Validates each part and skips invalid entries with a warning rather than
+ * throwing. Empty parts, NaN values, and ranges where start > end are skipped.
+ *
+ * @param ranges - Line range string (e.g., "1-10,15,20-25")
+ * @returns Array of individual line numbers
+ */
+export function expandLineRanges(ranges) {
+    const lines = [];
+    for (const part of ranges.split(',')) {
+        const trimmed = part.trim();
+        // Skip empty parts (e.g., trailing commas, double commas)
+        if (trimmed === '') {
+            continue;
+        }
+        if (trimmed.includes('-')) {
+            const segments = trimmed.split('-');
+            if (segments.length !== 2) {
+                debug(`[anvil] expandLineRanges: skipping invalid range part "${trimmed}"`);
+                continue;
+            }
+            const start = Number(segments[0]);
+            const end = Number(segments[1]);
+            if (!Number.isInteger(start) || !Number.isInteger(end)) {
+                debug(`[anvil] expandLineRanges: skipping non-integer range "${trimmed}"`);
+                continue;
+            }
+            if (start > end) {
+                debug(`[anvil] expandLineRanges: skipping invalid range "${trimmed}" (start > end)`);
+                continue;
+            }
+            for (let i = start; i <= end; i++) {
+                lines.push(i);
+            }
+        }
+        else {
+            const num = Number(trimmed);
+            if (!Number.isInteger(num)) {
+                debug(`[anvil] expandLineRanges: skipping non-integer value "${trimmed}"`);
+                continue;
+            }
+            lines.push(num);
+        }
+    }
+    return lines.sort((a, b) => a - b);
+}
+/**
+ * Compact an array of line numbers into ranges
+ *
+ * @param lines - Array of line numbers
+ * @returns Compact range string (e.g., "1-10,15,20-25")
+ */
+export function compactLineRanges(lines) {
+    if (lines.length === 0)
+        return '';
+    const sorted = [...new Set(lines)].sort((a, b) => a - b);
+    const ranges = [];
+    let rangeStart = sorted[0];
+    let rangeEnd = sorted[0];
+    for (let i = 1; i < sorted.length; i++) {
+        if (sorted[i] === rangeEnd + 1) {
+            rangeEnd = sorted[i];
+        }
+        else {
+            ranges.push(rangeStart === rangeEnd ? `${rangeStart}` : `${rangeStart}-${rangeEnd}`);
+            rangeStart = sorted[i];
+            rangeEnd = sorted[i];
+        }
+    }
+    ranges.push(rangeStart === rangeEnd ? `${rangeStart}` : `${rangeStart}-${rangeEnd}`);
+    return ranges.join(',');
+}