codewalk 0.1.0

package/dist/injections-73j83es3.scm

@@ -0,0 +1,27 @@
+; Query from: https://raw.githubusercontent.com/nvim-treesitter/nvim-treesitter/refs/heads/master/queries/markdown/injections.scm
+(fenced_code_block
+  (info_string
+    (language) @_lang)
+  (code_fence_content) @injection.content
+  (#set-lang-from-info-string! @_lang))
+
+((html_block) @injection.content
+  (#set! injection.language "html")
+  (#set! injection.combined)
+  (#set! injection.include-children))
+
+((minus_metadata) @injection.content
+  (#set! injection.language "yaml")
+  (#offset! @injection.content 1 0 -1 0)
+  (#set! injection.include-children))
+
+((plus_metadata) @injection.content
+  (#set! injection.language "toml")
+  (#offset! @injection.content 1 0 -1 0)
+  (#set! injection.include-children))
+
+([
+  (inline)
+  (pipe_table_cell)
+] @injection.content
+  (#set! injection.language "markdown_inline"))

package/dist/tui/app.d.ts

@@ -0,0 +1,13 @@
+import { createCliRenderer, type CliRenderer, BoxRenderable, TextRenderable, ScrollBoxRenderable, DiffRenderable } from '@opentui/core';
+import type { ReasoningGroup } from '../utils/tracking.js';
+export interface AppState {
+    branch: string;
+    reasoningGroups: ReasoningGroup[];
+    selectedIndex: number;
+    expandedReasonings: Set<number>;
+    expandedFiles: Set<string>;
+}
+export declare function createAppState(branch: string, reasoningGroups: ReasoningGroup[]): AppState;
+export { createCliRenderer, BoxRenderable, TextRenderable, ScrollBoxRenderable, DiffRenderable };
+export type { CliRenderer };
+//# sourceMappingURL=app.d.ts.map

package/dist/tui/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../src/tui/app.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,KAAK,WAAW,EAChB,aAAa,EACb,cAAc,EACd,mBAAmB,EACnB,cAAc,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,cAAc,EAAE,CAAC;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAChC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC5B;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,cAAc,EAAE,GAChC,QAAQ,CAQV;AAED,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,cAAc,EAAE,mBAAmB,EAAE,cAAc,EAAE,CAAC;AACjG,YAAY,EAAE,WAAW,EAAE,CAAC"}

package/dist/tui/app.js

@@ -0,0 +1,11 @@
+import { createCliRenderer, BoxRenderable, TextRenderable, ScrollBoxRenderable, DiffRenderable, } from '@opentui/core';
+export function createAppState(branch, reasoningGroups) {
+    return {
+        branch,
+        reasoningGroups,
+        selectedIndex: 0,
+        expandedReasonings: new Set(),
+        expandedFiles: new Set(),
+    };
+}
+export { createCliRenderer, BoxRenderable, TextRenderable, ScrollBoxRenderable, DiffRenderable };

package/dist/tui/tree-view.d.ts

@@ -0,0 +1,24 @@
+import { type CliRenderer } from '@opentui/core';
+import type { AppState } from './app.js';
+export declare class TreeView {
+    private renderer;
+    private state;
+    private rootBox;
+    private headerBox;
+    private scrollBox;
+    private footerBox;
+    private selectableItems;
+    constructor(renderer: CliRenderer, state: AppState);
+    private buildUI;
+    private buildHeader;
+    private buildContent;
+    private buildFooter;
+    private isReasoningSelected;
+    private isFileSelected;
+    getItemCount(): number;
+    toggleExpand(): void;
+    moveSelection(delta: number): void;
+    refresh(): void;
+    destroy(): void;
+}
+//# sourceMappingURL=tree-view.d.ts.map

package/dist/tui/tree-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-view.d.ts","sourceRoot":"","sources":["../../src/tui/tree-view.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,WAAW,EACjB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAgDzC,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAc;IAC9B,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,eAAe,CAAwB;gBAEnC,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ;IAiDlD,OAAO,CAAC,OAAO;IAoBf,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,YAAY;IAwGpB,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,mBAAmB;IAK3B,OAAO,CAAC,cAAc;IAKf,YAAY,IAAI,MAAM;IAItB,YAAY,IAAI,IAAI;IA4BpB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAQlC,OAAO,IAAI,IAAI;IAIf,OAAO,IAAI,IAAI;CAGvB"}

package/dist/tui/tree-view.js

@@ -0,0 +1,274 @@
+import { BoxRenderable, TextRenderable, ScrollBoxRenderable, DiffRenderable, } from '@opentui/core';
+// Convert hunks to unified diff format for DiffRenderable
+function hunksToUnifiedDiff(filePath, hunks) {
+    let diff = `--- a/${filePath}\n+++ b/${filePath}\n`;
+    for (const hunk of hunks) {
+        diff += hunk.header + '\n';
+        diff += hunk.content;
+    }
+    return diff;
+}
+// Get file extension for syntax highlighting
+function getFileType(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    const typeMap = {
+        ts: 'typescript',
+        tsx: 'tsx',
+        js: 'javascript',
+        jsx: 'jsx',
+        py: 'python',
+        rb: 'ruby',
+        go: 'go',
+        rs: 'rust',
+        java: 'java',
+        c: 'c',
+        cpp: 'cpp',
+        h: 'c',
+        hpp: 'cpp',
+        css: 'css',
+        scss: 'scss',
+        html: 'html',
+        json: 'json',
+        md: 'markdown',
+        yaml: 'yaml',
+        yml: 'yaml',
+    };
+    return ext ? typeMap[ext] : undefined;
+}
+export class TreeView {
+    renderer;
+    state;
+    rootBox;
+    headerBox;
+    scrollBox;
+    footerBox;
+    selectableItems = [];
+    constructor(renderer, state) {
+        this.renderer = renderer;
+        this.state = state;
+        // Root container - full screen, vertical flex
+        this.rootBox = new BoxRenderable(renderer, {
+            width: '100%',
+            height: '100%',
+            flexDirection: 'column',
+        });
+        // Header - fixed at top
+        this.headerBox = new BoxRenderable(renderer, {
+            width: '100%',
+            height: 3,
+            border: true,
+            borderStyle: 'single',
+            borderColor: '#555555',
+            backgroundColor: '#1a1a2e',
+        });
+        // Scrollable content area
+        this.scrollBox = new ScrollBoxRenderable(renderer, {
+            width: '100%',
+            flexGrow: 1,
+            scrollY: true,
+            backgroundColor: '#0f0f1a',
+        });
+        // Footer - fixed at bottom
+        this.footerBox = new BoxRenderable(renderer, {
+            width: '100%',
+            height: 2,
+            border: true,
+            borderStyle: 'single',
+            borderColor: '#555555',
+            backgroundColor: '#1a1a2e',
+            paddingLeft: 1,
+        });
+        this.rootBox.add(this.headerBox);
+        this.rootBox.add(this.scrollBox);
+        this.rootBox.add(this.footerBox);
+        renderer.root.add(this.rootBox);
+        this.buildUI();
+    }
+    buildUI() {
+        // Clear previous content
+        this.selectableItems = [];
+        // Clear scrollbox content
+        const children = this.scrollBox.getChildren();
+        for (const child of children) {
+            this.scrollBox.remove(child.id);
+        }
+        // Build header
+        this.buildHeader();
+        // Build content
+        this.buildContent();
+        // Build footer
+        this.buildFooter();
+    }
+    buildHeader() {
+        // Clear header
+        const headerChildren = this.headerBox.getChildren();
+        for (const child of headerChildren) {
+            this.headerBox.remove(child.id);
+        }
+        const totalChanges = this.state.reasoningGroups.length;
+        const headerText = new TextRenderable(this.renderer, {
+            content: ` CodeWalker - ${this.state.branch} (${totalChanges} logical changes)`,
+            fg: '#88ccff',
+            paddingTop: 0,
+            paddingLeft: 1,
+        });
+        this.headerBox.add(headerText);
+    }
+    buildContent() {
+        this.state.reasoningGroups.forEach((group, reasoningIdx) => {
+            const isExpanded = this.state.expandedReasonings.has(reasoningIdx);
+            const isSelected = this.isReasoningSelected(reasoningIdx);
+            // Reasoning container
+            const reasoningBox = new BoxRenderable(this.renderer, {
+                width: '100%',
+                flexDirection: 'column',
+                paddingLeft: 1,
+                paddingTop: 1,
+                backgroundColor: isSelected ? '#2a2a4e' : undefined,
+            });
+            // Reasoning header with arrow and text
+            const arrow = isExpanded ? '▼' : '▶';
+            const fileCount = group.files.length;
+            const reasoningHeader = new TextRenderable(this.renderer, {
+                content: `${arrow} ${group.reasoning} (${fileCount} file${fileCount !== 1 ? 's' : ''})`,
+                fg: isSelected ? '#ffffff' : '#cccccc',
+                width: '100%',
+            });
+            reasoningBox.add(reasoningHeader);
+            this.selectableItems.push({
+                type: 'reasoning',
+                reasoningIdx,
+                renderable: reasoningBox,
+            });
+            // If expanded, show files
+            if (isExpanded) {
+                group.files.forEach((file) => {
+                    const fileKey = `${reasoningIdx}|${file.path}`;
+                    const isFileExpanded = this.state.expandedFiles.has(fileKey);
+                    const isFileSelected = this.isFileSelected(reasoningIdx, file.path);
+                    // File container
+                    const fileBox = new BoxRenderable(this.renderer, {
+                        width: '100%',
+                        flexDirection: 'column',
+                        paddingLeft: 3,
+                        paddingTop: 1,
+                        backgroundColor: isFileSelected ? '#2a2a4e' : undefined,
+                    });
+                    // File header
+                    const fileArrow = isFileExpanded ? '▼' : '▶';
+                    const fileHeader = new TextRenderable(this.renderer, {
+                        content: `${fileArrow} ${file.path}`,
+                        fg: isFileSelected ? '#88ccff' : '#6699cc',
+                    });
+                    fileBox.add(fileHeader);
+                    this.selectableItems.push({
+                        type: 'file',
+                        reasoningIdx,
+                        filePath: file.path,
+                        renderable: fileBox,
+                    });
+                    // If file is expanded, show diff
+                    if (isFileExpanded && file.hunks.length > 0) {
+                        const diffContent = hunksToUnifiedDiff(file.path, file.hunks);
+                        const fileType = getFileType(file.path);
+                        const diffBox = new BoxRenderable(this.renderer, {
+                            width: '100%',
+                            border: true,
+                            borderStyle: 'single',
+                            borderColor: '#444444',
+                            title: file.path,
+                            titleAlignment: 'left',
+                            marginLeft: 2,
+                            marginTop: 1,
+                            marginBottom: 1,
+                        });
+                        const diffRenderable = new DiffRenderable(this.renderer, {
+                            diff: diffContent,
+                            view: 'unified',
+                            showLineNumbers: true,
+                            filetype: fileType,
+                            addedBg: '#1a3d1a',
+                            removedBg: '#3d1a1a',
+                            contextBg: '#1a1a2e',
+                            addedSignColor: '#22cc22',
+                            removedSignColor: '#cc2222',
+                            lineNumberFg: '#666666',
+                            width: '100%',
+                        });
+                        diffBox.add(diffRenderable);
+                        fileBox.add(diffBox);
+                    }
+                    reasoningBox.add(fileBox);
+                });
+            }
+            this.scrollBox.add(reasoningBox);
+        });
+    }
+    buildFooter() {
+        // Clear footer
+        const footerChildren = this.footerBox.getChildren();
+        for (const child of footerChildren) {
+            this.footerBox.remove(child.id);
+        }
+        const totalItems = this.selectableItems.length;
+        const currentPos = this.state.selectedIndex + 1;
+        const footerText = new TextRenderable(this.renderer, {
+            content: `j/k: navigate │ Enter: expand/collapse │ q: quit          [${currentPos}/${totalItems}]`,
+            fg: '#888888',
+        });
+        this.footerBox.add(footerText);
+    }
+    isReasoningSelected(reasoningIdx) {
+        const item = this.selectableItems[this.state.selectedIndex];
+        return item?.type === 'reasoning' && item.reasoningIdx === reasoningIdx;
+    }
+    isFileSelected(reasoningIdx, filePath) {
+        const item = this.selectableItems[this.state.selectedIndex];
+        return item?.type === 'file' && item.reasoningIdx === reasoningIdx && item.filePath === filePath;
+    }
+    getItemCount() {
+        return this.selectableItems.length;
+    }
+    toggleExpand() {
+        const item = this.selectableItems[this.state.selectedIndex];
+        if (!item)
+            return;
+        if (item.type === 'reasoning') {
+            if (this.state.expandedReasonings.has(item.reasoningIdx)) {
+                this.state.expandedReasonings.delete(item.reasoningIdx);
+                // Collapse all files in this reasoning
+                for (const key of this.state.expandedFiles) {
+                    if (key.startsWith(`${item.reasoningIdx}|`)) {
+                        this.state.expandedFiles.delete(key);
+                    }
+                }
+            }
+            else {
+                this.state.expandedReasonings.add(item.reasoningIdx);
+            }
+        }
+        else if (item.type === 'file' && item.filePath) {
+            const fileKey = `${item.reasoningIdx}|${item.filePath}`;
+            if (this.state.expandedFiles.has(fileKey)) {
+                this.state.expandedFiles.delete(fileKey);
+            }
+            else {
+                this.state.expandedFiles.add(fileKey);
+            }
+        }
+        this.buildUI();
+    }
+    moveSelection(delta) {
+        const newIndex = this.state.selectedIndex + delta;
+        if (newIndex >= 0 && newIndex < this.selectableItems.length) {
+            this.state.selectedIndex = newIndex;
+            this.buildUI();
+        }
+    }
+    refresh() {
+        this.buildUI();
+    }
+    destroy() {
+        this.renderer.root.remove(this.rootBox.id);
+    }
+}

package/dist/types/codewalker.d.ts

@@ -0,0 +1,15 @@
+export type Changeset = {
+    version: number;
+    commit: string;
+    author: string;
+    changes: Change[];
+};
+export type Change = {
+    reasoning: string;
+    files: FileChange[];
+};
+export type FileChange = {
+    path: string;
+    hunks: number[];
+};
+//# sourceMappingURL=codewalker.d.ts.map

package/dist/types/codewalker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codewalker.d.ts","sourceRoot":"","sources":["../../src/types/codewalker.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG;IAEtB,OAAO,EAAE,MAAM,CAAC;IAGhB,MAAM,EAAE,MAAM,CAAC;IAGf,MAAM,EAAE,MAAM,CAAC;IAGf,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IAGnB,SAAS,EAAE,MAAM,CAAC;IAGlB,KAAK,EAAE,UAAU,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IAEvB,IAAI,EAAE,MAAM,CAAC;IAKb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC"}

package/dist/types/codewalker.js

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

package/dist/utils/git.d.ts

@@ -0,0 +1,24 @@
+export interface CommitInfo {
+    sha: string;
+    shortSha: string;
+    author: string;
+    message: string;
+}
+export interface ParsedHunk {
+    hunkNumber: number;
+    header: string;
+    content: string;
+}
+export interface FileDiff {
+    path: string;
+    hunks: ParsedHunk[];
+}
+export declare function getCurrentBranch(cwd: string): string;
+export declare function getCommitList(cwd: string): CommitInfo[];
+export declare function isGitRepo(cwd: string): boolean;
+export declare function getMainBranch(cwd: string): string;
+export declare function getMergeBase(cwd: string, branch1: string, branch2: string): string;
+export declare function getCommitDiff(cwd: string, commitSha: string): string;
+export declare function parseDiffIntoFiles(diffOutput: string): FileDiff[];
+export declare function getCommitFileDiffs(cwd: string, commitSha: string): FileDiff[];
+//# sourceMappingURL=git.d.ts.map

package/dist/utils/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../src/utils/git.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,UAAU,EAAE,CAAC;CACrB;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CASpD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,EAAE,CAuBvD;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAO9C;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAWjD;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CASlF;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAUpE;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,EAAE,CAsDjE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,QAAQ,EAAE,CAG7E"}

package/dist/utils/git.js

@@ -0,0 +1,132 @@
+import { execSync } from 'child_process';
+export function getCurrentBranch(cwd) {
+    try {
+        return execSync('git rev-parse --abbrev-ref HEAD', {
+            cwd,
+            encoding: 'utf-8',
+        }).trim();
+    }
+    catch {
+        throw new Error('Not a git repository or git is not installed');
+    }
+}
+export function getCommitList(cwd) {
+    try {
+        const output = execSync('git log --format="%H|%h|%an|%s" --first-parent', {
+            cwd,
+            encoding: 'utf-8',
+        });
+        return output
+            .trim()
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => {
+            const [sha, shortSha, author, ...messageParts] = line.split('|');
+            return {
+                sha,
+                shortSha,
+                author,
+                message: messageParts.join('|'),
+            };
+        });
+    }
+    catch {
+        throw new Error('Failed to get commit list');
+    }
+}
+export function isGitRepo(cwd) {
+    try {
+        execSync('git rev-parse --git-dir', { cwd, encoding: 'utf-8' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getMainBranch(cwd) {
+    try {
+        // Try to get the default branch from origin
+        const result = execSync('git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null || echo "refs/heads/main"', {
+            cwd,
+            encoding: 'utf-8',
+        }).trim();
+        return result.replace('refs/remotes/origin/', '').replace('refs/heads/', '');
+    }
+    catch {
+        return 'main';
+    }
+}
+export function getMergeBase(cwd, branch1, branch2) {
+    try {
+        return execSync(`git merge-base ${branch1} ${branch2}`, {
+            cwd,
+            encoding: 'utf-8',
+        }).trim();
+    }
+    catch {
+        throw new Error(`Failed to find merge base between ${branch1} and ${branch2}`);
+    }
+}
+export function getCommitDiff(cwd, commitSha) {
+    try {
+        return execSync(`git show ${commitSha} --format="" --patch`, {
+            cwd,
+            encoding: 'utf-8',
+            maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large diffs
+        });
+    }
+    catch {
+        return '';
+    }
+}
+export function parseDiffIntoFiles(diffOutput) {
+    const files = [];
+    // Split by file headers (diff --git a/... b/...)
+    const fileChunks = diffOutput.split(/^diff --git /m).filter(Boolean);
+    for (const chunk of fileChunks) {
+        const lines = chunk.split('\n');
+        // Extract file path from the first line (a/path b/path)
+        const headerMatch = lines[0]?.match(/a\/(.+?) b\/(.+)/);
+        if (!headerMatch)
+            continue;
+        const filePath = headerMatch[2];
+        const hunks = [];
+        let currentHunk = null;
+        let hunkNumber = 0;
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i];
+            // Start of a new hunk
+            if (line.startsWith('@@')) {
+                if (currentHunk) {
+                    hunks.push(currentHunk);
+                }
+                hunkNumber++;
+                currentHunk = {
+                    hunkNumber,
+                    header: line,
+                    content: '',
+                };
+            }
+            else if (currentHunk) {
+                // Skip binary file markers and other metadata
+                if (line.startsWith('Binary files') || line.startsWith('index ') ||
+                    line.startsWith('---') || line.startsWith('+++') ||
+                    line.startsWith('new file') || line.startsWith('deleted file')) {
+                    continue;
+                }
+                currentHunk.content += line + '\n';
+            }
+        }
+        if (currentHunk) {
+            hunks.push(currentHunk);
+        }
+        if (hunks.length > 0) {
+            files.push({ path: filePath, hunks });
+        }
+    }
+    return files;
+}
+export function getCommitFileDiffs(cwd, commitSha) {
+    const diffOutput = getCommitDiff(cwd, commitSha);
+    return parseDiffIntoFiles(diffOutput);
+}

package/dist/utils/tracking.d.ts

@@ -0,0 +1,23 @@
+import type { Changeset } from '../types/codewalker.js';
+import type { CommitInfo, ParsedHunk } from './git.js';
+export interface TrackedCommit {
+    commit: CommitInfo;
+    tracking: Changeset | null;
+}
+export interface FileWithHunks {
+    path: string;
+    hunks: ParsedHunk[];
+    hunkNumbers: number[];
+}
+export interface ReasoningGroup {
+    reasoning: string;
+    files: FileWithHunks[];
+}
+export declare function loadTrackingFiles(cwd: string, commits: CommitInfo[]): Promise<TrackedCommit[]>;
+export declare function getTrackedCommits(trackedCommits: TrackedCommit[]): TrackedCommit[];
+/**
+ * Aggregates all tracking data into reasoning groups with actual diff hunks.
+ * This is the "By Reasoning" view - grouping changes by their logical purpose.
+ */
+export declare function aggregateByReasoning(cwd: string, trackedCommits: TrackedCommit[]): ReasoningGroup[];
+//# sourceMappingURL=tracking.d.ts.map

package/dist/utils/tracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracking.d.ts","sourceRoot":"","sources":["../../src/utils/tracking.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAY,UAAU,EAAE,MAAM,UAAU,CAAC;AAGjE,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB;AAED,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,UAAU,EAAE,GACpB,OAAO,CAAC,aAAa,EAAE,CAAC,CAkB1B;AAED,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,CAElF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,aAAa,EAAE,GAC9B,cAAc,EAAE,CAiElB"}

package/dist/utils/tracking.js

@@ -0,0 +1,85 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { getCommitFileDiffs } from './git.js';
+export async function loadTrackingFiles(cwd, commits) {
+    const result = [];
+    for (const commit of commits) {
+        const trackingPath = path.join(cwd, '.codewalker', `${commit.shortSha}.json`);
+        let tracking = null;
+        try {
+            const content = await fs.readFile(trackingPath, 'utf-8');
+            tracking = JSON.parse(content);
+        }
+        catch {
+            // No tracking file for this commit
+        }
+        result.push({ commit, tracking });
+    }
+    return result;
+}
+export function getTrackedCommits(trackedCommits) {
+    return trackedCommits.filter((tc) => tc.tracking !== null);
+}
+/**
+ * Aggregates all tracking data into reasoning groups with actual diff hunks.
+ * This is the "By Reasoning" view - grouping changes by their logical purpose.
+ */
+export function aggregateByReasoning(cwd, trackedCommits) {
+    const reasoningMap = new Map();
+    // Build a map of commit SHA to file diffs for quick lookup
+    const commitDiffs = new Map();
+    for (const tc of trackedCommits) {
+        if (!tc.tracking)
+            continue;
+        // Get diffs for this commit (lazy load)
+        if (!commitDiffs.has(tc.commit.shortSha)) {
+            commitDiffs.set(tc.commit.shortSha, getCommitFileDiffs(cwd, tc.commit.shortSha));
+        }
+        const fileDiffs = commitDiffs.get(tc.commit.shortSha) || [];
+        for (const change of tc.tracking.changes) {
+            // Use reasoning as the key (could also include commit if you want per-commit grouping)
+            const key = change.reasoning;
+            if (!reasoningMap.has(key)) {
+                reasoningMap.set(key, {
+                    reasoning: change.reasoning,
+                    files: [],
+                });
+            }
+            const group = reasoningMap.get(key);
+            for (const fileChange of change.files) {
+                // Find the diff for this file
+                const fileDiff = fileDiffs.find((fd) => fd.path === fileChange.path);
+                if (!fileDiff)
+                    continue;
+                // Get only the hunks specified in the tracking file
+                const selectedHunks = fileChange.hunks
+                    .map((hunkNum) => fileDiff.hunks.find((h) => h.hunkNumber === hunkNum))
+                    .filter((h) => h != null);
+                if (selectedHunks.length === 0)
+                    continue;
+                // Check if this file is already in the group
+                const existingFile = group.files.find((f) => f.path === fileChange.path);
+                if (existingFile) {
+                    // Merge hunks (avoid duplicates)
+                    for (const hunk of selectedHunks) {
+                        if (!existingFile.hunks.find((h) => h.hunkNumber === hunk.hunkNumber)) {
+                            existingFile.hunks.push(hunk);
+                            existingFile.hunkNumbers.push(hunk.hunkNumber);
+                        }
+                    }
+                }
+                else {
+                    group.files.push({
+                        path: fileChange.path,
+                        hunks: selectedHunks,
+                        hunkNumbers: fileChange.hunks,
+                    });
+                }
+            }
+        }
+    }
+    // Convert map to array and sort by number of files (most impactful first)
+    return Array.from(reasoningMap.values())
+        .filter((group) => group.files.length > 0)
+        .sort((a, b) => b.files.length - a.files.length);
+}