diff-easy 0.1.0

package/dist/shared/grouping.d.ts

@@ -0,0 +1,4 @@
+import type { DiffFile, GroupingResult } from '../types/diff.js';
+export type GroupInputFile = Pick<DiffFile, 'path' | 'additions' | 'deletions' | 'status' | 'isGenerated'>;
+export declare function groupByModule(files: GroupInputFile[]): GroupingResult;
+export declare function groupSmart(files: GroupInputFile[]): GroupingResult;

package/dist/shared/grouping.js

@@ -0,0 +1,170 @@
+const churn = (fs) => fs.reduce((s, f) => s + f.additions + f.deletions, 0);
+function splitNoise(files) {
+    const noise = [];
+    const kept = [];
+    for (const f of files) {
+        if (f.isGenerated)
+            noise.push(f.path);
+        else
+            kept.push(f);
+    }
+    return { noise, kept };
+}
+/** Longest common *directory* prefix (ending in `/`, or '' if none). */
+function commonDirPrefix(paths) {
+    if (paths.length === 0)
+        return '';
+    const split = paths.map((p) => p.split('/'));
+    const first = split[0] ?? [];
+    let i = 0;
+    for (; i < first.length - 1; i++) {
+        const seg = first[i];
+        if (!split.every((parts) => parts.length - 1 > i && parts[i] === seg))
+            break;
+    }
+    return i > 0 ? first.slice(0, i).join('/') + '/' : '';
+}
+export function groupByModule(files) {
+    const { noise, kept } = splitNoise(files);
+    const prefix = commonDirPrefix(kept.map((f) => f.path));
+    const buckets = new Map();
+    for (const f of kept) {
+        const rest = f.path.slice(prefix.length);
+        const slash = rest.indexOf('/');
+        const key = slash === -1 ? '(root)' : rest.slice(0, slash);
+        const arr = buckets.get(key) ?? [];
+        arr.push(f);
+        buckets.set(key, arr);
+    }
+    const groups = [...buckets.entries()]
+        .map(([label, fs]) => ({ label, fs, weight: churn(fs) }))
+        .sort((a, b) => b.weight - a.weight || a.label.localeCompare(b.label))
+        .map((g, i) => ({
+        id: `g${i + 1}`,
+        label: g.label,
+        files: g.fs.map((f) => f.path).sort((a, b) => a.localeCompare(b)),
+    }));
+    return { mode: 'module', groups, noise, generatedAt: Date.now() };
+}
+const GENERIC_STEMS = new Set(['index', 'main', 'mod', 'utils', 'types', 'helpers', 'constants']);
+const TAIL_ORDER = ['Tests', 'Styles', 'Config', 'Docs'];
+function basename(path) {
+    return path.split('/').pop() ?? path;
+}
+function dirname(path) {
+    const i = path.lastIndexOf('/');
+    return i === -1 ? '' : path.slice(0, i);
+}
+/** Lowercased base name with extension + test/spec/module/etc. qualifiers stripped. */
+function stemOf(path) {
+    const name = basename(path).toLowerCase();
+    const dot = name.indexOf('.');
+    return dot === -1 ? name : name.slice(0, dot);
+}
+function titleCase(stem) {
+    return stem.length ? stem.charAt(0).toUpperCase() + stem.slice(1) : stem;
+}
+function roleOf(path) {
+    const name = basename(path).toLowerCase();
+    if (/\.(test|spec)\.[cm]?[jt]sx?$/.test(name) ||
+        /_test\.go$/.test(name) ||
+        /test\.(java|kt|scala)$/.test(name) ||
+        /(^|\/)(tests?|__tests__|spec)\//.test(path))
+        return 'test';
+    if (/\.(css|scss|sass|less|styl)$/.test(name))
+        return 'style';
+    if (/\.(json|ya?ml|toml|ini)$/.test(name) ||
+        /(^|\/)\.env/.test(path) ||
+        /^dockerfile$/.test(name) ||
+        /^makefile$/.test(name) ||
+        /\.config\.[cm]?[jt]s$/.test(name) ||
+        /(^|\/)\.(github|circleci)\//.test(path))
+        return 'config';
+    if (/\.(md|mdx|markdown|rst|txt)$/.test(name) || /^(readme|changelog|license)/.test(name))
+        return 'doc';
+    return 'source';
+}
+const roleToTail = {
+    test: 'Tests',
+    style: 'Styles',
+    config: 'Config',
+    doc: 'Docs',
+};
+const complete = (fs) => fs.some((f) => roleOf(f.path) === 'test') && fs.some((f) => roleOf(f.path) === 'source');
+export function groupSmart(files) {
+    const { noise, kept } = splitNoise(files);
+    // Pass 2: feature-stem clusters. Distinctive stems merge across dirs; generic
+    // stems only cluster within one directory.
+    const clusterKey = (f) => {
+        const stem = stemOf(f.path);
+        const distinctive = stem.length >= 4 && !GENERIC_STEMS.has(stem);
+        return distinctive ? `stem:${stem}` : `dir:${dirname(f.path)}:${stem}`;
+    };
+    const byKey = new Map();
+    for (const f of kept) {
+        const k = clusterKey(f);
+        const arr = byKey.get(k) ?? [];
+        arr.push(f);
+        byKey.set(k, arr);
+    }
+    const claimed = new Set();
+    const featureCohorts = [];
+    for (const fs of byKey.values()) {
+        if (fs.length < 2)
+            continue;
+        const firstFile = fs[0];
+        if (!firstFile)
+            continue;
+        featureCohorts.push({ label: titleCase(stemOf(firstFile.path)), files: fs });
+        for (const f of fs)
+            claimed.add(f.path);
+    }
+    // Pass 3: role-tail extraction from unclaimed files.
+    const tailBuckets = new Map();
+    const forDir = [];
+    for (const f of kept) {
+        if (claimed.has(f.path))
+            continue;
+        const tail = roleToTail[roleOf(f.path)];
+        if (tail) {
+            const arr = tailBuckets.get(tail) ?? [];
+            arr.push(f);
+            tailBuckets.set(tail, arr);
+        }
+        else {
+            forDir.push(f);
+        }
+    }
+    // Pass 4: directory affinity for remaining (source) singletons.
+    const dirBuckets = new Map();
+    for (const f of forDir) {
+        const d = dirname(f.path) || '(root)';
+        const arr = dirBuckets.get(d) ?? [];
+        arr.push(f);
+        dirBuckets.set(d, arr);
+    }
+    const dirCohorts = [...dirBuckets.entries()].map(([label, files]) => ({
+        label,
+        files,
+    }));
+    // Pass 5: order feature + dir cohorts by completeness, then churn, then label.
+    const ranked = [...featureCohorts, ...dirCohorts].sort((a, b) => {
+        const c = Number(complete(b.files)) - Number(complete(a.files));
+        if (c !== 0)
+            return c;
+        const k = churn(b.files) - churn(a.files);
+        if (k !== 0)
+            return k;
+        return a.label.localeCompare(b.label);
+    });
+    const tailCohorts = TAIL_ORDER.filter((l) => tailBuckets.get(l)?.length).map((l) => ({
+        label: l,
+        files: tailBuckets.get(l) ?? [],
+    }));
+    const groups = [...ranked, ...tailCohorts].map((c, i) => ({
+        id: `g${i + 1}`,
+        label: c.label,
+        files: c.files.map((f) => f.path).sort((a, b) => a.localeCompare(b)),
+    }));
+    return { mode: 'smart', groups, noise, generatedAt: Date.now() };
+}

package/dist/types/diff.d.ts

@@ -0,0 +1,263 @@
+export interface DiffFile {
+    path: string;
+    oldPath?: string;
+    status: 'modified' | 'added' | 'deleted' | 'renamed';
+    additions: number;
+    deletions: number;
+    chunks: DiffChunk[];
+    isGenerated?: boolean;
+}
+export interface DiffChunk {
+    header: string;
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    lines: DiffLine[];
+}
+export interface DiffLine {
+    type: 'add' | 'delete' | 'normal' | 'hunk' | 'remove' | 'context' | 'header';
+    content: string;
+    oldLineNumber?: number;
+    newLineNumber?: number;
+}
+export type DiffViewMode = 'split' | 'unified';
+export type DiffSide = 'old' | 'new';
+export type DiffLineRange = number | {
+    start: number;
+    end: number;
+};
+export interface DiffCommentPosition {
+    side: DiffSide;
+    line: DiffLineRange;
+}
+export interface DiffCommentCodeSnapshot {
+    content: string;
+    language?: string;
+}
+export type BaseMode = 'direct' | 'merge-base';
+export interface DiffSelection {
+    baseCommitish: string;
+    targetCommitish: string;
+    baseMode?: BaseMode;
+}
+export interface DiffResponse {
+    commit: string;
+    files: DiffFile[];
+    ignoreWhitespace?: boolean;
+    isEmpty?: boolean;
+    openInEditorAvailable?: boolean;
+    baseCommitish?: string;
+    targetCommitish?: string;
+    requestedBaseCommitish?: string;
+    requestedTargetCommitish?: string;
+    requestedBaseMode?: BaseMode;
+    clearComments?: boolean;
+    repositoryId?: string;
+    /** diff-easy hub: basename of the active workspace folder, for the toolbar label. */
+    repoName?: string;
+    /** diff-easy hub: home-relative path of the active workspace (e.g. ~/code/repo), for the tooltip. */
+    repoPath?: string;
+    commentImports?: CommentImport[];
+    commentImportId?: string;
+    /** diff-easy: PR title, for a GitHub-PR static-patch workspace (grouping intent). */
+    prTitle?: string;
+    /** diff-easy: PR body, for a GitHub-PR static-patch workspace (grouping intent). */
+    prBody?: string;
+    /** diff-easy: set when the diff couldn't be produced (e.g. a pruned snapshot). */
+    diffError?: string;
+    /** diff-easy hub: set when no workspace is selected yet (show the picker). */
+    needsWorkspace?: boolean;
+}
+export interface GeneratedStatusResponse {
+    path: string;
+    ref: string;
+    isGenerated: boolean;
+    source: 'path' | 'content';
+}
+export type LineNumber = number | [number, number];
+export interface Comment {
+    id: string;
+    file: string;
+    line: LineNumber;
+    body: string;
+    timestamp: string;
+    author?: string;
+    codeContent?: string;
+    side?: DiffSide;
+}
+export interface LineSelection {
+    side: DiffSide;
+    lineNumber: number;
+}
+export interface LegacyDiffComment {
+    id: string;
+    filePath: string;
+    body: string;
+    author?: string;
+    createdAt: string;
+    updatedAt: string;
+    position: DiffCommentPosition;
+    codeSnapshot?: DiffCommentCodeSnapshot;
+}
+export interface DiffCommentMessage {
+    id: string;
+    body: string;
+    author?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface DiffCommentThread {
+    id: string;
+    filePath: string;
+    createdAt: string;
+    updatedAt: string;
+    position: DiffCommentPosition;
+    codeSnapshot?: DiffCommentCodeSnapshot;
+    messages: DiffCommentMessage[];
+}
+interface CommentImportBase {
+    id?: string;
+    filePath: string;
+    position: DiffCommentPosition;
+    body: string;
+    author?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    codeSnapshot?: DiffCommentCodeSnapshot;
+}
+export interface ThreadCommentImport extends CommentImportBase {
+    type: 'thread';
+}
+export interface ReplyCommentImport extends CommentImportBase {
+    type: 'reply';
+}
+export type CommentImport = ThreadCommentImport | ReplyCommentImport;
+export interface ViewedFileRecord {
+    filePath: string;
+    viewedAt: string;
+    diffContentHash: string;
+}
+export interface ViewedHashIndexEntry {
+    filePath: string;
+    diffContentHash: string;
+    hashVersion: 1;
+    viewedAt: string;
+}
+export interface ViewedHashIndex {
+    version: 1;
+    lastModifiedAt: string;
+    entries: ViewedHashIndexEntry[];
+}
+export interface LegacyDiffContextStorage {
+    version: 1;
+    baseCommitish: string;
+    targetCommitish: string;
+    createdAt: string;
+    lastModifiedAt: string;
+    comments: LegacyDiffComment[];
+    viewedFiles: ViewedFileRecord[];
+}
+export interface DiffContextStorage {
+    version: 2;
+    baseCommitish: string;
+    targetCommitish: string;
+    baseMode?: BaseMode;
+    createdAt: string;
+    lastModifiedAt: string;
+    threads: DiffCommentThread[];
+    viewedFiles: ViewedFileRecord[];
+    appliedCommentImportIds: string[];
+}
+export interface CommentThread {
+    id: string;
+    file: string;
+    line: LineNumber;
+    side?: DiffSide;
+    createdAt: string;
+    updatedAt: string;
+    codeContent?: string;
+    isOutdated?: boolean;
+    messages: DiffCommentMessage[];
+}
+interface RevisionOption {
+    value: string;
+    label: string;
+}
+interface BranchInfo {
+    name: string;
+    current: boolean;
+}
+export interface CommitInfo {
+    hash: string;
+    shortHash: string;
+    /** Subject line (git `%s`). */
+    message: string;
+    /** Full commit body (git `%b`), if any. Used by the context bar's expanded view. */
+    body?: string;
+    /** Author name (git `%aN`). */
+    author?: string;
+    /** Author date, ISO 8601 (git `%aI`). */
+    date?: string;
+}
+export interface RevisionsResponse {
+    specialOptions: RevisionOption[];
+    branches: BranchInfo[];
+    commits: CommitInfo[];
+    originDefaultBranch?: string;
+    resolvedBase?: string;
+    resolvedTarget?: string;
+    currentBranch?: string;
+    /** From `git config branch.<name>.pgit-parent`; undefined when unset. */
+    pgitParent?: string;
+    /**
+     * Effective base for the "Current branch" view, resolved server-side:
+     * the pgit parent when set, else the origin default branch when the current
+     * branch actually diverges from it. Undefined when neither applies (→ the
+     * client lands on the working-tree view and prompts for a base).
+     */
+    branchBase?: string;
+    /**
+     * How `branchBase` was chosen: 'pgit' is explicit; 'branch' (nearest ancestor
+     * branch) and 'origin-default' are inferred best-guesses.
+     */
+    branchBaseSource?: 'pgit' | 'branch' | 'origin-default';
+    /** Stable per-repo id (sha256 of the repo path) — keys per-repo UI prefs. */
+    repositoryId?: string;
+}
+export interface ExpandedLinesState {
+    [filePath: string]: FileExpandedState;
+}
+export interface FileExpandedState {
+    oldContent?: string[];
+    newContent?: string[];
+    expandedRanges: ExpandedRange[];
+    oldTotalLines?: number;
+    newTotalLines?: number;
+}
+interface ExpandedRange {
+    chunkIndex: number;
+    direction: 'up' | 'down';
+    count: number;
+}
+export interface ExpandedLine extends DiffLine {
+    isExpanded?: boolean;
+}
+export interface FileGroup {
+    id: string;
+    label: string;
+    rationale?: string;
+    files: string[];
+}
+export interface GroupingResult {
+    /** Which algorithm produced this result. */
+    mode: 'smart' | 'module' | 'ai';
+    groups: FileGroup[];
+    noise: string[];
+    /** AI only: the model that produced the grouping. */
+    model?: string;
+    /** Set when AI grouping was requested but degraded to the deterministic `smart` result. */
+    fallbackFrom?: 'ai';
+    generatedAt: number;
+}
+export {};

package/dist/types/diff.js

@@ -0,0 +1 @@
+export {};

package/dist/types/watch.d.ts

@@ -0,0 +1,59 @@
+export declare enum DiffMode {
+    DEFAULT = "default",// HEAD^ vs HEAD
+    WORKING = "working",// staged vs working
+    STAGED = "staged",// HEAD vs staged
+    DOT = "dot",// HEAD vs working (all changes)
+    SPECIFIC = "specific"
+}
+type WatchChangeType = 'file' | 'commit' | 'staging';
+interface ConnectedWatchEvent {
+    type: 'connected';
+    diffMode: DiffMode;
+    changeType: WatchChangeType;
+    timestamp: string;
+    message?: string;
+}
+interface ReloadWatchEvent {
+    type: 'reload';
+    diffMode: DiffMode;
+    changeType: WatchChangeType;
+    timestamp: string;
+    message?: string;
+}
+interface ErrorWatchEvent {
+    type: 'error';
+    diffMode: DiffMode;
+    changeType: WatchChangeType;
+    timestamp: string;
+    message?: string;
+}
+interface CommentsChangedWatchEvent {
+    type: 'commentsChanged';
+    version: number;
+    timestamp: string;
+}
+interface TurnCompleteWatchEvent {
+    type: 'turn-complete';
+    timestamp: string;
+}
+interface WorkspaceChangedWatchEvent {
+    type: 'workspace-changed';
+    timestamp: string;
+}
+interface WorkspaceActivityWatchEvent {
+    type: 'workspace-activity';
+    repoId: string;
+    count: number;
+    timestamp: string;
+}
+export type WatchEvent = ConnectedWatchEvent | ReloadWatchEvent | ErrorWatchEvent | CommentsChangedWatchEvent | TurnCompleteWatchEvent | WorkspaceChangedWatchEvent | WorkspaceActivityWatchEvent;
+export interface ClientWatchState {
+    isWatchEnabled: boolean;
+    diffMode: DiffMode;
+    shouldReload: boolean;
+    isReloading: boolean;
+    lastChangeTime: Date | null;
+    lastChangeType: WatchChangeType | null;
+    connectionStatus: 'connected' | 'disconnected' | 'reconnecting';
+}
+export {};

package/dist/types/watch.js

@@ -0,0 +1,8 @@
+export var DiffMode;
+(function (DiffMode) {
+    DiffMode["DEFAULT"] = "default";
+    DiffMode["WORKING"] = "working";
+    DiffMode["STAGED"] = "staged";
+    DiffMode["DOT"] = "dot";
+    DiffMode["SPECIFIC"] = "specific";
+})(DiffMode || (DiffMode = {}));

package/dist/utils/commentFormatting.d.ts

@@ -0,0 +1,6 @@
+import type { Comment, CommentThread } from '../types/diff';
+export declare function formatCommentPrompt(file: string, line: number | number[], body: string, codeContent?: string): string;
+export declare function formatAllCommentsPrompt(comments: Comment[]): string;
+export declare function formatCommentThreadPrompt(thread: CommentThread): string;
+export declare function formatAllCommentThreadsPrompt(threads: CommentThread[]): string;
+export declare function formatCommentsOutput(input: Comment[] | CommentThread[]): string;

package/dist/utils/commentFormatting.js

@@ -0,0 +1,90 @@
+import { hasSuggestionBlock, parseSuggestionBlocks } from './suggestionUtils.js';
+function getLineInfo(line) {
+    return typeof line === 'number' ? `L${line}` : `L${line[0]}-L${line[1]}`;
+}
+function formatCommentContent(body, codeContent) {
+    if (hasSuggestionBlock(body)) {
+        const suggestions = parseSuggestionBlocks(body);
+        if (suggestions.length > 0) {
+            let result = '';
+            let lastIndex = 0;
+            for (const suggestion of suggestions) {
+                const textBefore = body.slice(lastIndex, suggestion.startIndex).trim();
+                if (textBefore) {
+                    result += `${result ? '\n' : ''}${textBefore}`;
+                }
+                if (codeContent) {
+                    result += `${result ? '\n' : ''}ORIGINAL:\n\`\`\`\n${codeContent}\n\`\`\``;
+                }
+                result += `${result ? '\n' : ''}SUGGESTED:\n\`\`\`\n${suggestion.suggestedCode}\n\`\`\``;
+                lastIndex = suggestion.endIndex;
+            }
+            const textAfter = body.slice(lastIndex).trim();
+            if (textAfter) {
+                result += `${result ? '\n' : ''}${textAfter}`;
+            }
+            return result;
+        }
+    }
+    return body;
+}
+function normalizeLegacyComment(comment) {
+    return {
+        id: comment.id,
+        file: comment.file,
+        line: comment.line,
+        side: comment.side,
+        createdAt: comment.timestamp,
+        updatedAt: comment.timestamp,
+        codeContent: comment.codeContent,
+        messages: [
+            {
+                id: comment.id,
+                body: comment.body,
+                author: comment.author,
+                createdAt: comment.timestamp,
+                updatedAt: comment.timestamp,
+            },
+        ],
+    };
+}
+export function formatCommentPrompt(file, line, body, codeContent) {
+    const filePath = file || '<unknown file>';
+    return `${filePath}:${getLineInfo(line)}\n${formatCommentContent(body, codeContent)}`;
+}
+export function formatAllCommentsPrompt(comments) {
+    if (comments.length === 0)
+        return '';
+    const prompts = comments.map((comment) => formatCommentPrompt(comment.file, comment.line, comment.body, comment.codeContent));
+    return prompts.join('\n=====\n');
+}
+export function formatCommentThreadPrompt(thread) {
+    const sections = [`${thread.file || '<unknown file>'}:${getLineInfo(thread.line)}`];
+    thread.messages.forEach((message, index) => {
+        if (index === 0) {
+            sections.push(formatCommentContent(message.body, thread.codeContent));
+            return;
+        }
+        const replyIndex = index;
+        const authorLabel = message.author?.trim() || 'Unknown';
+        sections.push(`Reply ${replyIndex} (${authorLabel})`);
+        sections.push(formatCommentContent(message.body, thread.codeContent));
+    });
+    return sections.filter(Boolean).join('\n');
+}
+export function formatAllCommentThreadsPrompt(threads) {
+    if (threads.length === 0)
+        return '';
+    return threads.map((thread) => formatCommentThreadPrompt(thread)).join('\n=====\n');
+}
+export function formatCommentsOutput(input) {
+    const threads = input.map((item) => ('messages' in item ? item : normalizeLegacyComment(item)));
+    const allPrompts = formatAllCommentThreadsPrompt(threads);
+    return [
+        '\n📝 Comments from review session:',
+        '='.repeat(50),
+        allPrompts,
+        '='.repeat(50),
+        `Total comments: ${threads.length}\n`,
+    ].join('\n');
+}

package/dist/utils/commentImports.d.ts

@@ -0,0 +1,11 @@
+import type { CommentImport, DiffCommentThread } from '../types/diff.js';
+interface MergeCommentImportsResult {
+    threads: DiffCommentThread[];
+    warnings: string[];
+}
+export declare function normalizeCommentImports(input: unknown): CommentImport[];
+export declare function parseCommentImportValue(value: string): CommentImport[];
+export declare function mergeCommentThreads(existingThreads: DiffCommentThread[], incomingThreads: DiffCommentThread[]): MergeCommentImportsResult;
+export declare function serializeCommentImports(commentImports: CommentImport[]): string;
+export declare function mergeCommentImports(existingThreads: DiffCommentThread[], commentImports: CommentImport[]): MergeCommentImportsResult;
+export {};