├── src
    ├── adapters
    │   ├── outbound
    │   │   ├── index.ts
    │   │   └── gateways
    │   │   │   ├── FastGlobGateway.ts
    │   │   │   ├── VscodeWorkspaceStateGateway.ts
    │   │   │   ├── index.ts
    │   │   │   ├── VscodeEditorGateway.ts
    │   │   │   ├── VscodeNotificationGateway.ts
    │   │   │   ├── VscodeFileSystemGateway.ts
    │   │   │   └── HNApiGateway.ts
    │   ├── index.ts
    │   └── inbound
    │   │   ├── index.ts
    │   │   ├── ui
    │   │       ├── index.ts
    │   │       └── webview
    │   │       │   ├── core
    │   │       │       └── index.ts
    │   │       │   ├── index.ts
    │   │       │   ├── components
    │   │       │       ├── content
    │   │       │       │   ├── index.ts
    │   │       │       │   └── ContentView.ts
    │   │       │       ├── waiting
    │   │       │       │   ├── index.ts
    │   │       │       │   ├── WaitingScreen.ts
    │   │       │       │   └── HNFeed.ts
    │   │       │       ├── markdown
    │   │       │       │   └── index.ts
    │   │       │       ├── sidebar
    │   │       │       │   ├── index.ts
    │   │       │       │   ├── FileSearch.ts
    │   │       │       │   ├── AIStatus.ts
    │   │       │       │   └── Sidebar.ts
    │   │       │       ├── index.ts
    │   │       │       └── diff
    │   │       │       │   ├── index.ts
    │   │       │       │   ├── DiffHeader.ts
    │   │       │       │   └── DiffViewer.ts
    │   │       │   ├── state
    │   │       │       ├── index.ts
    │   │       │       ├── types.ts
    │   │       │       └── StateManager.ts
    │   │       │   ├── utils
    │   │       │       ├── index.ts
    │   │       │       ├── events.ts
    │   │       │       ├── dom.ts
    │   │       │       ├── collections.ts
    │   │       │       └── scroll.ts
    │   │       │   ├── main.ts
    │   │       │   ├── template.ts
    │   │       │   ├── webview-app.ts
    │   │       │   ├── html.ts
    │   │       │   └── webview-entry.ts
    │   │   └── controllers
    │   │       ├── index.ts
    │   │       └── ClaudeCodeConfigController.ts
    ├── infrastructure
    │   ├── index.ts
    │   └── repositories
    │   │   ├── index.ts
    │   │   ├── InMemoryFileThreadMappingRepository.ts
    │   │   ├── InMemorySnapshotRepository.ts
    │   │   ├── JsonThreadStateRepository.ts
    │   │   └── JsonCommentRepository.ts
    ├── domain
    │   ├── index.ts
    │   ├── services
    │   │   ├── index.ts
    │   │   └── TerminalStatusDetector.ts
    │   └── entities
    │   │   ├── index.ts
    │   │   ├── Diff.ts
    │   │   ├── FileSnapshot.ts
    │   │   ├── ScopedDiff.ts
    │   │   ├── FileThreadMapping.ts
    │   │   ├── AISession.ts
    │   │   ├── Scope.ts
    │   │   ├── HNStory.ts
    │   │   ├── ThreadState.ts
    │   │   └── Comment.ts
    ├── application
    │   ├── index.ts
    │   ├── ports
    │   │   ├── outbound
    │   │   │   ├── IFileGlobber.ts
    │   │   │   ├── IHNApiPort.ts
    │   │   │   ├── INotificationPort.ts
    │   │   │   ├── IEditorPort.ts
    │   │   │   ├── IWorkspaceStatePort.ts
    │   │   │   ├── IThreadStateRepository.ts
    │   │   │   ├── IFileThreadMappingRepository.ts
    │   │   │   ├── ISnapshotRepository.ts
    │   │   │   ├── IFileSystemPort.ts
    │   │   │   ├── ISymbolPort.ts
    │   │   │   ├── index.ts
    │   │   │   ├── ICommentRepository.ts
    │   │   │   ├── ITerminalPort.ts
    │   │   │   ├── SessionContext.ts
    │   │   │   ├── IGitPort.ts
    │   │   │   └── PanelState.ts
    │   │   ├── index.ts
    │   │   └── inbound
    │   │   │   ├── ICaptureSnapshotsUseCase.ts
    │   │   │   ├── IDeleteCommentUseCase.ts
    │   │   │   ├── IGenerateScopedDiffUseCase.ts
    │   │   │   ├── ITrackFileOwnershipUseCase.ts
    │   │   │   ├── IEditCommentUseCase.ts
    │   │   │   ├── IOpenInEditorUseCase.ts
    │   │   │   ├── IAddCommentUseCase.ts
    │   │   │   ├── IFetchHNStoriesUseCase.ts
    │   │   │   ├── ISubmitCommentsUseCase.ts
    │   │   │   ├── IAttachToWorktreeUseCase.ts
    │   │   │   ├── IGenerateDiffUseCase.ts
    │   │   │   ├── IDeleteThreadUseCase.ts
    │   │   │   ├── IManageWhitelistUseCase.ts
    │   │   │   ├── ICreateThreadUseCase.ts
    │   │   │   ├── IDetectThreadStatusUseCase.ts
    │   │   │   └── index.ts
    │   ├── useCases
    │   │   ├── DeleteCommentUseCase.ts
    │   │   ├── EditCommentUseCase.ts
    │   │   ├── TrackFileOwnershipUseCase.ts
    │   │   ├── AddCommentUseCase.ts
    │   │   ├── index.ts
    │   │   ├── OpenInEditorUseCase.ts
    │   │   ├── ManageWhitelistUseCase.ts
    │   │   ├── GenerateScopedDiffUseCase.ts
    │   │   ├── AttachToWorktreeUseCase.ts
    │   │   ├── CaptureSnapshotsUseCase.ts
    │   │   ├── DeleteThreadUseCase.ts
    │   │   ├── FetchHNStoriesUseCase.ts
    │   │   ├── GenerateDiffUseCase.ts
    │   │   └── CreateThreadUseCase.ts
    │   └── services
    │   │   ├── IPanelStateManager.ts
    │   │   └── BatchEventCollector.ts
    ├── types
    │   └── git.ts
    └── test
    │   ├── application
    │       └── useCases
    │       │   └── TrackFileOwnershipUseCase.test.ts
    │   ├── domain
    │       └── services
    │       │   └── TerminalStatusDetector.test.ts
    │   └── infrastructure
    │       └── repositories
    │           └── InMemoryFileThreadMappingRepository.test.ts
├── assets
    ├── sidecar-full.png
    ├── sidecar-icon.png
    ├── code-squad-full.png
    └── code-squad-icon.png
├── .gitignore
├── .vscodeignore
├── .eslintrc.json
├── tsconfig.json
├── .github
    └── workflows
    │   └── publish.yml
├── LICENSE
├── SIDECAR_README.md
├── README.md
└── package.json


/src/adapters/outbound/index.ts:
--------------------------------------------------------------------------------
1 | export * from './gateways';
2 | 


--------------------------------------------------------------------------------
/src/infrastructure/index.ts:
--------------------------------------------------------------------------------
1 | export * from './repositories';
2 | 


--------------------------------------------------------------------------------
/src/domain/index.ts:
--------------------------------------------------------------------------------
1 | export * from './entities';
2 | export * from './services';
3 | 


--------------------------------------------------------------------------------
/src/adapters/index.ts:
--------------------------------------------------------------------------------
1 | export * from './inbound';
2 | export * from './outbound';
3 | 


--------------------------------------------------------------------------------
/src/application/index.ts:
--------------------------------------------------------------------------------
1 | export * from './ports';
2 | export * from './useCases';
3 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/index.ts:
--------------------------------------------------------------------------------
1 | export * from './controllers';
2 | export * from './ui';
3 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/index.ts:
--------------------------------------------------------------------------------
1 | export { CodeSquadPanelAdapter } from './CodeSquadPanelAdapter';
2 | 


--------------------------------------------------------------------------------
/assets/sidecar-full.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/team-attention/code-squad/HEAD/assets/sidecar-full.png


--------------------------------------------------------------------------------
/assets/sidecar-icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/team-attention/code-squad/HEAD/assets/sidecar-icon.png


--------------------------------------------------------------------------------
/assets/code-squad-full.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/team-attention/code-squad/HEAD/assets/code-squad-full.png


--------------------------------------------------------------------------------
/assets/code-squad-icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/team-attention/code-squad/HEAD/assets/code-squad-icon.png


--------------------------------------------------------------------------------
/src/application/ports/outbound/IFileGlobber.ts:
--------------------------------------------------------------------------------
1 | export interface IFileGlobber {
2 |     glob(pattern: string, cwd: string): Promise<string[]>;
3 | }
4 | 


--------------------------------------------------------------------------------
/src/application/ports/index.ts:
--------------------------------------------------------------------------------
1 | // Re-export from inbound and outbound for organized access
2 | export * from './inbound';
3 | export * from './outbound';
4 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/core/index.ts:
--------------------------------------------------------------------------------
1 | /**
2 |  * Core module exports
3 |  */
4 | 
5 | export { initialize, getVSCode, cleanup, stateManager } from './App';
6 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/ICaptureSnapshotsUseCase.ts:
--------------------------------------------------------------------------------
1 | export interface ICaptureSnapshotsUseCase {
2 |     execute(includePatterns: string[]): Promise<number>;
3 | }
4 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/controllers/index.ts:
--------------------------------------------------------------------------------
1 | export { AIDetectionController } from './AIDetectionController';
2 | export { FileWatchController } from './FileWatchController';
3 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/IDeleteCommentUseCase.ts:
--------------------------------------------------------------------------------
1 | export interface DeleteCommentInput {
2 |     id: string;
3 | }
4 | 
5 | export interface IDeleteCommentUseCase {
6 |     execute(input: DeleteCommentInput): Promise<boolean>;
7 | }
8 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/index.ts:
--------------------------------------------------------------------------------
1 | export { getWebviewContent } from './template';
2 | export { webviewStyles } from './styles';
3 | export { webviewHtml } from './html';
4 | // webviewScript no longer exported - all logic is in the bundled webview.js
5 | 


--------------------------------------------------------------------------------
/src/domain/services/index.ts:
--------------------------------------------------------------------------------
1 | export { DiffService, DiffEntry } from './DiffService';
2 | export { ScopeMappingService, ScopeInfo } from './ScopeMappingService';
3 | export { TerminalStatusDetector, ITerminalStatusDetector } from './TerminalStatusDetector';
4 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/content/index.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Content View component barrel export
 3 |  */
 4 | 
 5 | export {
 6 |     renderContentView,
 7 |     renderContentViewHeader,
 8 |     type ContentViewProps,
 9 | } from './ContentView';
10 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/IGenerateScopedDiffUseCase.ts:
--------------------------------------------------------------------------------
1 | import { ScopedDiffResult } from '../../../domain/entities/ScopedDiff';
2 | 
3 | export interface IGenerateScopedDiffUseCase {
4 |     execute(relativePath: string): Promise<ScopedDiffResult | null>;
5 | }
6 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/ITrackFileOwnershipUseCase.ts:
--------------------------------------------------------------------------------
1 | export interface TrackFileOwnershipInput {
2 |     filePath: string;
3 |     threadId: string;
4 | }
5 | 
6 | export interface ITrackFileOwnershipUseCase {
7 |     execute(input: TrackFileOwnershipInput): Promise<void>;
8 | }
9 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/IHNApiPort.ts:
--------------------------------------------------------------------------------
1 | import { HNStory } from '../../../domain/entities/HNStory';
2 | 
3 | export interface IHNApiPort {
4 |   fetchTopStoryIds(): Promise<number[]>;
5 |   fetchStory(id: number): Promise<HNStory | null>;
6 |   fetchStories(ids: number[]): Promise<HNStory[]>;
7 | }
8 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/INotificationPort.ts:
--------------------------------------------------------------------------------
1 | export interface INotificationPort {
2 |     showInfo(message: string): void;
3 |     showWarning(message: string): void;
4 |     showError(message: string): void;
5 |     showSystemNotification(title: string, message: string, onClick?: () => void): void;
6 | }
7 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/IEditCommentUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { Comment } from '../../../domain/entities/Comment';
 2 | 
 3 | export interface EditCommentInput {
 4 |     id: string;
 5 |     text: string;
 6 | }
 7 | 
 8 | export interface IEditCommentUseCase {
 9 |     execute(input: EditCommentInput): Promise<Comment | null>;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/state/index.ts:
--------------------------------------------------------------------------------
 1 | export {
 2 |   StateManager,
 3 |   stateManager,
 4 |   MAX_COLLAPSED_FOLDERS,
 5 |   MAX_SEARCH_MATCHES,
 6 |   MAX_HIGHLIGHT_ENTRIES,
 7 | } from './StateManager';
 8 | export type {
 9 |   WebviewState,
10 |   SelectionState,
11 |   UIState,
12 |   SearchState,
13 |   ViewState,
14 | } from './types';
15 | 


--------------------------------------------------------------------------------
/src/infrastructure/repositories/index.ts:
--------------------------------------------------------------------------------
1 | export { JsonCommentRepository } from './JsonCommentRepository';
2 | export { InMemorySnapshotRepository } from './InMemorySnapshotRepository';
3 | export { InMemoryFileThreadMappingRepository } from './InMemoryFileThreadMappingRepository';
4 | export { JsonThreadStateRepository } from './JsonThreadStateRepository';
5 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/IOpenInEditorUseCase.ts:
--------------------------------------------------------------------------------
 1 | export interface OpenInEditorInput {
 2 |     threadId: string;
 3 | }
 4 | 
 5 | export interface OpenInEditorOutput {
 6 |     success: boolean;
 7 |     error?: string;
 8 | }
 9 | 
10 | export interface IOpenInEditorUseCase {
11 |     execute(input: OpenInEditorInput): Promise<OpenInEditorOutput>;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/waiting/index.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Waiting Components
 3 |  *
 4 |  * Components for the waiting screen shown when AI is processing.
 5 |  */
 6 | 
 7 | export { renderHNFeed, setupHNFeedHandlers } from './HNFeed';
 8 | export type { HNStory, HNFeedStatus } from './HNFeed';
 9 | 
10 | export { renderWaitingScreen, showWaitingScreen } from './WaitingScreen';
11 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/IEditorPort.ts:
--------------------------------------------------------------------------------
 1 | export type EditorType = 'cursor' | 'vscode';
 2 | 
 3 | export interface IEditorPort {
 4 |     /**
 5 |      * Get the current editor type based on environment
 6 |      */
 7 |     getEditorType(): EditorType;
 8 | 
 9 |     /**
10 |      * Open a folder in a new editor window
11 |      */
12 |     openFolder(folderPath: string): Promise<void>;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/IAddCommentUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { Comment } from '../../../domain/entities/Comment';
 2 | 
 3 | export interface AddCommentInput {
 4 |     file: string;
 5 |     line: number;
 6 |     endLine?: number;
 7 |     text: string;
 8 |     codeContext: string;
 9 |     threadId?: string;
10 | }
11 | 
12 | export interface IAddCommentUseCase {
13 |     execute(input: AddCommentInput): Promise<Comment>;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/IFetchHNStoriesUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { HNStory } from '../../../domain/entities/HNStory';
 2 | 
 3 | export interface FetchHNStoriesResult {
 4 |   stories: HNStory[];
 5 |   fromCache: boolean;
 6 |   fetchedAt: number;
 7 |   hasMore: boolean;
 8 | }
 9 | 
10 | export interface IFetchHNStoriesUseCase {
11 |   execute(forceRefresh?: boolean): Promise<FetchHNStoriesResult>;
12 |   loadMore(): Promise<FetchHNStoriesResult>;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/ISubmitCommentsUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { AISession } from '../../../domain/entities/AISession';
 2 | 
 3 | export interface SubmitCommentsResult {
 4 |     submittedIds: string[];
 5 |     count: number;
 6 | }
 7 | 
 8 | export interface ISubmitCommentsUseCase {
 9 |     execute(session: AISession | undefined): Promise<SubmitCommentsResult | null>;
10 |     executeWithRouting(focusedSession: AISession | undefined): Promise<SubmitCommentsResult | null>;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/IWorkspaceStatePort.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Port for accessing VSCode workspace state (persistent storage per workspace).
 3 |  */
 4 | export interface IWorkspaceStatePort {
 5 |   get<T>(key: string): T | undefined;
 6 |   set<T>(key: string, value: T): Promise<void>;
 7 | }
 8 | 
 9 | export const WORKSPACE_STATE_KEYS = {
10 |   AUTO_OPEN_PANEL: 'codeSquad.autoOpenPanel',
11 | } as const;
12 | 
13 | export type AutoOpenPanelSetting = 'ask' | 'always' | 'never';
14 | 


--------------------------------------------------------------------------------
/src/adapters/outbound/gateways/FastGlobGateway.ts:
--------------------------------------------------------------------------------
 1 | import fg from 'fast-glob';
 2 | import { IFileGlobber } from '../../../application/ports/outbound/IFileGlobber';
 3 | 
 4 | export class FastGlobGateway implements IFileGlobber {
 5 |     async glob(pattern: string, cwd: string): Promise<string[]> {
 6 |         return fg(pattern, {
 7 |             cwd,
 8 |             absolute: true,
 9 |             ignore: ['**/node_modules/**'],
10 |             dot: true,
11 |         });
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/utils/index.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Utility functions barrel export
 3 |  */
 4 | 
 5 | export {
 6 |   escapeHtml,
 7 |   getElementById,
 8 |   querySelector,
 9 |   querySelectorAll,
10 | } from './dom';
11 | export { resetAbortController, getSignal, abortAllListeners } from './events';
12 | export {
13 |   getScrollableElement,
14 |   saveCurrentScrollPosition,
15 |   restoreScrollPosition,
16 | } from './scroll';
17 | export { SizeLimitedSet, SizeLimitedMap } from './collections';
18 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Dependencies
 2 | node_modules/
 3 | 
 4 | # Build output
 5 | out/
 6 | dist/
 7 | 
 8 | # VSCode extension package
 9 | *.vsix
10 | 
11 | # IDE/Editor settings
12 | .vscode/
13 | .idea/
14 | 
15 | # OS files
16 | .DS_Store
17 | Thumbs.db
18 | 
19 | # Claude Code settings (personal config)
20 | .claude/
21 | docs/
22 | 
23 | # Logs
24 | *.log
25 | npm-debug.log*
26 | 
27 | # Test coverage
28 | coverage/
29 | 
30 | # Temporary files
31 | *.tmp
32 | *.temp
33 | 
34 | .env
35 | CLAUDE.md
36 | .codex
37 | /content


--------------------------------------------------------------------------------
/src/domain/entities/index.ts:
--------------------------------------------------------------------------------
1 | export { Comment, CommentData } from './Comment';
2 | export { AISession, AISessionData, AIType } from './AISession';
3 | export { FileSnapshot, FileSnapshotData } from './FileSnapshot';
4 | export { FileThreadMapping, FileThreadMappingData } from './FileThreadMapping';
5 | export { HNStory, HNStoryData } from './HNStory';
6 | export { Scope, ScopeData } from './Scope';
7 | export { ScopedChunk, ScopedDiffResult } from './ScopedDiff';
8 | export { ThreadState, ThreadStateData } from './ThreadState';
9 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/IAttachToWorktreeUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { ThreadState } from '../../../domain/entities/ThreadState';
 2 | 
 3 | export interface AttachToWorktreeInput {
 4 |     worktreePath: string;
 5 |     name?: string;  // Optional, defaults to branch name
 6 |     workspaceRoot: string;
 7 | }
 8 | 
 9 | export interface AttachToWorktreeOutput {
10 |     threadState: ThreadState;
11 | }
12 | 
13 | export interface IAttachToWorktreeUseCase {
14 |     execute(input: AttachToWorktreeInput): Promise<AttachToWorktreeOutput>;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/IThreadStateRepository.ts:
--------------------------------------------------------------------------------
 1 | import { ThreadState } from '../../../domain/entities/ThreadState';
 2 | 
 3 | export interface IThreadStateRepository {
 4 |     save(state: ThreadState): Promise<void>;
 5 |     findAll(): Promise<ThreadState[]>;
 6 |     findById(threadId: string): Promise<ThreadState | null>;
 7 |     findByTerminalId(terminalId: string): Promise<ThreadState | null>;
 8 |     delete(threadId: string): Promise<boolean>;
 9 |     updateWhitelist(threadId: string, patterns: string[]): Promise<void>;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/IFileThreadMappingRepository.ts:
--------------------------------------------------------------------------------
 1 | import { FileThreadMapping } from '../../../domain/entities/FileThreadMapping';
 2 | 
 3 | export interface IFileThreadMappingRepository {
 4 |     save(mapping: FileThreadMapping): Promise<void>;
 5 |     findByFilePath(filePath: string): Promise<FileThreadMapping | null>;
 6 |     findByThreadId(threadId: string): Promise<FileThreadMapping[]>;
 7 |     findAll(): Promise<FileThreadMapping[]>;
 8 |     delete(filePath: string): Promise<boolean>;
 9 |     clear(): Promise<void>;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/ISnapshotRepository.ts:
--------------------------------------------------------------------------------
 1 | import { FileSnapshot } from '../../../domain/entities/FileSnapshot';
 2 | 
 3 | export interface SnapshotStats {
 4 |     count: number;
 5 |     totalSize: number;
 6 | }
 7 | 
 8 | export interface ISnapshotRepository {
 9 |     save(snapshot: FileSnapshot): Promise<boolean>;
10 |     findByPath(relativePath: string): Promise<FileSnapshot | undefined>;
11 |     has(relativePath: string): boolean;
12 |     clear(): void;
13 |     getAll(): Map<string, FileSnapshot>;
14 |     getStats(): SnapshotStats;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/application/useCases/DeleteCommentUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { ICommentRepository } from '../ports/outbound/ICommentRepository';
 2 | import { DeleteCommentInput, IDeleteCommentUseCase } from '../ports/inbound/IDeleteCommentUseCase';
 3 | 
 4 | export class DeleteCommentUseCase implements IDeleteCommentUseCase {
 5 |     constructor(private readonly commentRepository: ICommentRepository) {}
 6 | 
 7 |     async execute(input: DeleteCommentInput): Promise<boolean> {
 8 |         const { id } = input;
 9 |         return this.commentRepository.delete(id);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/IGenerateDiffUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { DiffResult } from '../../../domain/entities/Diff';
 2 | 
 3 | export interface IGenerateDiffUseCase {
 4 |     execute(relativePath: string): Promise<DiffResult | null>;
 5 | 
 6 |     /**
 7 |      * Set workspace root for worktree support.
 8 |      * Call this when switching to a different worktree.
 9 |      */
10 |     setWorkspaceRoot(workspaceRoot: string | undefined): void;
11 | 
12 |     /**
13 |      * Get current workspace root.
14 |      */
15 |     getWorkspaceRoot(): string | undefined;
16 | }
17 | 


--------------------------------------------------------------------------------
/.vscodeignore:
--------------------------------------------------------------------------------
 1 | # Source files (only compiled output needed)
 2 | .vscode/**
 3 | .vscode-test/**
 4 | src/**
 5 | out/**
 6 | **/*.ts
 7 | !dist/**
 8 | 
 9 | # Dependencies (bundled separately)
10 | node_modules/**
11 | 
12 | # Build artifacts
13 | *.vsix
14 | 
15 | # Development files
16 | .gitignore
17 | .eslintrc*
18 | tsconfig.json
19 | **/*.map
20 | 
21 | # Documentation (not needed in extension)
22 | docs/**
23 | .claude/**
24 | 
25 | # OS files
26 | .DS_Store
27 | Thumbs.db
28 | 
29 | # Test files
30 | **/*.test.ts
31 | coverage/**
32 | 
33 | # Misc
34 | *.log
35 | .git/**
36 | .env
37 | 


--------------------------------------------------------------------------------
/src/adapters/outbound/gateways/VscodeWorkspaceStateGateway.ts:
--------------------------------------------------------------------------------
 1 | import * as vscode from 'vscode';
 2 | import { IWorkspaceStatePort } from '../../../application/ports/outbound/IWorkspaceStatePort';
 3 | 
 4 | export class VscodeWorkspaceStateGateway implements IWorkspaceStatePort {
 5 |   constructor(private readonly workspaceState: vscode.Memento) {}
 6 | 
 7 |   get<T>(key: string): T | undefined {
 8 |     return this.workspaceState.get<T>(key);
 9 |   }
10 | 
11 |   async set<T>(key: string, value: T): Promise<void> {
12 |     await this.workspaceState.update(key, value);
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/main.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Webview Main Entry Point
 3 |  *
 4 |  * This file is kept for backwards compatibility.
 5 |  * All webview logic is now in the bundled script (webview-entry.ts → dist/webview.js).
 6 |  *
 7 |  * The bundled script includes:
 8 |  * - Shiki syntax highlighter (webview-entry.ts)
 9 |  * - Application logic (webview-app.ts → core/App.ts)
10 |  * - All UI components (components/*)
11 |  * - State management (state/*)
12 |  * - Utilities (utils/*)
13 |  */
14 | 
15 | // No longer exporting inline script - all logic is in the bundled webview.js
16 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/markdown/index.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Markdown Components
 3 |  */
 4 | 
 5 | export {
 6 |   createPreviewSelectionState,
 7 |   clearPreviewSelection,
 8 |   setupPreviewCommentHandlers,
 9 | } from './PreviewComments';
10 | export type {
11 |   PreviewSelectionState,
12 |   PreviewCommentHandlers,
13 | } from './PreviewComments';
14 | 
15 | export {
16 |   processInline,
17 |   renderTable,
18 |   renderMarkdown,
19 |   renderFullMarkdownWithHighlights,
20 | } from './MarkdownPreview';
21 | export type { MarkdownComment, DeletionInfo } from './MarkdownPreview';
22 | 


--------------------------------------------------------------------------------
/src/adapters/outbound/gateways/index.ts:
--------------------------------------------------------------------------------
 1 | export { VscodeTerminalGateway } from './VscodeTerminalGateway';
 2 | export { VscodeFileSystemGateway } from './VscodeFileSystemGateway';
 3 | export { VscodeGitGateway } from './VscodeGitGateway';
 4 | export { VscodeNotificationGateway } from './VscodeNotificationGateway';
 5 | export { FastGlobGateway } from './FastGlobGateway';
 6 | export { VscodeLspGateway } from './VscodeLspGateway';
 7 | export { HNApiGateway } from './HNApiGateway';
 8 | export { VscodeWorkspaceStateGateway } from './VscodeWorkspaceStateGateway';
 9 | export { VscodeEditorGateway } from './VscodeEditorGateway';
10 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/IDeleteThreadUseCase.ts:
--------------------------------------------------------------------------------
 1 | export interface DeleteThreadInput {
 2 |     threadId: string;
 3 |     workspaceRoot: string;
 4 |     closeTerminal?: boolean;    // default: true
 5 |     removeWorktree?: boolean;   // default: true for worktree threads
 6 | }
 7 | 
 8 | export interface DeleteThreadOutput {
 9 |     success: boolean;
10 |     deletedThreadId: string;
11 |     deletedCommentsCount: number;
12 |     worktreeRemoved: boolean;
13 |     terminalClosed: boolean;
14 | }
15 | 
16 | export interface IDeleteThreadUseCase {
17 |     execute(input: DeleteThreadInput): Promise<DeleteThreadOutput>;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/IManageWhitelistUseCase.ts:
--------------------------------------------------------------------------------
 1 | export interface AddWhitelistPatternInput {
 2 |     threadId: string;
 3 |     pattern: string;
 4 | }
 5 | 
 6 | export interface RemoveWhitelistPatternInput {
 7 |     threadId: string;
 8 |     pattern: string;
 9 | }
10 | 
11 | export interface GetWhitelistPatternsInput {
12 |     threadId: string;
13 | }
14 | 
15 | export interface IManageWhitelistUseCase {
16 |     addPattern(input: AddWhitelistPatternInput): Promise<void>;
17 |     removePattern(input: RemoveWhitelistPatternInput): Promise<void>;
18 |     getPatterns(input: GetWhitelistPatternsInput): Promise<string[]>;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/IFileSystemPort.ts:
--------------------------------------------------------------------------------
 1 | export interface IFileSystemPort {
 2 |     readFile(absolutePath: string): Promise<string>;
 3 |     fileExists(absolutePath: string): Promise<boolean>;
 4 |     isFile(absolutePath: string): Promise<boolean>;
 5 |     getWorkspaceRoot(): string | undefined;
 6 |     toAbsolutePath(relativePath: string): string;
 7 |     toRelativePath(absolutePath: string): string;
 8 |     copyFile(source: string, dest: string): Promise<void>;
 9 |     ensureDir(dirPath: string): Promise<void>;
10 |     /** Join path segments (platform-independent) */
11 |     joinPath(...segments: string[]): string;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/ICreateThreadUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { ThreadState } from '../../../domain/entities/ThreadState';
 2 | 
 3 | export type IsolationMode = 'none' | 'worktree';
 4 | 
 5 | export interface CreateThreadInput {
 6 |     name: string;
 7 |     isolationMode: IsolationMode;
 8 |     branchName?: string;
 9 |     worktreePath?: string;
10 |     workspaceRoot: string;
11 |     worktreeCopyPatterns?: string[];
12 | }
13 | 
14 | export interface CreateThreadOutput {
15 |     threadState: ThreadState;
16 | }
17 | 
18 | export interface ICreateThreadUseCase {
19 |     execute(input: CreateThreadInput): Promise<CreateThreadOutput>;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/application/useCases/EditCommentUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { Comment } from '../../domain/entities/Comment';
 2 | import { ICommentRepository } from '../ports/outbound/ICommentRepository';
 3 | import { EditCommentInput, IEditCommentUseCase } from '../ports/inbound/IEditCommentUseCase';
 4 | 
 5 | export class EditCommentUseCase implements IEditCommentUseCase {
 6 |     constructor(private readonly commentRepository: ICommentRepository) {}
 7 | 
 8 |     async execute(input: EditCommentInput): Promise<Comment | null> {
 9 |         const { id, text } = input;
10 | 
11 |         if (!text.trim()) {
12 |             return null;
13 |         }
14 | 
15 |         return this.commentRepository.update(id, text.trim());
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/adapters/outbound/gateways/VscodeEditorGateway.ts:
--------------------------------------------------------------------------------
 1 | import * as vscode from 'vscode';
 2 | import { exec } from 'child_process';
 3 | import { promisify } from 'util';
 4 | import { IEditorPort, EditorType } from '../../../application/ports/outbound/IEditorPort';
 5 | 
 6 | const execAsync = promisify(exec);
 7 | 
 8 | export class VscodeEditorGateway implements IEditorPort {
 9 |     getEditorType(): EditorType {
10 |         const appName = vscode.env.appName.toLowerCase();
11 |         return appName.includes('cursor') ? 'cursor' : 'vscode';
12 |     }
13 | 
14 |     async openFolder(folderPath: string): Promise<void> {
15 |         const command = this.getEditorType() === 'cursor' ? 'cursor' : 'code';
16 |         await execAsync(`${command} "${folderPath}"`);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/ISymbolPort.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Represents a scope containing a line range
 3 |  */
 4 | export interface ScopeInfo {
 5 |     name: string;
 6 |     containerName?: string;
 7 |     kind: string;
 8 |     startLine: number;
 9 |     endLine: number;
10 | }
11 | 
12 | /**
13 |  * Port for symbol/scope detection via Language Server Protocol
14 |  */
15 | export interface ISymbolPort {
16 |     getEnclosingScope(filePath: string, line: number): Promise<ScopeInfo | null>;
17 |     getScopesForRange(filePath: string, startLine: number, endLine: number): Promise<ScopeInfo[]>;
18 | 
19 |     /**
20 |      * Get all symbols for entire file.
21 |      * Used for building complete scope hierarchy.
22 |      */
23 |     getAllFileSymbols(filePath: string): Promise<ScopeInfo[]>;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/index.ts:
--------------------------------------------------------------------------------
 1 | export { ICommentRepository } from './ICommentRepository';
 2 | export { ISnapshotRepository } from './ISnapshotRepository';
 3 | export { IFileThreadMappingRepository } from './IFileThreadMappingRepository';
 4 | export { ITerminalPort } from './ITerminalPort';
 5 | export { IFileSystemPort } from './IFileSystemPort';
 6 | export { IGitPort } from './IGitPort';
 7 | export { INotificationPort } from './INotificationPort';
 8 | export { IFileGlobber } from './IFileGlobber';
 9 | export { ISymbolPort, ScopeInfo } from './ISymbolPort';
10 | export { SessionContext } from './SessionContext';
11 | export { IHNApiPort } from './IHNApiPort';
12 | export {
13 |   IWorkspaceStatePort,
14 |   WORKSPACE_STATE_KEYS,
15 |   AutoOpenPanelSetting,
16 | } from './IWorkspaceStatePort';
17 | 


--------------------------------------------------------------------------------
/src/domain/entities/Diff.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Represents a single line in a diff
 3 |  */
 4 | export interface DiffLine {
 5 |     type: 'addition' | 'deletion' | 'context';
 6 |     content: string;
 7 |     oldLineNumber?: number;
 8 |     newLineNumber?: number;
 9 | }
10 | 
11 | /**
12 |  * Represents a chunk of changes in a diff
13 |  */
14 | export interface DiffChunk {
15 |     header: string;
16 |     oldStart: number;
17 |     newStart: number;
18 |     lines: DiffLine[];
19 |     stats: {
20 |         additions: number;
21 |         deletions: number;
22 |     };
23 | }
24 | 
25 | /**
26 |  * Structured diff result for UI rendering
27 |  */
28 | export interface DiffResult {
29 |     file: string;
30 |     chunks: DiffChunk[];
31 |     stats: {
32 |         additions: number;
33 |         deletions: number;
34 |     };
35 | }
36 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/IDetectThreadStatusUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { AgentStatus, AIType } from '../../../domain/entities/AISession';
 2 | 
 3 | export interface StatusChangeCallback {
 4 |     (terminalId: string, status: AgentStatus): void;
 5 | }
 6 | 
 7 | export interface AITypeChangeCallback {
 8 |     (terminalId: string, aiType: AIType): void;
 9 | }
10 | 
11 | export interface IDetectThreadStatusUseCase {
12 |     processOutput(terminalId: string, aiType: AIType, output: string): void;
13 |     getStatus(terminalId: string): AgentStatus;
14 |     getAIType(terminalId: string): AIType | null;
15 |     onStatusChange(callback: StatusChangeCallback): void;
16 |     onAITypeChange(callback: AITypeChangeCallback): void;
17 |     clear(terminalId: string): void;
18 |     setThreadName(terminalId: string, name: string): void;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/utils/events.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Event Handling Utilities
 3 |  *
 4 |  * AbortController management for clean event listener cleanup.
 5 |  */
 6 | 
 7 | let globalAbortController = new AbortController();
 8 | 
 9 | /**
10 |  * Reset the global abort controller
11 |  * This aborts all existing event listeners and creates a new controller
12 |  */
13 | export function resetAbortController(): void {
14 |   globalAbortController.abort();
15 |   globalAbortController = new AbortController();
16 | }
17 | 
18 | /**
19 |  * Get the current abort signal for event listeners
20 |  */
21 | export function getSignal(): AbortSignal {
22 |   return globalAbortController.signal;
23 | }
24 | 
25 | /**
26 |  * Abort all event listeners and reset
27 |  */
28 | export function abortAllListeners(): void {
29 |   resetAbortController();
30 | }
31 | 


--------------------------------------------------------------------------------
/src/adapters/outbound/gateways/VscodeNotificationGateway.ts:
--------------------------------------------------------------------------------
 1 | import * as vscode from 'vscode';
 2 | import { INotificationPort } from '../../../application/ports/outbound/INotificationPort';
 3 | 
 4 | export class VscodeNotificationGateway implements INotificationPort {
 5 |     showInfo(message: string): void {
 6 |         vscode.window.showInformationMessage(message);
 7 |     }
 8 | 
 9 |     showWarning(message: string): void {
10 |         vscode.window.showWarningMessage(message);
11 |     }
12 | 
13 |     showError(message: string): void {
14 |         vscode.window.showErrorMessage(message);
15 |     }
16 | 
17 |     showSystemNotification(title: string, message: string, onClick?: () => void): void {
18 |         vscode.window.showInformationMessage(`${title}: ${message}`).then(() => {
19 |             onClick?.();
20 |         });
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/application/useCases/TrackFileOwnershipUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { FileThreadMapping } from '../../domain/entities/FileThreadMapping';
 2 | import { IFileThreadMappingRepository } from '../ports/outbound/IFileThreadMappingRepository';
 3 | import { ITrackFileOwnershipUseCase, TrackFileOwnershipInput } from '../ports/inbound/ITrackFileOwnershipUseCase';
 4 | 
 5 | export class TrackFileOwnershipUseCase implements ITrackFileOwnershipUseCase {
 6 |     constructor(
 7 |         private readonly mappingRepository: IFileThreadMappingRepository
 8 |     ) {}
 9 | 
10 |     async execute(input: TrackFileOwnershipInput): Promise<void> {
11 |         if (!input.threadId) {
12 |             return;
13 |         }
14 | 
15 |         const mapping = FileThreadMapping.create(input.filePath, input.threadId);
16 |         await this.mappingRepository.save(mapping);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/domain/entities/FileSnapshot.ts:
--------------------------------------------------------------------------------
 1 | export interface FileSnapshotData {
 2 |     relativePath: string;
 3 |     content: string;
 4 |     capturedAt: number;
 5 | }
 6 | 
 7 | export class FileSnapshot {
 8 |     readonly relativePath: string;
 9 |     readonly content: string;
10 |     readonly capturedAt: number;
11 | 
12 |     constructor(data: FileSnapshotData) {
13 |         this.relativePath = data.relativePath;
14 |         this.content = data.content;
15 |         this.capturedAt = data.capturedAt;
16 |     }
17 | 
18 |     get lines(): string[] {
19 |         return this.content.split('\n');
20 |     }
21 | 
22 |     static create(relativePath: string, content: string): FileSnapshot {
23 |         return new FileSnapshot({
24 |             relativePath,
25 |             content,
26 |             capturedAt: Date.now(),
27 |         });
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/application/ports/inbound/index.ts:
--------------------------------------------------------------------------------
 1 | export { IAddCommentUseCase, AddCommentInput } from './IAddCommentUseCase';
 2 | export { ICaptureSnapshotsUseCase } from './ICaptureSnapshotsUseCase';
 3 | export { IGenerateDiffUseCase } from './IGenerateDiffUseCase';
 4 | export { IGenerateScopedDiffUseCase } from './IGenerateScopedDiffUseCase';
 5 | export { ISubmitCommentsUseCase } from './ISubmitCommentsUseCase';
 6 | export { IEditCommentUseCase, EditCommentInput } from './IEditCommentUseCase';
 7 | export { IDeleteCommentUseCase, DeleteCommentInput } from './IDeleteCommentUseCase';
 8 | export { IFetchHNStoriesUseCase, FetchHNStoriesResult } from './IFetchHNStoriesUseCase';
 9 | export { ITrackFileOwnershipUseCase, TrackFileOwnershipInput } from './ITrackFileOwnershipUseCase';
10 | export { IDetectThreadStatusUseCase, StatusChangeCallback } from './IDetectThreadStatusUseCase';
11 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/template.ts:
--------------------------------------------------------------------------------
 1 | import { webviewStyles } from './styles';
 2 | import { webviewHtml } from './html';
 3 | 
 4 | export function getWebviewContent(bundledScriptUri?: string): string {
 5 |     // The bundled script (dist/webview.js) contains all webview logic:
 6 |     // - Shiki syntax highlighter
 7 |     // - State management
 8 |     // - All UI components
 9 |     // - Event handlers
10 |     const bundledScript = bundledScriptUri
11 |         ? `<script src="${bundledScriptUri}"></script>`
12 |         : '';
13 | 
14 |     return `<!DOCTYPE html>
15 | <html lang="en">
16 | <head>
17 |     <meta charset="UTF-8">
18 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
19 |     <title>Code Squad</title>
20 |     <style>${webviewStyles}</style>
21 | </head>
22 | ${webviewHtml}
23 | ${bundledScript}
24 | </body>
25 | </html>`;
26 | }
27 | 


--------------------------------------------------------------------------------
/.eslintrc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "root": true,
 3 |   "parser": "@typescript-eslint/parser",
 4 |   "parserOptions": {
 5 |     "ecmaVersion": 2020,
 6 |     "sourceType": "module"
 7 |   },
 8 |   "plugins": ["@typescript-eslint"],
 9 |   "extends": [
10 |     "eslint:recommended",
11 |     "plugin:@typescript-eslint/recommended"
12 |   ],
13 |   "rules": {
14 |     "@typescript-eslint/no-unused-vars": ["warn", { "argsIgnorePattern": "^_" }],
15 |     "@typescript-eslint/no-explicit-any": "warn",
16 |     "@typescript-eslint/explicit-function-return-type": "off",
17 |     "no-console": "off"
18 |   },
19 |   "ignorePatterns": [
20 |     "out",
21 |     "dist",
22 |     "**/*.d.ts",
23 |     "node_modules"
24 |   ],
25 |   "overrides": [
26 |     {
27 |       "files": ["src/adapters/inbound/ui/webview/**/*.ts"],
28 |       "env": {
29 |         "browser": true
30 |       }
31 |     }
32 |   ]
33 | }
34 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/ICommentRepository.ts:
--------------------------------------------------------------------------------
 1 | import { Comment } from '../../../domain/entities/Comment';
 2 | 
 3 | export interface ICommentRepository {
 4 |     save(comment: Comment): Promise<void>;
 5 |     findAll(): Promise<Comment[]>;
 6 |     findActive(): Promise<Comment[]>;
 7 |     findByThreadId(threadId: string): Promise<Comment[]>;
 8 |     findActiveByThreadId(threadId: string): Promise<Comment[]>;
 9 |     markAsSubmitted(ids: string[]): Promise<void>;
10 |     update(id: string, text: string): Promise<Comment | null>;
11 |     delete(id: string): Promise<boolean>;
12 |     /**
13 |      * Delete all comments associated with a thread.
14 |      * Used during thread cleanup.
15 |      *
16 |      * @param threadId - Thread ID to delete comments for
17 |      * @returns Number of comments deleted
18 |      */
19 |     deleteByThreadId(threadId: string): Promise<number>;
20 | }
21 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "compilerOptions": {
 3 |         "module": "Node16",
 4 |         "target": "ES2022",
 5 |         "lib": [
 6 |             "ES2022"
 7 |         ],
 8 |         "sourceMap": true,
 9 |         "rootDir": "src",
10 |         "outDir": "out",
11 |         "strict": true,
12 |         "moduleResolution": "Node16",
13 |         "esModuleInterop": true,
14 |         "skipLibCheck": true,
15 |         "forceConsistentCasingInFileNames": true
16 |     },
17 |     "exclude": [
18 |         "node_modules",
19 |         ".vscode-test",
20 |         "src/adapters/inbound/ui/webview/webview-entry.ts",
21 |         "src/adapters/inbound/ui/webview/webview-app.ts",
22 |         "src/adapters/inbound/ui/webview/state",
23 |         "src/adapters/inbound/ui/webview/utils",
24 |         "src/adapters/inbound/ui/webview/components",
25 |         "src/adapters/inbound/ui/webview/core"
26 |     ]
27 | }


--------------------------------------------------------------------------------
/.github/workflows/publish.yml:
--------------------------------------------------------------------------------
 1 | name: Publish Extension
 2 | 
 3 | on:
 4 |   push:
 5 |     tags:
 6 |       - 'v*'
 7 | 
 8 | jobs:
 9 |   publish:
10 |     runs-on: ubuntu-latest
11 |     environment: publish
12 |     steps:
13 |       - uses: actions/checkout@v4
14 | 
15 |       - name: Setup Node.js
16 |         uses: actions/setup-node@v4
17 |         with:
18 |           node-version: '20'
19 | 
20 |       - name: Install dependencies
21 |         run: npm install
22 | 
23 |       - name: Compile
24 |         run: npm run compile
25 | 
26 |       - name: Install vsce
27 |         run: npm install -g @vscode/vsce
28 | 
29 |       - name: Publish to VS Code Marketplace
30 |         run: vsce publish -p ${{ secrets.VSCE_PAT }}
31 | 
32 |       - name: Install ovsx
33 |         run: npm install -g ovsx
34 | 
35 |       - name: Publish to Open VSX (Cursor)
36 |         run: ovsx publish -p ${{ secrets.OVSX_PAT }}
37 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/webview-app.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Webview Application
 3 |  *
 4 |  * Main application logic for the webview UI. This file is bundled by esbuild
 5 |  * along with webview-entry.ts and exposes the UI components to the window object.
 6 |  */
 7 | 
 8 | import { initialize, stateManager } from './core';
 9 | 
10 | // ===== Type Declarations =====
11 | 
12 | declare global {
13 |   interface Window {
14 |     CodeSquadApp: {
15 |       initialize: () => void;
16 |       stateManager: typeof stateManager;
17 |     };
18 |   }
19 | }
20 | 
21 | // ===== Expose on Window =====
22 | 
23 | window.CodeSquadApp = {
24 |   initialize,
25 |   stateManager,
26 | };
27 | 
28 | // Auto-initialize when DOM is ready
29 | if (document.readyState === 'loading') {
30 |   document.addEventListener('DOMContentLoaded', initialize);
31 | } else {
32 |   // DOM already loaded, initialize now
33 |   initialize();
34 | }
35 | 


--------------------------------------------------------------------------------
/src/application/useCases/AddCommentUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { Comment } from '../../domain/entities/Comment';
 2 | import { ICommentRepository } from '../ports/outbound/ICommentRepository';
 3 | import { IAddCommentUseCase, AddCommentInput } from '../ports/inbound/IAddCommentUseCase';
 4 | 
 5 | export class AddCommentUseCase implements IAddCommentUseCase {
 6 |     constructor(
 7 |         private readonly commentRepository: ICommentRepository
 8 |     ) {}
 9 | 
10 |     async execute(input: AddCommentInput): Promise<Comment> {
11 |         const comment = Comment.create({
12 |             file: input.file,
13 |             line: input.line,
14 |             endLine: input.endLine,
15 |             text: input.text,
16 |             codeContext: input.codeContext,
17 |             threadId: input.threadId,
18 |         });
19 | 
20 |         await this.commentRepository.save(comment);
21 | 
22 |         return comment;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/application/useCases/index.ts:
--------------------------------------------------------------------------------
 1 | export { AddCommentUseCase } from './AddCommentUseCase';
 2 | export { SubmitCommentsUseCase } from './SubmitCommentsUseCase';
 3 | export { GenerateDiffUseCase } from './GenerateDiffUseCase';
 4 | export { GenerateScopedDiffUseCase } from './GenerateScopedDiffUseCase';
 5 | export { CaptureSnapshotsUseCase } from './CaptureSnapshotsUseCase';
 6 | export { EditCommentUseCase } from './EditCommentUseCase';
 7 | export { DeleteCommentUseCase } from './DeleteCommentUseCase';
 8 | export { FetchHNStoriesUseCase } from './FetchHNStoriesUseCase';
 9 | export { TrackFileOwnershipUseCase } from './TrackFileOwnershipUseCase';
10 | export { DetectThreadStatusUseCase } from './DetectThreadStatusUseCase';
11 | 
12 | // Re-export from ports for backward compatibility
13 | export { AddCommentInput } from '../ports/inbound/IAddCommentUseCase';
14 | export { IFileGlobber } from '../ports/outbound/IFileGlobber';
15 | export { FetchHNStoriesResult } from '../ports/inbound/IFetchHNStoriesUseCase';
16 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/sidebar/index.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Sidebar Components
 3 |  */
 4 | 
 5 | export { renderAIStatus } from './AIStatus';
 6 | export type { AIStatusData } from './AIStatus';
 7 | 
 8 | export { setupFileSearchHandlers } from './FileSearch';
 9 | export type { FileSearchHandlers } from './FileSearch';
10 | 
11 | export {
12 |   expandSidebar,
13 |   collapseSidebar,
14 |   setupSidebarToggle,
15 |   setupResizer,
16 |   getSidebarElements,
17 | } from './Sidebar';
18 | export type { SidebarState, SidebarElements } from './Sidebar';
19 | 
20 | export {
21 |   renderComments,
22 |   startEditComment,
23 |   cancelEditComment,
24 |   saveEditComment,
25 |   deleteComment,
26 |   navigateToComment,
27 |   toggleSubmittedHistory,
28 |   registerCommentHandlers,
29 | } from './Comments';
30 | export type { Comment, CommentHandlers } from './Comments';
31 | 
32 | export { renderFileList, buildFileTree } from './FileList';
33 | export type {
34 |   FileItem,
35 |   DiffData,
36 |   TreeNode,
37 |   FileListProps,
38 |   FileListHandlers,
39 | } from './FileList';
40 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/utils/dom.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * DOM Utility Functions
 3 |  *
 4 |  * Helper functions for DOM manipulation and HTML escaping.
 5 |  */
 6 | 
 7 | /**
 8 |  * Escape HTML special characters to prevent XSS
 9 |  */
10 | export function escapeHtml(text: string): string {
11 |   const div = document.createElement('div');
12 |   div.textContent = text;
13 |   return div.innerHTML;
14 | }
15 | 
16 | /**
17 |  * Get element by ID with type safety
18 |  */
19 | export function getElementById<T extends HTMLElement = HTMLElement>(
20 |   id: string
21 | ): T | null {
22 |   return document.getElementById(id) as T | null;
23 | }
24 | 
25 | /**
26 |  * Query selector with type safety
27 |  */
28 | export function querySelector<T extends Element = Element>(
29 |   selector: string
30 | ): T | null {
31 |   return document.querySelector(selector) as T | null;
32 | }
33 | 
34 | /**
35 |  * Query selector all with type safety
36 |  */
37 | export function querySelectorAll<T extends Element = Element>(
38 |   selector: string
39 | ): NodeListOf<T> {
40 |   return document.querySelectorAll(selector) as NodeListOf<T>;
41 | }
42 | 


--------------------------------------------------------------------------------
/src/domain/entities/ScopedDiff.ts:
--------------------------------------------------------------------------------
 1 | import { DiffLine } from './Diff';
 2 | import { Scope } from './Scope';
 3 | 
 4 | /**
 5 |  * Represents a line in scoped view (can be from file or diff)
 6 |  */
 7 | export interface ScopeLine {
 8 |     lineNumber: number;
 9 |     content: string;
10 |     type: 'context' | 'addition' | 'deletion';
11 |     /** Original diff line if this is a changed line */
12 |     diffLine?: DiffLine;
13 | }
14 | 
15 | /**
16 |  * Represents a chunk of lines grouped by scope
17 |  * Contains all lines within the scope, not just diff lines
18 |  */
19 | export interface ScopedChunk {
20 |     scope: Scope;
21 |     /** All lines in this scope (from file content + diff changes) */
22 |     lines: ScopeLine[];
23 |     hasChanges: boolean;
24 |     stats: { additions: number; deletions: number };
25 |     children: ScopedChunk[];
26 | }
27 | 
28 | /**
29 |  * Result of mapping diff to scopes
30 |  */
31 | export interface ScopedDiffResult {
32 |     file: string;
33 |     root: ScopedChunk[];
34 |     orphanLines: ScopeLine[];
35 |     stats: { additions: number; deletions: number };
36 |     hasScopeData: boolean;
37 | }
38 | 


--------------------------------------------------------------------------------
/src/domain/entities/FileThreadMapping.ts:
--------------------------------------------------------------------------------
 1 | export interface FileThreadMappingData {
 2 |     filePath: string;
 3 |     threadId: string;
 4 |     lastModifiedAt: number;
 5 | }
 6 | 
 7 | export class FileThreadMapping {
 8 |     readonly filePath: string;
 9 |     readonly threadId: string;
10 |     readonly lastModifiedAt: number;
11 | 
12 |     constructor(data: FileThreadMappingData) {
13 |         this.filePath = data.filePath;
14 |         this.threadId = data.threadId;
15 |         this.lastModifiedAt = data.lastModifiedAt;
16 |     }
17 | 
18 |     static create(filePath: string, threadId: string): FileThreadMapping {
19 |         return new FileThreadMapping({
20 |             filePath,
21 |             threadId,
22 |             lastModifiedAt: Date.now(),
23 |         });
24 |     }
25 | 
26 |     static fromData(data: FileThreadMappingData): FileThreadMapping {
27 |         return new FileThreadMapping(data);
28 |     }
29 | 
30 |     toData(): FileThreadMappingData {
31 |         return {
32 |             filePath: this.filePath,
33 |             threadId: this.threadId,
34 |             lastModifiedAt: this.lastModifiedAt,
35 |         };
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2025 Jake Park <jake@thirdcommit.com>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/utils/collections.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Collection Utilities
 3 |  *
 4 |  * Size-limited Set and Map implementations to prevent memory leaks.
 5 |  */
 6 | 
 7 | /**
 8 |  * Create a size-limited Set that automatically removes oldest entries
 9 |  */
10 | export class SizeLimitedSet<T> extends Set<T> {
11 |   constructor(private maxSize: number) {
12 |     super();
13 |   }
14 | 
15 |   add(value: T): this {
16 |     if (this.size >= this.maxSize) {
17 |       const first = this.values().next().value;
18 |       if (first !== undefined) {
19 |         this.delete(first);
20 |       }
21 |     }
22 |     return super.add(value);
23 |   }
24 | }
25 | 
26 | /**
27 |  * Create a size-limited Map that automatically removes oldest entries
28 |  */
29 | export class SizeLimitedMap<K, V> extends Map<K, V> {
30 |   constructor(private maxSize: number) {
31 |     super();
32 |   }
33 | 
34 |   set(key: K, value: V): this {
35 |     if (this.size >= this.maxSize) {
36 |       const firstKey = this.keys().next().value;
37 |       if (firstKey !== undefined) {
38 |         this.delete(firstKey);
39 |       }
40 |     }
41 |     return super.set(key, value);
42 |   }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/infrastructure/repositories/InMemoryFileThreadMappingRepository.ts:
--------------------------------------------------------------------------------
 1 | import { FileThreadMapping } from '../../domain/entities/FileThreadMapping';
 2 | import { IFileThreadMappingRepository } from '../../application/ports/outbound/IFileThreadMappingRepository';
 3 | 
 4 | export class InMemoryFileThreadMappingRepository implements IFileThreadMappingRepository {
 5 |     private mappings = new Map<string, FileThreadMapping>();
 6 | 
 7 |     async save(mapping: FileThreadMapping): Promise<void> {
 8 |         this.mappings.set(mapping.filePath, mapping);
 9 |     }
10 | 
11 |     async findByFilePath(filePath: string): Promise<FileThreadMapping | null> {
12 |         return this.mappings.get(filePath) ?? null;
13 |     }
14 | 
15 |     async findByThreadId(threadId: string): Promise<FileThreadMapping[]> {
16 |         const results: FileThreadMapping[] = [];
17 |         for (const mapping of this.mappings.values()) {
18 |             if (mapping.threadId === threadId) {
19 |                 results.push(mapping);
20 |             }
21 |         }
22 |         return results;
23 |     }
24 | 
25 |     async findAll(): Promise<FileThreadMapping[]> {
26 |         return Array.from(this.mappings.values());
27 |     }
28 | 
29 |     async delete(filePath: string): Promise<boolean> {
30 |         return this.mappings.delete(filePath);
31 |     }
32 | 
33 |     async clear(): Promise<void> {
34 |         this.mappings.clear();
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/utils/scroll.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Scroll Position Utilities
 3 |  *
 4 |  * Functions for managing and restoring scroll positions.
 5 |  */
 6 | 
 7 | /**
 8 |  * Get the scrollable element (differs between diff table and preview mode)
 9 |  */
10 | export function getScrollableElement(): HTMLElement | null {
11 |   const preview = document.querySelector('.markdown-preview');
12 |   if (preview) return preview as HTMLElement;
13 |   return document.getElementById('diff-viewer');
14 | }
15 | 
16 | /**
17 |  * Save current scroll position to pending restore
18 |  * Returns the current scroll position
19 |  */
20 | export function saveCurrentScrollPosition(): number {
21 |   const scrollEl = getScrollableElement();
22 |   return scrollEl ? scrollEl.scrollTop : 0;
23 | }
24 | 
25 | /**
26 |  * Restore scroll position to an element
27 |  */
28 | export function restoreScrollPosition(scrollTop: number, retries = 3): void {
29 |   if (scrollTop <= 0) return;
30 | 
31 |   const restoreScroll = () => {
32 |     const scrollEl = getScrollableElement();
33 |     if (scrollEl) scrollEl.scrollTop = scrollTop;
34 |   };
35 | 
36 |   // Try multiple times as DOM may not be ready
37 |   restoreScroll();
38 |   if (retries > 0) {
39 |     setTimeout(restoreScroll, 0);
40 |   }
41 |   if (retries > 1) {
42 |     setTimeout(restoreScroll, 50);
43 |   }
44 |   if (retries > 2) {
45 |     setTimeout(restoreScroll, 100);
46 |   }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/index.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Component barrel export
 3 |  */
 4 | 
 5 | export { renderHNFeed, setupHNFeedHandlers } from './waiting/HNFeed';
 6 | export type { HNStory, HNFeedStatus } from './waiting/HNFeed';
 7 | 
 8 | export { renderWaitingScreen, showWaitingScreen } from './waiting/WaitingScreen';
 9 | 
10 | export {
11 |   renderAIStatus,
12 |   setupFileSearchHandlers,
13 |   expandSidebar,
14 |   collapseSidebar,
15 |   setupSidebarToggle,
16 |   setupResizer,
17 |   getSidebarElements,
18 | } from './sidebar';
19 | export type {
20 |   AIStatusData,
21 |   FileSearchHandlers,
22 |   SidebarState,
23 |   SidebarElements,
24 | } from './sidebar';
25 | 
26 | export { renderContentView, renderContentViewHeader } from './content';
27 | export type { ContentViewProps } from './content';
28 | 
29 | export {
30 |   performDiffSearch,
31 |   highlightDiffMatches,
32 |   clearDiffHighlights,
33 |   updateCurrentMatch,
34 |   navigateDiffSearch,
35 |   updateNavButtons,
36 |   updateMatchCounter,
37 |   setupDiffSearchHandlers,
38 |   getDiffSearchElements,
39 | } from './diff';
40 | export type {
41 |   SearchMatch,
42 |   DiffSearchState,
43 |   DiffSearchElements,
44 | } from './diff';
45 | 
46 | export {
47 |   createPreviewSelectionState,
48 |   clearPreviewSelection,
49 |   setupPreviewCommentHandlers,
50 | } from './markdown';
51 | export type {
52 |   PreviewSelectionState,
53 |   PreviewCommentHandlers,
54 | } from './markdown';
55 | 


--------------------------------------------------------------------------------
/src/application/useCases/OpenInEditorUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { IOpenInEditorUseCase, OpenInEditorInput, OpenInEditorOutput } from '../ports/inbound/IOpenInEditorUseCase';
 2 | import { IThreadStateRepository } from '../ports/outbound/IThreadStateRepository';
 3 | import { IEditorPort } from '../ports/outbound/IEditorPort';
 4 | 
 5 | export class OpenInEditorUseCase implements IOpenInEditorUseCase {
 6 |     constructor(
 7 |         private readonly threadStateRepository: IThreadStateRepository,
 8 |         private readonly editorPort: IEditorPort
 9 |     ) {}
10 | 
11 |     async execute(input: OpenInEditorInput): Promise<OpenInEditorOutput> {
12 |         // 1. Find thread state
13 |         const threadState = await this.threadStateRepository.findById(input.threadId);
14 |         if (!threadState) {
15 |             return { success: false, error: 'Thread not found' };
16 |         }
17 | 
18 |         // 2. Verify this is a worktree thread
19 |         if (!threadState.worktreePath) {
20 |             return { success: false, error: 'Thread does not have a worktree' };
21 |         }
22 | 
23 |         // 3. Open in editor
24 |         try {
25 |             await this.editorPort.openFolder(threadState.worktreePath);
26 |             return { success: true };
27 |         } catch (error) {
28 |             return {
29 |                 success: false,
30 |                 error: error instanceof Error ? error.message : 'Failed to open editor'
31 |             };
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/controllers/ClaudeCodeConfigController.ts:
--------------------------------------------------------------------------------
 1 | import * as vscode from 'vscode';
 2 | 
 3 | const CLAUDE_CODE_EXTENSION_ID = 'anthropic.claude-code';
 4 | 
 5 | export class ClaudeCodeConfigController {
 6 |     /**
 7 |      * Prompt user to enable terminal mode for Claude Code if not already enabled.
 8 |      * Shows a QuickPick with "Enable" pre-selected so user just presses Enter to accept.
 9 |      */
10 |     async promptTerminalMode(): Promise<void> {
11 |         const claudeExt = vscode.extensions.getExtension(CLAUDE_CODE_EXTENSION_ID);
12 |         if (!claudeExt) {
13 |             return;
14 |         }
15 | 
16 |         const config = vscode.workspace.getConfiguration('claudeCode');
17 |         if (config.get('useTerminal') === true) {
18 |             return;
19 |         }
20 | 
21 |         const items: vscode.QuickPickItem[] = [
22 |             {
23 |                 label: '$(check) Enable terminal mode',
24 |                 description: '(Recommended)',
25 |                 picked: true,
26 |             },
27 |             {
28 |                 label: '$(x) Skip',
29 |             },
30 |         ];
31 | 
32 |         const pick = await vscode.window.showQuickPick(items, {
33 |             title: 'Code Squad works best with Claude Code in terminal mode',
34 |             placeHolder: 'Press Enter to enable',
35 |         });
36 | 
37 |         if (pick?.label.includes('Enable')) {
38 |             await config.update('useTerminal', true, vscode.ConfigurationTarget.Global);
39 |         }
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/state/types.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Webview UI State Types
 3 |  *
 4 |  * All state managed by the webview client-side.
 5 |  * This is separate from application state sent from the extension.
 6 |  */
 7 | 
 8 | export interface SelectionState {
 9 |   selectedLineNum: number | null;
10 |   selectedLineElement: HTMLElement | null;
11 |   selectionStartLine: number | null;
12 |   selectionEndLine: number | null;
13 |   selectionStartRow: HTMLElement | null;
14 |   selectionEndRow: HTMLElement | null;
15 |   isSelecting: boolean;
16 | }
17 | 
18 | export interface UIState {
19 |   isResizing: boolean;
20 |   sidebarWidth: number;
21 |   pendingScrollRestore: number | null;
22 |   currentFile: string | null;
23 | }
24 | 
25 | export interface SearchState {
26 |   // File search
27 |   currentSearchQuery: string;
28 |   searchDebounceTimer: number | null;
29 | 
30 |   // Diff search
31 |   diffSearchQuery: string;
32 |   diffSearchMatches: any[];
33 |   diffSearchCurrentIndex: number;
34 | }
35 | 
36 | export interface ViewState {
37 |   // Tree view
38 |   collapsedFolders: Set<string>;
39 | 
40 |   // Scoped diff
41 |   scopedDiffCurrentFile: string | null;
42 |   scopedDiffHighlightMap: Map<number, string>;
43 | 
44 |   // Preview comment
45 |   previewCurrentFile: string | null;
46 |   previewDragStartBlock: HTMLElement | null;
47 |   previewDragEndBlock: HTMLElement | null;
48 |   previewIsDragging: boolean;
49 | }
50 | 
51 | export interface WebviewState {
52 |   selection: SelectionState;
53 |   ui: UIState;
54 |   search: SearchState;
55 |   view: ViewState;
56 | }
57 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/sidebar/FileSearch.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * File Search Component
 3 |  *
 4 |  * Search input for filtering files in the sidebar.
 5 |  */
 6 | 
 7 | export interface FileSearchHandlers {
 8 |   onSearchQueryChange: (query: string) => void;
 9 | }
10 | 
11 | /**
12 |  * Setup file search input handlers
13 |  * @param handlers - Event handlers for search events
14 |  * @param signal - AbortSignal for cleanup
15 |  * @param debounceMs - Debounce delay in milliseconds (default 200)
16 |  */
17 | export function setupFileSearchHandlers(
18 |   handlers: FileSearchHandlers,
19 |   signal: AbortSignal,
20 |   debounceMs = 200
21 | ): void {
22 |   const searchInput = document.getElementById(
23 |     'file-search'
24 |   ) as HTMLInputElement | null;
25 |   const searchClear = document.getElementById('search-clear');
26 | 
27 |   if (!searchInput || !searchClear) return;
28 | 
29 |   let debounceTimer: ReturnType<typeof setTimeout> | null = null;
30 | 
31 |   searchInput.addEventListener(
32 |     'input',
33 |     (e) => {
34 |       const query = (e.target as HTMLInputElement).value;
35 |       searchClear.style.display = query ? 'flex' : 'none';
36 | 
37 |       if (debounceTimer) {
38 |         clearTimeout(debounceTimer);
39 |       }
40 |       debounceTimer = setTimeout(() => {
41 |         handlers.onSearchQueryChange(query);
42 |       }, debounceMs);
43 |     },
44 |     { signal }
45 |   );
46 | 
47 |   searchClear.addEventListener(
48 |     'click',
49 |     () => {
50 |       searchInput.value = '';
51 |       searchClear.style.display = 'none';
52 |       handlers.onSearchQueryChange('');
53 |     },
54 |     { signal }
55 |   );
56 | }
57 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/ITerminalPort.ts:
--------------------------------------------------------------------------------
 1 | export type TerminalActivityCallback = (terminalId: string, hasActivity: boolean) => void;
 2 | export type TerminalOutputCallback = (terminalId: string, data: string) => void;
 3 | export type TerminalCommandCallback = (terminalId: string, command: string) => void;
 4 | 
 5 | export interface ITerminalPort {
 6 |     initialize(): void;
 7 |     sendText(terminalId: string, text: string): void;
 8 |     showTerminal(terminalId: string): void;
 9 |     createTerminal(name: string, cwd?: string, openInPanel?: boolean): Promise<string>;
10 |     /**
11 |      * Register a callback to receive terminal activity notifications.
12 |      * Called with hasActivity=true when terminal is writing output (AI running).
13 |      * Called with hasActivity=false after a period of inactivity (AI idle).
14 |      */
15 |     onTerminalActivity(callback: TerminalActivityCallback): void;
16 |     /**
17 |      * Register a callback to receive terminal output data.
18 |      * Called with raw output data from terminal shell execution.
19 |      * Requires shell integration enabled in the terminal.
20 |      */
21 |     onTerminalOutput(callback: TerminalOutputCallback): void;
22 |     /**
23 |      * Register a callback to receive command execution notifications.
24 |      * Called when a shell command is executed in the terminal.
25 |      */
26 |     onCommandExecuted(callback: TerminalCommandCallback): void;
27 |     /**
28 |      * Register a callback to receive command completion notifications.
29 |      * Called when a shell command finishes execution.
30 |      * Useful for detecting when AI CLI exits (claude, gemini, codex).
31 |      */
32 |     onCommandEnded(callback: TerminalCommandCallback): void;
33 |     /**
34 |      * Close a terminal by ID.
35 |      * Disposes the terminal instance.
36 |      * No-op if terminal doesn't exist.
37 |      */
38 |     closeTerminal(terminalId: string): void;
39 | }
40 | 


--------------------------------------------------------------------------------
/src/application/useCases/ManageWhitelistUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { IThreadStateRepository } from '../ports/outbound/IThreadStateRepository';
 2 | import {
 3 |     IManageWhitelistUseCase,
 4 |     AddWhitelistPatternInput,
 5 |     RemoveWhitelistPatternInput,
 6 |     GetWhitelistPatternsInput,
 7 | } from '../ports/inbound/IManageWhitelistUseCase';
 8 | 
 9 | export class ManageWhitelistUseCase implements IManageWhitelistUseCase {
10 |     constructor(
11 |         private readonly threadStateRepository: IThreadStateRepository
12 |     ) {}
13 | 
14 |     async addPattern(input: AddWhitelistPatternInput): Promise<void> {
15 |         const { threadId, pattern } = input;
16 | 
17 |         const threadState = await this.threadStateRepository.findById(threadId);
18 |         if (!threadState) {
19 |             throw new Error(`Thread not found: ${threadId}`);
20 |         }
21 | 
22 |         threadState.addWhitelistPattern(pattern);
23 |         await this.threadStateRepository.updateWhitelist(
24 |             threadId,
25 |             threadState.whitelistPatterns
26 |         );
27 |     }
28 | 
29 |     async removePattern(input: RemoveWhitelistPatternInput): Promise<void> {
30 |         const { threadId, pattern } = input;
31 | 
32 |         const threadState = await this.threadStateRepository.findById(threadId);
33 |         if (!threadState) {
34 |             throw new Error(`Thread not found: ${threadId}`);
35 |         }
36 | 
37 |         threadState.removeWhitelistPattern(pattern);
38 |         await this.threadStateRepository.updateWhitelist(
39 |             threadId,
40 |             threadState.whitelistPatterns
41 |         );
42 |     }
43 | 
44 |     async getPatterns(input: GetWhitelistPatternsInput): Promise<string[]> {
45 |         const { threadId } = input;
46 | 
47 |         const threadState = await this.threadStateRepository.findById(threadId);
48 |         if (!threadState) {
49 |             return [];
50 |         }
51 | 
52 |         return threadState.whitelistPatterns;
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/application/useCases/GenerateScopedDiffUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { IGenerateScopedDiffUseCase } from '../ports/inbound/IGenerateScopedDiffUseCase';
 2 | import { IGenerateDiffUseCase } from '../ports/inbound/IGenerateDiffUseCase';
 3 | import { ISymbolPort, ScopeInfo } from '../ports/outbound/ISymbolPort';
 4 | import { IFileSystemPort } from '../ports/outbound/IFileSystemPort';
 5 | import { ScopeMappingService } from '../../domain/services/ScopeMappingService';
 6 | import { ScopedDiffResult } from '../../domain/entities/ScopedDiff';
 7 | 
 8 | export class GenerateScopedDiffUseCase implements IGenerateScopedDiffUseCase {
 9 |     constructor(
10 |         private readonly generateDiffUseCase: IGenerateDiffUseCase,
11 |         private readonly symbolPort: ISymbolPort,
12 |         private readonly fileSystemPort: IFileSystemPort,
13 |         private readonly scopeMappingService: ScopeMappingService
14 |     ) {}
15 | 
16 |     async execute(relativePath: string): Promise<ScopedDiffResult | null> {
17 |         const diff = await this.generateDiffUseCase.execute(relativePath);
18 |         if (!diff) {
19 |             return null;
20 |         }
21 | 
22 |         const absolutePath = this.fileSystemPort.toAbsolutePath(relativePath);
23 | 
24 |         // Read current file content for full scope display
25 |         let fileContent: string | undefined;
26 |         try {
27 |             fileContent = await this.fileSystemPort.readFile(absolutePath);
28 |         } catch (error) {
29 |             console.warn('[Code Squad] Failed to read file content:', error);
30 |         }
31 | 
32 |         // Get scope information from LSP
33 |         let scopes: ScopeInfo[] = [];
34 |         try {
35 |             scopes = await this.symbolPort.getAllFileSymbols(absolutePath);
36 |         } catch (error) {
37 |             // LSP failed, will fall back to chunk-based view
38 |             console.warn('[Code Squad] Symbol extraction failed:', error);
39 |         }
40 | 
41 |         return this.scopeMappingService.mapDiffToScopes(diff, scopes, fileContent);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/adapters/outbound/gateways/VscodeFileSystemGateway.ts:
--------------------------------------------------------------------------------
 1 | import * as vscode from 'vscode';
 2 | import * as fs from 'fs';
 3 | import * as path from 'path';
 4 | import { IFileSystemPort } from '../../../application/ports/outbound/IFileSystemPort';
 5 | 
 6 | export class VscodeFileSystemGateway implements IFileSystemPort {
 7 |     private workspaceRoot: string | undefined;
 8 | 
 9 |     constructor() {
10 |         const workspaceFolders = vscode.workspace.workspaceFolders;
11 |         if (workspaceFolders && workspaceFolders.length > 0) {
12 |             this.workspaceRoot = workspaceFolders[0].uri.fsPath;
13 |         }
14 |     }
15 | 
16 |     async readFile(absolutePath: string): Promise<string> {
17 |         return fs.promises.readFile(absolutePath, 'utf8');
18 |     }
19 | 
20 |     async fileExists(absolutePath: string): Promise<boolean> {
21 |         try {
22 |             await fs.promises.access(absolutePath);
23 |             return true;
24 |         } catch {
25 |             return false;
26 |         }
27 |     }
28 | 
29 |     async isFile(absolutePath: string): Promise<boolean> {
30 |         try {
31 |             const stat = await fs.promises.stat(absolutePath);
32 |             return stat.isFile();
33 |         } catch {
34 |             return false;
35 |         }
36 |     }
37 | 
38 |     getWorkspaceRoot(): string | undefined {
39 |         return this.workspaceRoot;
40 |     }
41 | 
42 |     toAbsolutePath(relativePath: string): string {
43 |         if (!this.workspaceRoot) return relativePath;
44 |         return path.join(this.workspaceRoot, relativePath);
45 |     }
46 | 
47 |     toRelativePath(absolutePath: string): string {
48 |         if (!this.workspaceRoot) return absolutePath;
49 |         return path.relative(this.workspaceRoot, absolutePath);
50 |     }
51 | 
52 |     async copyFile(source: string, dest: string): Promise<void> {
53 |         await fs.promises.copyFile(source, dest);
54 |     }
55 | 
56 |     async ensureDir(dirPath: string): Promise<void> {
57 |         await fs.promises.mkdir(dirPath, { recursive: true });
58 |     }
59 | 
60 |     joinPath(...segments: string[]): string {
61 |         return path.join(...segments);
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/domain/entities/AISession.ts:
--------------------------------------------------------------------------------
 1 | export type AIType = 'claude' | 'codex' | 'gemini';
 2 | 
 3 | export type AgentStatus = 'inactive' | 'idle' | 'working' | 'waiting';
 4 | 
 5 | export interface AgentMetadata {
 6 |     name: string;
 7 |     role?: string;
 8 |     status: AgentStatus;
 9 |     fileCount: number;
10 | }
11 | 
12 | export interface AISessionData {
13 |     type: AIType;
14 |     terminalId: string;
15 |     startTime: number;
16 | }
17 | 
18 | export class AISession {
19 |     private _type: AIType;
20 |     readonly terminalId: string;
21 |     readonly startTime: number;
22 |     private _agentMetadata?: AgentMetadata;
23 | 
24 |     constructor(data: AISessionData) {
25 |         this._type = data.type;
26 |         this.terminalId = data.terminalId;
27 |         this.startTime = data.startTime;
28 |     }
29 | 
30 |     get type(): AIType {
31 |         return this._type;
32 |     }
33 | 
34 |     /**
35 |      * Update the AI type for this session.
36 |      * Used when AI type is detected from command execution or output patterns.
37 |      */
38 |     updateType(newType: AIType): void {
39 |         this._type = newType;
40 |     }
41 | 
42 |     get displayName(): string {
43 |         if (this.type === 'claude') return 'Claude';
44 |         if (this.type === 'codex') return 'Codex';
45 |         return 'Gemini';
46 |     }
47 | 
48 |     get agentMetadata(): AgentMetadata | undefined {
49 |         return this._agentMetadata;
50 |     }
51 | 
52 |     setAgentMetadata(metadata: AgentMetadata): void {
53 |         this._agentMetadata = metadata;
54 |     }
55 | 
56 |     get agentName(): string {
57 |         return this._agentMetadata?.name ?? this.displayName;
58 |     }
59 | 
60 |     get agentStatus(): AgentStatus {
61 |         return this._agentMetadata?.status ?? 'inactive';
62 |     }
63 | 
64 |     static create(type: AIType, terminalId: string): AISession {
65 |         return new AISession({
66 |             type,
67 |             terminalId,
68 |             startTime: Date.now(),
69 |         });
70 |     }
71 | 
72 |     static getDisplayName(type: AIType): string {
73 |         if (type === 'claude') return 'Claude';
74 |         if (type === 'codex') return 'Codex';
75 |         return 'Gemini';
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/application/useCases/AttachToWorktreeUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { ThreadState } from '../../domain/entities/ThreadState';
 2 | import { IThreadStateRepository } from '../ports/outbound/IThreadStateRepository';
 3 | import { ITerminalPort } from '../ports/outbound/ITerminalPort';
 4 | import { IGitPort } from '../ports/outbound/IGitPort';
 5 | import {
 6 |     IAttachToWorktreeUseCase,
 7 |     AttachToWorktreeInput,
 8 |     AttachToWorktreeOutput,
 9 | } from '../ports/inbound/IAttachToWorktreeUseCase';
10 | 
11 | export class AttachToWorktreeUseCase implements IAttachToWorktreeUseCase {
12 |     constructor(
13 |         private readonly threadStateRepository: IThreadStateRepository,
14 |         private readonly terminalPort: ITerminalPort,
15 |         private readonly gitPort: IGitPort
16 |     ) {}
17 | 
18 |     async execute(input: AttachToWorktreeInput): Promise<AttachToWorktreeOutput> {
19 |         const { worktreePath, name, workspaceRoot } = input;
20 | 
21 |         // Step 1: Validate worktree
22 |         const isValid = await this.gitPort.isValidWorktree(worktreePath, workspaceRoot);
23 |         if (!isValid) {
24 |             throw new Error(`Invalid git worktree at ${worktreePath}`);
25 |         }
26 | 
27 |         // Step 2: Get branch name
28 |         let branch: string;
29 |         try {
30 |             branch = await this.gitPort.getWorktreeBranch(worktreePath);
31 |         } catch (error) {
32 |             throw new Error(`Failed to get branch name: ${error instanceof Error ? error.message : String(error)}`);
33 |         }
34 | 
35 |         // Step 3: Determine thread name (use provided name or default to branch)
36 |         const threadName = name ?? branch;
37 | 
38 |         // Step 4: Create terminal in worktree directory
39 |         const terminalId = await this.terminalPort.createTerminal(threadName, worktreePath);
40 | 
41 |         // Step 5: Create thread state
42 |         const threadState = ThreadState.create({
43 |             name: threadName,
44 |             terminalId,
45 |             workingDir: worktreePath,
46 |             branch,
47 |             worktreePath,
48 |             whitelistPatterns: [],
49 |         });
50 | 
51 |         // Step 6: Persist thread state
52 |         await this.threadStateRepository.save(threadState);
53 | 
54 |         return { threadState };
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/SessionContext.ts:
--------------------------------------------------------------------------------
 1 | import { AISession, AgentMetadata } from '../../../domain/entities/AISession';
 2 | import { ThreadState } from '../../../domain/entities/ThreadState';
 3 | import { ISnapshotRepository } from './ISnapshotRepository';
 4 | import { IPanelStateManager } from '../../services/IPanelStateManager';
 5 | import { IGenerateDiffUseCase } from '../inbound/IGenerateDiffUseCase';
 6 | import { IGenerateScopedDiffUseCase } from '../inbound/IGenerateScopedDiffUseCase';
 7 | import { IAddCommentUseCase } from '../inbound/IAddCommentUseCase';
 8 | import { IEditCommentUseCase } from '../inbound/IEditCommentUseCase';
 9 | import { IDeleteCommentUseCase } from '../inbound/IDeleteCommentUseCase';
10 | import { IFetchHNStoriesUseCase } from '../inbound/IFetchHNStoriesUseCase';
11 | import { ICaptureSnapshotsUseCase } from '../inbound/ICaptureSnapshotsUseCase';
12 | 
13 | /**
14 |  * 터미널 하나에 바인딩된 독립 세션 컨텍스트
15 |  * 패널, 상태, 스냅샷이 모두 이 세션에 격리됨
16 |  */
17 | export interface SessionContext {
18 |     /** 터미널 식별자 */
19 |     terminalId: string;
20 | 
21 |     /** AI 세션 정보 */
22 |     session: AISession;
23 | 
24 |     /** 터미널의 작업 디렉토리 (worktree 지원용) */
25 |     workspaceRoot: string;
26 | 
27 |     /** 이 세션의 스냅샷 저장소 */
28 |     snapshotRepository: ISnapshotRepository;
29 | 
30 |     /** 이 세션의 상태 관리자 */
31 |     stateManager: IPanelStateManager;
32 | 
33 |     /** 이 세션의 Diff UseCase */
34 |     generateDiffUseCase: IGenerateDiffUseCase;
35 | 
36 |     /** 이 세션의 Comment UseCase */
37 |     addCommentUseCase: IAddCommentUseCase;
38 | 
39 |     /** 이 세션의 Edit Comment UseCase */
40 |     editCommentUseCase: IEditCommentUseCase;
41 | 
42 |     /** 이 세션의 Delete Comment UseCase */
43 |     deleteCommentUseCase: IDeleteCommentUseCase;
44 | 
45 |     /** 이 세션의 Scoped Diff UseCase */
46 |     generateScopedDiffUseCase: IGenerateScopedDiffUseCase;
47 | 
48 |     /** HN Stories UseCase (공유) */
49 |     fetchHNStoriesUseCase?: IFetchHNStoriesUseCase;
50 | 
51 |     /** 이 세션의 Snapshot UseCase */
52 |     captureSnapshotsUseCase: ICaptureSnapshotsUseCase;
53 | 
54 |     /** 패널 dispose 콜백 (AIDetectionController에서 설정) */
55 |     disposePanel: () => void;
56 | 
57 |     /** 코멘트 제출 콜백 (싱글 패널 아키텍처용) */
58 |     submitComments: () => Promise<void>;
59 | 
60 |     /** 에이전트 메타데이터 (멀티 에이전트 지원용) */
61 |     agentMetadata?: AgentMetadata;
62 | 
63 |     /** 스레드 상태 (멀티 스레드 지원용) */
64 |     threadState?: ThreadState;
65 | }
66 | 


--------------------------------------------------------------------------------
/src/domain/entities/Scope.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Data interface for creating a Scope
 3 |  */
 4 | export interface ScopeData {
 5 |     name: string;
 6 |     kind: string;
 7 |     startLine: number;
 8 |     endLine: number;
 9 |     containerName?: string;
10 |     children?: ScopeData[];
11 | }
12 | 
13 | /**
14 |  * Represents a code scope (function, method, class, etc.)
15 |  * Used for scope-based diff visualization
16 |  */
17 | export class Scope {
18 |     readonly name: string;
19 |     readonly kind: string;
20 |     readonly startLine: number;
21 |     readonly endLine: number;
22 |     readonly containerName?: string;
23 |     readonly children: Scope[];
24 | 
25 |     constructor(data: ScopeData) {
26 |         this.name = data.name;
27 |         this.kind = data.kind;
28 |         this.startLine = data.startLine;
29 |         this.endLine = data.endLine;
30 |         this.containerName = data.containerName;
31 |         this.children = (data.children || []).map((c) => new Scope(c));
32 |     }
33 | 
34 |     /**
35 |      * Check if this scope contains the given line number
36 |      */
37 |     containsLine(line: number): boolean {
38 |         return line >= this.startLine && line <= this.endLine;
39 |     }
40 | 
41 |     /**
42 |      * Check if this scope overlaps with the given range
43 |      * Returns true for any overlap (partial or full)
44 |      */
45 |     containsRange(start: number, end: number): boolean {
46 |         return this.startLine <= end && this.endLine >= start;
47 |     }
48 | 
49 |     /**
50 |      * Get the full qualified name including container
51 |      */
52 |     get fullName(): string {
53 |         return this.containerName ? `${this.containerName}.${this.name}` : this.name;
54 |     }
55 | 
56 |     /**
57 |      * Get display name with appropriate suffix for methods/functions
58 |      */
59 |     get displayName(): string {
60 |         const suffix = this.kind === 'method' || this.kind === 'function' ? '()' : '';
61 |         return `${this.name}${suffix}`;
62 |     }
63 | 
64 |     /**
65 |      * Convert back to plain data object
66 |      */
67 |     toData(): ScopeData {
68 |         return {
69 |             name: this.name,
70 |             kind: this.kind,
71 |             startLine: this.startLine,
72 |             endLine: this.endLine,
73 |             containerName: this.containerName,
74 |             children: this.children.map((c) => c.toData()),
75 |         };
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/application/useCases/CaptureSnapshotsUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { FileSnapshot } from '../../domain/entities/FileSnapshot';
 2 | import { ISnapshotRepository } from '../ports/outbound/ISnapshotRepository';
 3 | import { IFileSystemPort } from '../ports/outbound/IFileSystemPort';
 4 | import { IFileGlobber } from '../ports/outbound/IFileGlobber';
 5 | import { ICaptureSnapshotsUseCase } from '../ports/inbound/ICaptureSnapshotsUseCase';
 6 | 
 7 | export class CaptureSnapshotsUseCase implements ICaptureSnapshotsUseCase {
 8 |     constructor(
 9 |         private readonly snapshotRepository: ISnapshotRepository,
10 |         private readonly fileSystemPort: IFileSystemPort,
11 |         private readonly fileGlobber: IFileGlobber,
12 |         private readonly workspaceRootOverride?: string
13 |     ) {}
14 | 
15 |     async execute(includePatterns: string[]): Promise<number> {
16 |         // 세션별 workspaceRoot 우선 사용 (worktree 지원)
17 |         const workspaceRoot = this.workspaceRootOverride || this.fileSystemPort.getWorkspaceRoot();
18 |         if (!workspaceRoot) return 0;
19 | 
20 |         this.snapshotRepository.clear();
21 | 
22 |         if (includePatterns.length === 0) {
23 |             return 0;
24 |         }
25 | 
26 |         let count = 0;
27 |         for (const pattern of includePatterns) {
28 |             const files = await this.fileGlobber.glob(pattern, workspaceRoot);
29 |             for (const absolutePath of files) {
30 |                 const captured = await this.captureFile(absolutePath, workspaceRoot);
31 |                 if (captured) count++;
32 |             }
33 |         }
34 | 
35 |         return count;
36 |     }
37 | 
38 |     private async captureFile(absolutePath: string, workspaceRoot: string): Promise<boolean> {
39 |         try {
40 |             const exists = await this.fileSystemPort.fileExists(absolutePath);
41 |             const isFile = await this.fileSystemPort.isFile(absolutePath);
42 | 
43 |             if (exists && isFile) {
44 |                 const content = await this.fileSystemPort.readFile(absolutePath);
45 |                 const relativePath = this.fileSystemPort.toRelativePath(absolutePath);
46 |                 const snapshot = FileSnapshot.create(relativePath, content);
47 |                 await this.snapshotRepository.save(snapshot);
48 |                 return true;
49 |             }
50 |         } catch {
51 |             return false;
52 |         }
53 |         return false;
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/waiting/WaitingScreen.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Waiting Screen Component
 3 |  *
 4 |  * Displays a loading screen with HN feed when AI is active
 5 |  * but no file changes are available yet.
 6 |  */
 7 | 
 8 | import { renderHNFeed, HNStory, HNFeedStatus } from './HNFeed';
 9 | 
10 | /**
11 |  * Render the waiting screen with spinner and HN feed
12 |  */
13 | export function renderWaitingScreen(
14 |   hnStories: HNStory[],
15 |   hnFeedStatus: HNFeedStatus,
16 |   hnFeedError: string | null,
17 |   hasMore: boolean = true,
18 |   loadingMore: boolean = false
19 | ): string {
20 |   const feedHtml = renderHNFeed(hnStories, hnFeedStatus, hnFeedError, hasMore, loadingMore);
21 | 
22 |   return `
23 |     <div class="waiting-screen">
24 |       <div class="layout-guide">
25 |         <div class="layout-hint">Recommended Layout</div>
26 |         <div class="layout-diagram">
27 | ┌───────────────────────────────┐
28 | │           VS Code             │
29 | ├────────────┬──────────────────┤
30 | │            │                  │
31 | │  Terminal  │                  │
32 | │ (AI Agent) │   Code Squad     │
33 | │            │                  │
34 | │            │                  │
35 | └────────────┴──────────────────┘
36 |         </div>
37 |         <div class="layout-tip">
38 |           Tip: Run <code>Terminal: Create New Terminal in Editor Area</code> command
39 |         </div>
40 |       </div>
41 | 
42 |       <div class="waiting-feed-container">
43 |         ${feedHtml}
44 |       </div>
45 |     </div>
46 |   `;
47 | }
48 | 
49 | /**
50 |  * Update the diff viewer to show waiting screen
51 |  * This modifies the DOM directly (used by renderState)
52 |  */
53 | export function showWaitingScreen(
54 |   hnStories: HNStory[],
55 |   hnFeedStatus: HNFeedStatus,
56 |   hnFeedError: string | null,
57 |   hasMore: boolean = true,
58 |   loadingMore: boolean = false
59 | ): void {
60 |   const header = document.querySelector('.diff-header-title');
61 |   const stats = document.getElementById('diff-stats');
62 |   const viewer = document.getElementById('diff-viewer');
63 |   const diffToolbar = document.getElementById('diff-toolbar');
64 | 
65 |   if (header) header.textContent = '';
66 |   if (stats) stats.innerHTML = '';
67 |   if (diffToolbar) diffToolbar.style.display = 'none';
68 | 
69 |   if (viewer) {
70 |     viewer.innerHTML = renderWaitingScreen(hnStories, hnFeedStatus, hnFeedError, hasMore, loadingMore);
71 |   }
72 | }
73 | 


--------------------------------------------------------------------------------
/src/domain/entities/HNStory.ts:
--------------------------------------------------------------------------------
 1 | export interface HNStoryData {
 2 |   id: number;
 3 |   title: string;
 4 |   url: string | null;
 5 |   score: number;
 6 |   descendants: number;
 7 |   by: string;
 8 |   time: number;
 9 | }
10 | 
11 | export class HNStory {
12 |   readonly id: number;
13 |   readonly title: string;
14 |   readonly url: string | null;
15 |   readonly score: number;
16 |   readonly descendants: number;
17 |   readonly by: string;
18 |   readonly time: number;
19 | 
20 |   constructor(data: HNStoryData) {
21 |     this.id = data.id;
22 |     this.title = data.title;
23 |     this.url = data.url;
24 |     this.score = data.score;
25 |     this.descendants = data.descendants;
26 |     this.by = data.by;
27 |     this.time = data.time;
28 |   }
29 | 
30 |   get domain(): string | null {
31 |     if (!this.url) return null;
32 |     try {
33 |       const urlObj = new URL(this.url);
34 |       return urlObj.hostname.replace(/^www\./, '');
35 |     } catch {
36 |       return null;
37 |     }
38 |   }
39 | 
40 |   get discussionUrl(): string {
41 |     return `https://news.ycombinator.com/item?id=${this.id}`;
42 |   }
43 | 
44 |   get timeAgo(): string {
45 |     const seconds = Math.floor(Date.now() / 1000) - this.time;
46 |     if (seconds < 60) return 'just now';
47 |     const minutes = Math.floor(seconds / 60);
48 |     if (minutes < 60) return `${minutes}m ago`;
49 |     const hours = Math.floor(minutes / 60);
50 |     if (hours < 24) return `${hours}h ago`;
51 |     const days = Math.floor(hours / 24);
52 |     return `${days}d ago`;
53 |   }
54 | 
55 |   toData(): HNStoryData {
56 |     return {
57 |       id: this.id,
58 |       title: this.title,
59 |       url: this.url,
60 |       score: this.score,
61 |       descendants: this.descendants,
62 |       by: this.by,
63 |       time: this.time,
64 |     };
65 |   }
66 | 
67 |   static fromApiResponse(response: Record<string, unknown>): HNStory | null {
68 |     if (
69 |       typeof response.id !== 'number' ||
70 |       typeof response.title !== 'string' ||
71 |       typeof response.score !== 'number' ||
72 |       typeof response.by !== 'string' ||
73 |       typeof response.time !== 'number'
74 |     ) {
75 |       return null;
76 |     }
77 | 
78 |     return new HNStory({
79 |       id: response.id,
80 |       title: response.title,
81 |       url: typeof response.url === 'string' ? response.url : null,
82 |       score: response.score,
83 |       descendants: typeof response.descendants === 'number' ? response.descendants : 0,
84 |       by: response.by,
85 |       time: response.time,
86 |     });
87 |   }
88 | }
89 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/diff/index.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Diff Components
  3 |  */
  4 | 
  5 | export {
  6 |   performDiffSearch,
  7 |   highlightDiffMatches,
  8 |   clearDiffHighlights,
  9 |   updateCurrentMatch,
 10 |   navigateDiffSearch,
 11 |   updateNavButtons,
 12 |   updateMatchCounter,
 13 |   setupDiffSearchHandlers,
 14 |   getDiffSearchElements,
 15 | } from './DiffSearch';
 16 | export type {
 17 |   SearchMatch,
 18 |   DiffSearchState,
 19 |   DiffSearchElements,
 20 | } from './DiffSearch';
 21 | 
 22 | export {
 23 |   isMarkdownFile,
 24 |   renderDiffStats,
 25 |   renderViewModeToggle,
 26 |   renderFeedToggle,
 27 |   renderThreadBadge,
 28 |   renderStatsSection,
 29 |   updateDiffHeader,
 30 |   renderPlaceholder,
 31 | } from './DiffHeader';
 32 | export type { DiffStats, ViewMode, DiffHeaderProps } from './DiffHeader';
 33 | 
 34 | export {
 35 |   createSelectionState,
 36 |   isSelectableLine,
 37 |   clearLineSelection,
 38 |   updateLineSelection,
 39 |   handleLineMouseDown,
 40 |   handleLineMouseMove,
 41 |   handleLineMouseUp,
 42 |   setupLineSelectionHandlers,
 43 | } from './LineSelection';
 44 | export type {
 45 |   SelectionState,
 46 |   SelectionRange,
 47 |   LineSelectionHandlers,
 48 | } from './LineSelection';
 49 | 
 50 | export {
 51 |   showInlineCommentForm,
 52 |   saveDraftComment,
 53 |   restoreDraftCommentForm,
 54 |   cancelCommentForm,
 55 |   submitInlineComment,
 56 |   toggleInlineComment,
 57 |   startInlineEdit,
 58 |   cancelInlineEdit,
 59 |   saveInlineEdit,
 60 |   registerInlineCommentHandlers,
 61 | } from './InlineComments';
 62 | export type { CommentDraft, InlineCommentHandlers } from './InlineComments';
 63 | 
 64 | export { renderChunksToHtml, setupChunkToggleHandlers } from './ChunkRenderer';
 65 | export type {
 66 |   DiffLine,
 67 |   ChunkStats,
 68 |   DiffChunk,
 69 |   ChunkState,
 70 |   InlineComment,
 71 | } from './ChunkRenderer';
 72 | 
 73 | export {
 74 |   SCOPE_ICONS,
 75 |   collectScopeLines,
 76 |   renderScopeDiffLines,
 77 |   renderScopeNode,
 78 |   renderScopedDiffContent,
 79 |   setupScopeHandlers,
 80 |   scrollToLineInScopedDiff,
 81 | } from './ScopedDiff';
 82 | export type {
 83 |   ScopeDiffLine,
 84 |   ScopeStats,
 85 |   ScopeNode,
 86 |   ScopedDiffData,
 87 | } from './ScopedDiff';
 88 | 
 89 | export {
 90 |   getDiffViewerElements,
 91 |   updateDiffViewerHeader,
 92 |   renderEmptyState,
 93 |   getNextViewMode,
 94 |   registerViewModeToggle,
 95 |   registerFeedToggle,
 96 |   renderDiffTableWrapper,
 97 | } from './DiffViewer';
 98 | export type {
 99 |   DiffData,
100 |   DiffViewerProps,
101 |   DiffViewerElements,
102 | } from './DiffViewer';
103 | 


--------------------------------------------------------------------------------
/src/types/git.ts:
--------------------------------------------------------------------------------
  1 | import * as vscode from 'vscode';
  2 | 
  3 | /**
  4 |  * VSCode Git Extension API types
  5 |  * Based on: https://github.com/microsoft/vscode/blob/main/extensions/git/src/api/api1.ts
  6 |  */
  7 | 
  8 | export interface GitExtension {
  9 |   readonly enabled: boolean;
 10 |   getAPI(version: 1): GitAPI;
 11 | }
 12 | 
 13 | export interface GitAPI {
 14 |   readonly repositories: Repository[];
 15 |   readonly onDidOpenRepository: vscode.Event<Repository>;
 16 |   readonly onDidCloseRepository: vscode.Event<Repository>;
 17 | }
 18 | 
 19 | export interface Repository {
 20 |   readonly rootUri: vscode.Uri;
 21 |   readonly state: RepositoryState;
 22 |   readonly inputBox: InputBox;
 23 | }
 24 | 
 25 | export interface InputBox {
 26 |   value: string;
 27 | }
 28 | 
 29 | export interface RepositoryState {
 30 |   readonly HEAD: Branch | undefined;
 31 |   readonly refs: Ref[];
 32 |   readonly remotes: Remote[];
 33 |   readonly submodules: Submodule[];
 34 |   readonly rebaseCommit: Commit | undefined;
 35 |   readonly mergeChanges: Change[];
 36 |   readonly indexChanges: Change[];
 37 |   readonly workingTreeChanges: Change[];
 38 |   readonly onDidChange: vscode.Event<void>;
 39 | }
 40 | 
 41 | export interface Branch {
 42 |   readonly name: string | undefined;
 43 |   readonly commit: string | undefined;
 44 |   readonly upstream?: { name: string; remote: string };
 45 | }
 46 | 
 47 | export interface Ref {
 48 |   readonly type: RefType;
 49 |   readonly name?: string;
 50 |   readonly commit?: string;
 51 |   readonly remote?: string;
 52 | }
 53 | 
 54 | export enum RefType {
 55 |   Head,
 56 |   RemoteHead,
 57 |   Tag
 58 | }
 59 | 
 60 | export interface Remote {
 61 |   readonly name: string;
 62 |   readonly fetchUrl?: string;
 63 |   readonly pushUrl?: string;
 64 |   readonly isReadOnly: boolean;
 65 | }
 66 | 
 67 | export interface Submodule {
 68 |   readonly name: string;
 69 |   readonly path: string;
 70 |   readonly url: string;
 71 | }
 72 | 
 73 | export interface Commit {
 74 |   readonly hash: string;
 75 |   readonly message: string;
 76 | }
 77 | 
 78 | export interface Change {
 79 |   readonly uri: vscode.Uri;
 80 |   readonly originalUri: vscode.Uri;
 81 |   readonly renameUri: vscode.Uri | undefined;
 82 |   readonly status: Status;
 83 | }
 84 | 
 85 | export enum Status {
 86 |   INDEX_MODIFIED,
 87 |   INDEX_ADDED,
 88 |   INDEX_DELETED,
 89 |   INDEX_RENAMED,
 90 |   INDEX_COPIED,
 91 |   MODIFIED,
 92 |   DELETED,
 93 |   UNTRACKED,
 94 |   IGNORED,
 95 |   INTENT_TO_ADD,
 96 |   ADDED_BY_US,
 97 |   ADDED_BY_THEM,
 98 |   DELETED_BY_US,
 99 |   DELETED_BY_THEM,
100 |   BOTH_ADDED,
101 |   BOTH_DELETED,
102 |   BOTH_MODIFIED
103 | }
104 | 


--------------------------------------------------------------------------------
/src/infrastructure/repositories/InMemorySnapshotRepository.ts:
--------------------------------------------------------------------------------
 1 | import { FileSnapshot } from '../../domain/entities/FileSnapshot';
 2 | import { ISnapshotRepository, SnapshotStats } from '../../application/ports/outbound/ISnapshotRepository';
 3 | 
 4 | const MAX_SNAPSHOT_COUNT = 100;
 5 | const MAX_SNAPSHOT_SIZE = 100 * 1024; // 100KB
 6 | 
 7 | export class InMemorySnapshotRepository implements ISnapshotRepository {
 8 |     private snapshots = new Map<string, FileSnapshot>();
 9 |     private accessOrder: string[] = []; // LRU tracking
10 | 
11 |     private updateAccessOrder(path: string): void {
12 |         const index = this.accessOrder.indexOf(path);
13 |         if (index !== -1) {
14 |             this.accessOrder.splice(index, 1);
15 |         }
16 |         this.accessOrder.push(path);
17 |     }
18 | 
19 |     private evictOldest(): void {
20 |         if (this.accessOrder.length > 0) {
21 |             const oldest = this.accessOrder.shift()!;
22 |             this.snapshots.delete(oldest);
23 |         }
24 |     }
25 | 
26 |     async save(snapshot: FileSnapshot): Promise<boolean> {
27 |         // Check size limit
28 |         const contentSize = Buffer.byteLength(snapshot.content, 'utf8');
29 |         if (contentSize > MAX_SNAPSHOT_SIZE) {
30 |             console.warn(
31 |                 `[Snapshot] Skipping ${snapshot.relativePath}: size ${contentSize} exceeds limit ${MAX_SNAPSHOT_SIZE}`
32 |             );
33 |             return false;
34 |         }
35 | 
36 |         // Evict if at capacity (and not updating existing)
37 |         if (!this.snapshots.has(snapshot.relativePath) && this.snapshots.size >= MAX_SNAPSHOT_COUNT) {
38 |             this.evictOldest();
39 |         }
40 | 
41 |         this.snapshots.set(snapshot.relativePath, snapshot);
42 |         this.updateAccessOrder(snapshot.relativePath);
43 |         return true;
44 |     }
45 | 
46 |     async findByPath(relativePath: string): Promise<FileSnapshot | undefined> {
47 |         const snapshot = this.snapshots.get(relativePath);
48 |         if (snapshot) {
49 |             this.updateAccessOrder(relativePath);
50 |         }
51 |         return snapshot;
52 |     }
53 | 
54 |     has(relativePath: string): boolean {
55 |         return this.snapshots.has(relativePath);
56 |     }
57 | 
58 |     clear(): void {
59 |         this.snapshots.clear();
60 |         this.accessOrder = [];
61 |     }
62 | 
63 |     getAll(): Map<string, FileSnapshot> {
64 |         return new Map(this.snapshots);
65 |     }
66 | 
67 |     getStats(): SnapshotStats {
68 |         let totalSize = 0;
69 |         for (const snapshot of this.snapshots.values()) {
70 |             totalSize += Buffer.byteLength(snapshot.content, 'utf8');
71 |         }
72 |         return {
73 |             count: this.snapshots.size,
74 |             totalSize,
75 |         };
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/domain/entities/ThreadState.ts:
--------------------------------------------------------------------------------
 1 | export interface ThreadStateData {
 2 |     threadId: string;
 3 |     name: string;
 4 |     terminalId: string;
 5 |     workingDir: string;
 6 |     branch?: string;
 7 |     worktreePath?: string;
 8 |     whitelistPatterns: string[];
 9 |     createdAt: number;
10 | }
11 | 
12 | export class ThreadState {
13 |     readonly threadId: string;
14 |     readonly name: string;
15 |     readonly terminalId: string;
16 |     readonly workingDir: string;
17 |     readonly branch?: string;
18 |     readonly worktreePath?: string;
19 |     private _whitelistPatterns: string[];
20 |     readonly createdAt: number;
21 | 
22 |     private constructor(data: ThreadStateData) {
23 |         this.threadId = data.threadId;
24 |         this.name = data.name;
25 |         this.terminalId = data.terminalId;
26 |         this.workingDir = data.workingDir;
27 |         this.branch = data.branch;
28 |         this.worktreePath = data.worktreePath;
29 |         this._whitelistPatterns = [...data.whitelistPatterns];
30 |         this.createdAt = data.createdAt;
31 |     }
32 | 
33 |     static create(data: Omit<ThreadStateData, 'threadId' | 'createdAt'>): ThreadState {
34 |         return new ThreadState({
35 |             ...data,
36 |             threadId: generateUUID(),
37 |             createdAt: Date.now(),
38 |         });
39 |     }
40 | 
41 |     static fromData(data: ThreadStateData): ThreadState {
42 |         return new ThreadState(data);
43 |     }
44 | 
45 |     get whitelistPatterns(): string[] {
46 |         return [...this._whitelistPatterns];
47 |     }
48 | 
49 |     addWhitelistPattern(pattern: string): void {
50 |         if (!this._whitelistPatterns.includes(pattern)) {
51 |             this._whitelistPatterns.push(pattern);
52 |         }
53 |     }
54 | 
55 |     removeWhitelistPattern(pattern: string): void {
56 |         const index = this._whitelistPatterns.indexOf(pattern);
57 |         if (index !== -1) {
58 |             this._whitelistPatterns.splice(index, 1);
59 |         }
60 |     }
61 | 
62 |     hasWhitelistPattern(pattern: string): boolean {
63 |         return this._whitelistPatterns.includes(pattern);
64 |     }
65 | 
66 |     toData(): ThreadStateData {
67 |         return {
68 |             threadId: this.threadId,
69 |             name: this.name,
70 |             terminalId: this.terminalId,
71 |             workingDir: this.workingDir,
72 |             branch: this.branch,
73 |             worktreePath: this.worktreePath,
74 |             whitelistPatterns: [...this._whitelistPatterns],
75 |             createdAt: this.createdAt,
76 |         };
77 |     }
78 | }
79 | 
80 | function generateUUID(): string {
81 |     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
82 |         const r = (Math.random() * 16) | 0;
83 |         const v = c === 'x' ? r : (r & 0x3) | 0x8;
84 |         return v.toString(16);
85 |     });
86 | }
87 | 


--------------------------------------------------------------------------------
/src/adapters/outbound/gateways/HNApiGateway.ts:
--------------------------------------------------------------------------------
 1 | import * as https from 'https';
 2 | import { HNStory } from '../../../domain/entities/HNStory';
 3 | import { IHNApiPort } from '../../../application/ports/outbound/IHNApiPort';
 4 | 
 5 | const HN_API_BASE = 'https://hacker-news.firebaseio.com/v0';
 6 | const REQUEST_TIMEOUT = 10000;
 7 | const MAX_RESPONSE_SIZE = 1024 * 1024; // 1MB
 8 | 
 9 | export class HNApiGateway implements IHNApiPort {
10 |   private async fetchJson<T>(url: string): Promise<T> {
11 |     return new Promise((resolve, reject) => {
12 |       const request = https.get(url, { timeout: REQUEST_TIMEOUT }, (response) => {
13 |         if (response.statusCode !== 200) {
14 |           reject(new Error(`HTTP ${response.statusCode}`));
15 |           return;
16 |         }
17 | 
18 |         // Use Buffer array instead of string concatenation for memory efficiency
19 |         const chunks: Buffer[] = [];
20 |         let totalSize = 0;
21 | 
22 |         response.on('data', (chunk: Buffer) => {
23 |           totalSize += chunk.length;
24 |           if (totalSize > MAX_RESPONSE_SIZE) {
25 |             request.destroy();
26 |             chunks.length = 0; // Clear chunks to free memory
27 |             reject(new Error(`Response exceeds ${MAX_RESPONSE_SIZE} bytes limit`));
28 |             return;
29 |           }
30 |           chunks.push(chunk);
31 |         });
32 | 
33 |         response.on('end', () => {
34 |           try {
35 |             const data = Buffer.concat(chunks).toString('utf8');
36 |             chunks.length = 0; // Clear chunks after use
37 |             resolve(JSON.parse(data));
38 |           } catch (error) {
39 |             reject(new Error('Invalid JSON response'));
40 |           }
41 |         });
42 | 
43 |         response.on('error', (error) => {
44 |           chunks.length = 0; // Clear chunks on error
45 |           reject(error);
46 |         });
47 |       });
48 | 
49 |       request.on('error', reject);
50 |       request.on('timeout', () => {
51 |         request.destroy();
52 |         reject(new Error('Request timeout'));
53 |       });
54 |     });
55 |   }
56 | 
57 |   async fetchTopStoryIds(): Promise<number[]> {
58 |     const ids = await this.fetchJson<number[]>(`${HN_API_BASE}/topstories.json`);
59 |     return ids || [];
60 |   }
61 | 
62 |   async fetchStory(id: number): Promise<HNStory | null> {
63 |     try {
64 |       const response = await this.fetchJson<Record<string, unknown>>(
65 |         `${HN_API_BASE}/item/${id}.json`
66 |       );
67 |       if (!response) return null;
68 |       return HNStory.fromApiResponse(response);
69 |     } catch {
70 |       return null;
71 |     }
72 |   }
73 | 
74 |   async fetchStories(ids: number[]): Promise<HNStory[]> {
75 |     const promises = ids.map(id => this.fetchStory(id));
76 |     const results = await Promise.all(promises);
77 |     return results.filter((story): story is HNStory => story !== null);
78 |   }
79 | }
80 | 


--------------------------------------------------------------------------------
/src/domain/entities/Comment.ts:
--------------------------------------------------------------------------------
 1 | export interface CommentData {
 2 |     id: string;
 3 |     file: string;
 4 |     line: number;
 5 |     endLine?: number;
 6 |     text: string;
 7 |     codeContext: string;
 8 |     isSubmitted: boolean;
 9 |     timestamp: number;
10 |     threadId?: string;
11 | }
12 | 
13 | export class Comment {
14 |     readonly id: string;
15 |     readonly file: string;
16 |     readonly line: number;
17 |     readonly endLine?: number;
18 |     readonly text: string;
19 |     readonly codeContext: string;
20 |     private _isSubmitted: boolean;
21 |     readonly timestamp: number;
22 |     readonly threadId?: string;
23 | 
24 |     constructor(data: CommentData) {
25 |         this.id = data.id;
26 |         this.file = data.file;
27 |         this.line = data.line;
28 |         this.endLine = data.endLine;
29 |         this.text = data.text;
30 |         this.codeContext = data.codeContext;
31 |         this._isSubmitted = data.isSubmitted;
32 |         this.timestamp = data.timestamp;
33 |         this.threadId = data.threadId;
34 |     }
35 | 
36 |     get isSubmitted(): boolean {
37 |         return this._isSubmitted;
38 |     }
39 | 
40 |     markAsSubmitted(): void {
41 |         this._isSubmitted = true;
42 |     }
43 | 
44 |     withText(newText: string): Comment {
45 |         return new Comment({
46 |             id: this.id,
47 |             file: this.file,
48 |             line: this.line,
49 |             endLine: this.endLine,
50 |             text: newText,
51 |             codeContext: this.codeContext,
52 |             isSubmitted: this._isSubmitted,
53 |             timestamp: this.timestamp,
54 |             threadId: this.threadId,
55 |         });
56 |     }
57 | 
58 |     get lineRange(): string {
59 |         return this.endLine ? `${this.line}-${this.endLine}` : `${this.line}`;
60 |     }
61 | 
62 |     toData(): CommentData {
63 |         return {
64 |             id: this.id,
65 |             file: this.file,
66 |             line: this.line,
67 |             endLine: this.endLine,
68 |             text: this.text,
69 |             codeContext: this.codeContext,
70 |             isSubmitted: this._isSubmitted,
71 |             timestamp: this.timestamp,
72 |             threadId: this.threadId,
73 |         };
74 |     }
75 | 
76 |     static create(params: {
77 |         file: string;
78 |         line: number;
79 |         endLine?: number;
80 |         text: string;
81 |         codeContext: string;
82 |         threadId?: string;
83 |     }): Comment {
84 |         return new Comment({
85 |             id: Date.now().toString(),
86 |             file: params.file,
87 |             line: params.line,
88 |             endLine: params.endLine,
89 |             text: params.text,
90 |             codeContext: params.codeContext,
91 |             isSubmitted: false,
92 |             timestamp: Date.now(),
93 |             threadId: params.threadId,
94 |         });
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/sidebar/AIStatus.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * AI Status Component
  3 |  *
  4 |  * Displays the current AI assistant status (Claude, Codex, Gemini, or Ready).
  5 |  * Also handles agent header display for multi-agent mode.
  6 |  */
  7 | 
  8 | export interface AIStatusData {
  9 |   active: boolean;
 10 |   type?: 'claude' | 'codex' | 'gemini' | string;
 11 | }
 12 | 
 13 | export type AgentStatus = 'working' | 'idle' | 'waiting' | 'error';
 14 | 
 15 | export interface AgentDisplayInfo {
 16 |   name: string;
 17 |   status: AgentStatus;
 18 | }
 19 | 
 20 | /**
 21 |  * Render AI status badge
 22 |  * Updates the DOM directly
 23 |  */
 24 | export function renderAIStatus(aiStatus: AIStatusData): void {
 25 |   const badge = document.getElementById('status-badge');
 26 |   const typeEl = document.getElementById('ai-type');
 27 | 
 28 |   if (!badge || !typeEl) return;
 29 | 
 30 |   if (aiStatus.active && aiStatus.type) {
 31 |     const label =
 32 |       aiStatus.type === 'claude'
 33 |         ? 'Claude'
 34 |         : aiStatus.type === 'codex'
 35 |           ? 'Codex'
 36 |           : aiStatus.type === 'gemini'
 37 |             ? 'Gemini'
 38 |             : aiStatus.type;
 39 |     typeEl.textContent = label;
 40 |     badge.classList.add('active');
 41 |   } else {
 42 |     typeEl.textContent = 'Ready';
 43 |     badge.classList.remove('active');
 44 |   }
 45 | }
 46 | 
 47 | /**
 48 |  * Get status icon for agent status
 49 |  */
 50 | function getStatusIcon(status: AgentStatus): string {
 51 |   switch (status) {
 52 |     case 'working':
 53 |       return '●';
 54 |     case 'waiting':
 55 |       return '●';
 56 |     case 'error':
 57 |       return '●';
 58 |     case 'idle':
 59 |     default:
 60 |       return '○';
 61 |   }
 62 | }
 63 | 
 64 | /**
 65 |  * Escape HTML to prevent XSS
 66 |  */
 67 | function escapeHtml(text: string): string {
 68 |   const div = document.createElement('div');
 69 |   div.textContent = text;
 70 |   return div.innerHTML;
 71 | }
 72 | 
 73 | /**
 74 |  * Render agent header for multi-agent mode
 75 |  * Updates the header title element
 76 |  */
 77 | export function renderAgentHeader(
 78 |   agentInfo: AgentDisplayInfo | undefined,
 79 |   isAggregatedView: boolean | undefined
 80 | ): void {
 81 |   const headerTitle = document.getElementById('header-title');
 82 |   if (!headerTitle) return;
 83 | 
 84 |   if (isAggregatedView) {
 85 |     headerTitle.innerHTML = `
 86 |       <div class="agent-header agent-header--aggregated">
 87 |         <span class="agent-icon">◫</span>
 88 |         <span class="agent-name">All Agents</span>
 89 |       </div>
 90 |     `;
 91 |   } else if (agentInfo) {
 92 |     const statusClass = `agent-status--${agentInfo.status}`;
 93 |     const statusIcon = getStatusIcon(agentInfo.status);
 94 |     headerTitle.innerHTML = `
 95 |       <div class="agent-header">
 96 |         <span class="agent-status ${statusClass}">${statusIcon}</span>
 97 |         <span class="agent-name">${escapeHtml(agentInfo.name)}</span>
 98 |       </div>
 99 |     `;
100 |   } else {
101 |     headerTitle.textContent = 'Code Squad';
102 |   }
103 | }
104 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/html.ts:
--------------------------------------------------------------------------------
 1 | export const webviewHtml = `
 2 | <body class="sidebar-collapsed">
 3 |   <div class="sidebar collapsed">
 4 |     <div class="header">
 5 |       <h2 id="header-title">Code Squad</h2>
 6 |       <div class="status" id="status-badge">
 7 |         <span id="ai-status-dot">●</span>
 8 |         <span id="ai-type">Ready</span>
 9 |       </div>
10 |     </div>
11 | 
12 |     <div class="section">
13 |       <div class="section-header">
14 |         <h3>Changed Files</h3>
15 |         <div class="toggle-row" id="toggle-row" style="display: none;">
16 |           <span class="toggle-label">+<span id="uncommitted-count">0</span> prior changes</span>
17 |           <div class="toggle-checkbox" id="uncommitted-toggle"></div>
18 |         </div>
19 |       </div>
20 |       <div class="files-toolbar">
21 |         <button class="toggle-btn" id="view-mode-toggle">List</button>
22 |         <div class="search-container">
23 |           <input type="text"
24 |                  id="file-search"
25 |                  class="search-input"
26 |                  placeholder="Search files..."
27 |                  autocomplete="off">
28 |           <button class="search-clear" id="search-clear" style="display: none;">×</button>
29 |         </div>
30 |       </div>
31 |       <div id="search-results" class="search-results" style="display: none;"></div>
32 |       <div id="files-list">
33 |               </div>
34 |     </div>
35 | 
36 |     <div class="section">
37 |       <h3>Comments</h3>
38 |       <div id="comments-list">
39 |         <div class="empty-text">No comments yet</div>
40 |       </div>
41 |       <button id="submit-comments" style="margin-top: 12px;">Ask AI</button>
42 |     </div>
43 |   </div>
44 | 
45 |   <div class="resizer" id="panel-resizer"></div>
46 | 
47 |   <div class="main-content">
48 |     <div class="diff-header" id="viewer-header">
49 |       <span class="diff-header-icon">📄</span>
50 |       <span class="diff-header-title">Select a file to review</span>
51 |       <div class="diff-stats" id="diff-stats"></div>
52 |       <button class="sidebar-toggle" id="toggle-sidebar" aria-label="Expand file list panel">&lt;</button>
53 |     </div>
54 | 
55 |     <div class="diff-toolbar" id="diff-toolbar" style="display: none;">
56 |       <button class="toggle-btn" id="diff-collapse-all">Collapse</button>
57 |       <div class="diff-search-wrapper">
58 |         <input type="text"
59 |                id="diff-search-input"
60 |                class="diff-search-input"
61 |                placeholder="Find in diff..."
62 |                autocomplete="off">
63 |         <span class="diff-search-count" id="diff-search-count"></span>
64 |         <button class="diff-search-nav" id="diff-search-prev" title="Previous (Shift+Enter)">↑</button>
65 |         <button class="diff-search-nav" id="diff-search-next" title="Next (Enter)">↓</button>
66 |       </div>
67 |     </div>
68 | 
69 |     <div class="diff-container" id="diff-viewer">
70 |       <div class="placeholder">
71 |         <div class="placeholder-icon">📝</div>
72 |         <div class="placeholder-text">Select a modified file to view changes</div>
73 |       </div>
74 |     </div>
75 |   </div>
76 | `;
77 | 


--------------------------------------------------------------------------------
/SIDECAR_README.md:
--------------------------------------------------------------------------------
  1 | <div align="center">
  2 | 
  3 | <img alt="Sidecar" src="assets/sidecar-full.png" width="400">
  4 | 
  5 | <br />
  6 | 
  7 | **Building with AI, the right way.**
  8 | 
  9 | 
 10 | [![Open VSX Downloads](https://img.shields.io/open-vsx/dt/JakePark/Sidecar?label=Downloads&color=teal)](https://open-vsx.org/extension/JakePark/Sidecar)
 11 | [![GitHub Stars](https://img.shields.io/github/stars/team-attention/sidecar?style=flat&color=yellow)](https://github.com/team-attention/sidecar)
 12 | [![License](https://img.shields.io/github/license/team-attention/sidecar)](LICENSE)
 13 | 
 14 | <br />
 15 | 
 16 | https://github.com/user-attachments/assets/51aa09b2-072a-47f7-b8be-f49e05493ca6
 17 | 
 18 | </div>
 19 | 
 20 | <br />
 21 | 
 22 | ## Why Sidecar?
 23 | 
 24 | Vibe coding is amazing... until you review the changes.
 25 | 
 26 | AI writes fast. Too fast. Files pile up, changes scatter everywhere, and suddenly you're juggling tabs, hunting diffs, fixing things by hand. The conversation breaks. The momentum dies.
 27 | 
 28 | **Sidecar keeps the conversation going.**
 29 | 
 30 | One seamless flow — talk to AI, review what it built, give feedback, keep building. All in one place, without breaking the rhythm.
 31 | 
 32 | ---
 33 | 
 34 | ## Features
 35 | 
 36 | **👁️ Unified View**
 37 | All AI outputs — code, docs, configs — organized in a single panel. No more hunting through files.
 38 | 
 39 | **💬 Inline Comments**
 40 | Select lines, leave feedback, send to AI. Talk to AI in context, not in a separate terminal.
 41 | 
 42 | **🧩 Structured Diffs**
 43 | Changes grouped by function, class, or module. See the intent, not just the diff.
 44 | 
 45 | ---
 46 | 
 47 | ## Quick Start
 48 | 
 49 | ```
 50 | 1. Install from VS Marketplace
 51 | 2. Start Claude Code, Codex, or Gemini CLI
 52 | 3. Sidecar opens automatically
 53 | ```
 54 | 
 55 | ---
 56 | 
 57 | ## Supported AI Tools
 58 | 
 59 | <table>
 60 |   <tr>
 61 |     <td align="center"><a href="https://github.com/anthropics/claude-code"><strong>Claude Code</strong></a><br/>Anthropic</td>
 62 |     <td align="center"><a href="https://github.com/openai/codex"><strong>Codex CLI</strong></a><br/>OpenAI</td>
 63 |     <td align="center"><a href="https://github.com/google-gemini/gemini-cli"><strong>Gemini CLI</strong></a><br/>Google</td>
 64 |   </tr>
 65 | </table>
 66 | 
 67 | ---
 68 | 
 69 | ## Settings
 70 | 
 71 | | Setting | Default | Description |
 72 | |---------|---------|-------------|
 73 | | `sidecar.autoDetect` | `true` | Auto-detect AI tools in terminal |
 74 | | `sidecar.autoShowPanel` | `true` | Open panel when AI tool detected |
 75 | | `sidecar.includeFiles` | `[]` | Glob patterns for gitignored files |
 76 | 
 77 | <details>
 78 | <summary><strong>Tracking gitignored files</strong></summary>
 79 | 
 80 | ```json
 81 | {
 82 |   "sidecar.includeFiles": ["dist/**", ".env.local"]
 83 | }
 84 | ```
 85 | 
 86 | </details>
 87 | 
 88 | ---
 89 | 
 90 | ## Requirements
 91 | 
 92 | VS Code 1.93.0+
 93 | 
 94 | ---
 95 | 
 96 | ## Links
 97 | 
 98 | [GitHub](https://github.com/team-attention/sidecar) · [Issues](https://github.com/team-attention/sidecar/issues) · [Changelog](https://github.com/team-attention/sidecar/releases)
 99 | 
100 | ---
101 | 
102 | <div align="center">
103 | 
104 | **MIT License**
105 | 
106 | </div>
107 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/content/ContentView.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Content View Component
 3 |  *
 4 |  * Renders external content (HN articles, URLs) in an iframe within the main panel area.
 5 |  * Includes header with navigation buttons and loading/error states.
 6 |  */
 7 | 
 8 | export interface ContentViewProps {
 9 |     url: string;
10 |     title: string;
11 | }
12 | 
13 | /**
14 |  * Escape HTML special characters to prevent XSS
15 |  */
16 | function escapeHtml(text: string): string {
17 |     const escapeMap: Record<string, string> = {
18 |         '&': '&amp;',
19 |         '<': '&lt;',
20 |         '>': '&gt;',
21 |         '"': '&quot;',
22 |         "'": '&#39;',
23 |     };
24 |     return text.replace(/[&<>"']/g, (c) => escapeMap[c] || c);
25 | }
26 | 
27 | /**
28 |  * Renders content view with iframe, loading state, and error handling
29 |  */
30 | export function renderContentView(props: ContentViewProps): string {
31 |     const { url } = props;
32 | 
33 |     return `
34 |         <div class="content-view">
35 |             <div class="content-view-loading" id="content-loading">
36 |                 <div class="loading-spinner"></div>
37 |                 <span>Loading content...</span>
38 |             </div>
39 |             <iframe
40 |                 class="content-view-iframe"
41 |                 id="content-iframe"
42 |                 src="${escapeHtml(url)}"
43 |                 sandbox="allow-scripts allow-same-origin allow-forms allow-popups"
44 |             ></iframe>
45 |             <div class="content-view-error hidden" id="content-error">
46 |                 <div class="error-icon">⚠️</div>
47 |                 <div class="error-text">Failed to load content</div>
48 |                 <div class="error-actions">
49 |                     <button class="error-btn" id="content-retry-btn">Retry</button>
50 |                     <button class="error-btn" id="content-external-error-btn">Open in Browser</button>
51 |                 </div>
52 |             </div>
53 |         </div>
54 |     `;
55 | }
56 | 
57 | /**
58 |  * Returns header HTML for content view
59 |  */
60 | export function renderContentViewHeader(props: {
61 |     title: string;
62 |     isSidebarCollapsed: boolean;
63 | }): string {
64 |     const { title, isSidebarCollapsed } = props;
65 |     const truncatedTitle =
66 |         title.length > 40 ? title.substring(0, 40) + '...' : title;
67 | 
68 |     const toggleLabel = isSidebarCollapsed
69 |         ? 'Expand file list panel'
70 |         : 'Collapse file list panel';
71 |     const toggleText = isSidebarCollapsed ? '<' : '>';
72 | 
73 |     return `
74 |         <span class="diff-header-icon">🌐</span>
75 |         <span class="diff-header-title content-title" title="${escapeHtml(title)}">${escapeHtml(truncatedTitle)}</span>
76 |         <div class="content-view-actions">
77 |             <button class="content-action-btn" id="content-back-btn" title="Back to previous view">
78 |                 ← Back
79 |             </button>
80 |             <button class="content-action-btn" id="content-external-btn" title="Open in browser">
81 |                 ↗ Open in Browser
82 |             </button>
83 |         </div>
84 |         <button class="sidebar-toggle" id="toggle-sidebar" aria-label="${toggleLabel}">${toggleText}</button>
85 |     `;
86 | }
87 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/IGitPort.ts:
--------------------------------------------------------------------------------
 1 | export type FileStatus = 'added' | 'modified' | 'deleted';
 2 | 
 3 | export interface WorktreeInfo {
 4 |     path: string;        // Absolute path to worktree directory
 5 |     branch: string;      // Branch name (e.g., "feature-x", "main")
 6 |     head: string;        // Commit SHA
 7 | }
 8 | 
 9 | export interface IGitPort {
10 |     getDiff(workspaceRoot: string, relativePath: string): Promise<string>;
11 |     isGitRepository(workspaceRoot: string): Promise<boolean>;
12 |     getUncommittedFiles(workspaceRoot: string): Promise<string[]>;
13 |     getFileStatus(workspaceRoot: string, relativePath: string): Promise<FileStatus>;
14 |     getUncommittedFilesWithStatus(workspaceRoot: string): Promise<Array<{ path: string; status: FileStatus }>>;
15 |     getCurrentBranch(workspaceRoot: string): Promise<string>;
16 |     createWorktree(path: string, branch: string, workspaceRoot: string): Promise<void>;
17 |     getWorktreeRoot(workspaceRoot: string): Promise<string | null>;
18 | 
19 |     /**
20 |      * List all git worktrees in the repository.
21 |      * Executes `git worktree list --porcelain` and parses output.
22 |      * Excludes the main repository root (only returns linked worktrees).
23 |      *
24 |      * @param workspaceRoot - Root directory of the main repository
25 |      * @returns Array of worktree information
26 |      */
27 |     listWorktrees(workspaceRoot: string): Promise<WorktreeInfo[]>;
28 | 
29 |     /**
30 |      * Validate if a path is a valid git worktree.
31 |      * Checks:
32 |      * 1. Path exists and is accessible
33 |      * 2. Path is a valid git repository
34 |      * 3. Path is listed in `git worktree list` from main repo
35 |      *
36 |      * @param path - Path to validate
37 |      * @param workspaceRoot - Root directory of the main repository
38 |      * @returns True if path is a valid worktree
39 |      */
40 |     isValidWorktree(path: string, workspaceRoot: string): Promise<boolean>;
41 | 
42 |     /**
43 |      * Get the branch name for a worktree.
44 |      * Executes `git rev-parse --abbrev-ref HEAD` in the worktree directory.
45 |      *
46 |      * @param worktreePath - Absolute path to worktree
47 |      * @returns Branch name (e.g., "feature-x") or "HEAD" for detached state
48 |      */
49 |     getWorktreeBranch(worktreePath: string): Promise<string>;
50 | 
51 |     /**
52 |      * Remove a git worktree.
53 |      * Executes `git worktree remove <path>`.
54 |      *
55 |      * @param worktreePath - Absolute path to worktree to remove
56 |      * @param workspaceRoot - Root directory of main repository
57 |      * @param force - Force removal even with uncommitted changes
58 |      * @throws Error if worktree has uncommitted changes and force=false
59 |      */
60 |     removeWorktree(worktreePath: string, workspaceRoot: string, force?: boolean): Promise<void>;
61 | 
62 |     /**
63 |      * Delete a git branch.
64 |      * Executes `git branch -D <branchName>`.
65 |      *
66 |      * @param branchName - Name of branch to delete
67 |      * @param workspaceRoot - Root directory of repository
68 |      * @param force - Force deletion (use -D instead of -d)
69 |      * @throws Error if branch doesn't exist or is currently checked out
70 |      */
71 |     deleteBranch(branchName: string, workspaceRoot: string, force?: boolean): Promise<void>;
72 | }
73 | 


--------------------------------------------------------------------------------
/src/application/useCases/DeleteThreadUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { IDeleteThreadUseCase, DeleteThreadInput, DeleteThreadOutput } from '../ports/inbound/IDeleteThreadUseCase';
 2 | import { IThreadStateRepository } from '../ports/outbound/IThreadStateRepository';
 3 | import { ITerminalPort } from '../ports/outbound/ITerminalPort';
 4 | import { IGitPort } from '../ports/outbound/IGitPort';
 5 | import { ICommentRepository } from '../ports/outbound/ICommentRepository';
 6 | import { IDetectThreadStatusUseCase } from '../ports/inbound/IDetectThreadStatusUseCase';
 7 | 
 8 | export class DeleteThreadUseCase implements IDeleteThreadUseCase {
 9 |     constructor(
10 |         private readonly threadStateRepository: IThreadStateRepository,
11 |         private readonly terminalPort: ITerminalPort,
12 |         private readonly gitPort: IGitPort,
13 |         private readonly commentRepository: ICommentRepository,
14 |         private readonly detectStatusUseCase: IDetectThreadStatusUseCase
15 |     ) {}
16 | 
17 |     async execute(input: DeleteThreadInput): Promise<DeleteThreadOutput> {
18 |         const { threadId, workspaceRoot, closeTerminal = true, removeWorktree = true } = input;
19 | 
20 |         // 1. Find thread state
21 |         const threadState = await this.threadStateRepository.findById(threadId);
22 |         if (!threadState) {
23 |             return {
24 |                 success: false,
25 |                 deletedThreadId: threadId,
26 |                 deletedCommentsCount: 0,
27 |                 worktreeRemoved: false,
28 |                 terminalClosed: false
29 |             };
30 |         }
31 | 
32 |         let terminalClosed = false;
33 |         let worktreeRemoved = false;
34 |         let deletedCommentsCount = 0;
35 | 
36 |         // 2. Close terminal if requested
37 |         if (closeTerminal && threadState.terminalId) {
38 |             this.terminalPort.closeTerminal(threadState.terminalId);
39 |             terminalClosed = true;
40 |         }
41 | 
42 |         // 3. Clear status detection state
43 |         this.detectStatusUseCase.clear(threadState.terminalId);
44 | 
45 |         // 4. Delete thread-scoped comments
46 |         deletedCommentsCount = await this.commentRepository.deleteByThreadId(threadId);
47 | 
48 |         // 5. Remove worktree if applicable and requested
49 |         if (removeWorktree && threadState.worktreePath) {
50 |             try {
51 |                 await this.gitPort.removeWorktree(threadState.worktreePath, workspaceRoot, true);
52 |                 worktreeRemoved = true;
53 | 
54 |                 // 5.1. Delete branch after worktree is removed
55 |                 if (threadState.branch) {
56 |                     try {
57 |                         await this.gitPort.deleteBranch(threadState.branch, workspaceRoot, true);
58 |                     } catch (branchError) {
59 |                         // Log but don't fail - branch might be in use elsewhere
60 |                         console.error('[Code Squad] Failed to delete branch:', branchError);
61 |                     }
62 |                 }
63 |             } catch (error) {
64 |                 // Log but don't fail - worktree might already be gone
65 |                 console.error('[Code Squad] Failed to remove worktree:', error);
66 |             }
67 |         }
68 | 
69 |         // 6. Delete thread state
70 |         await this.threadStateRepository.delete(threadId);
71 | 
72 |         return {
73 |             success: true,
74 |             deletedThreadId: threadId,
75 |             deletedCommentsCount,
76 |             worktreeRemoved,
77 |             terminalClosed
78 |         };
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/src/infrastructure/repositories/JsonThreadStateRepository.ts:
--------------------------------------------------------------------------------
 1 | import * as fs from 'fs';
 2 | import * as path from 'path';
 3 | import { ThreadState, ThreadStateData } from '../../domain/entities/ThreadState';
 4 | import { IThreadStateRepository } from '../../application/ports/outbound/IThreadStateRepository';
 5 | 
 6 | export class JsonThreadStateRepository implements IThreadStateRepository {
 7 |     private threads: ThreadState[] = [];
 8 |     private storagePath: string | undefined;
 9 | 
10 |     constructor(workspaceRoot: string | undefined) {
11 |         if (workspaceRoot) {
12 |             const vscodeDir = path.join(workspaceRoot, '.vscode');
13 |             if (!fs.existsSync(vscodeDir)) {
14 |                 fs.mkdirSync(vscodeDir);
15 |             }
16 |             this.storagePath = path.join(vscodeDir, 'code-squad-threads.json');
17 |             this.loadThreads();
18 |         }
19 |     }
20 | 
21 |     async save(state: ThreadState): Promise<void> {
22 |         const existingIndex = this.threads.findIndex(t => t.threadId === state.threadId);
23 |         if (existingIndex !== -1) {
24 |             this.threads[existingIndex] = state;
25 |         } else {
26 |             this.threads.push(state);
27 |         }
28 |         this.persistThreads();
29 |     }
30 | 
31 |     async findAll(): Promise<ThreadState[]> {
32 |         return [...this.threads];
33 |     }
34 | 
35 |     async findById(threadId: string): Promise<ThreadState | null> {
36 |         return this.threads.find(t => t.threadId === threadId) ?? null;
37 |     }
38 | 
39 |     async findByTerminalId(terminalId: string): Promise<ThreadState | null> {
40 |         return this.threads.find(t => t.terminalId === terminalId) ?? null;
41 |     }
42 | 
43 |     async delete(threadId: string): Promise<boolean> {
44 |         const index = this.threads.findIndex(t => t.threadId === threadId);
45 |         if (index === -1) {
46 |             return false;
47 |         }
48 | 
49 |         this.threads.splice(index, 1);
50 |         this.persistThreads();
51 |         return true;
52 |     }
53 | 
54 |     async updateWhitelist(threadId: string, patterns: string[]): Promise<void> {
55 |         const thread = this.threads.find(t => t.threadId === threadId);
56 |         if (!thread) {
57 |             return;
58 |         }
59 | 
60 |         // Clear existing patterns and add new ones
61 |         const currentPatterns = thread.whitelistPatterns;
62 |         for (const pattern of currentPatterns) {
63 |             thread.removeWhitelistPattern(pattern);
64 |         }
65 |         for (const pattern of patterns) {
66 |             thread.addWhitelistPattern(pattern);
67 |         }
68 | 
69 |         this.persistThreads();
70 |     }
71 | 
72 |     private loadThreads(): void {
73 |         if (!this.storagePath || !fs.existsSync(this.storagePath)) {
74 |             return;
75 |         }
76 | 
77 |         try {
78 |             const data = fs.readFileSync(this.storagePath, 'utf8');
79 |             const parsed: ThreadStateData[] = JSON.parse(data);
80 |             this.threads = parsed.map(d => ThreadState.fromData(d));
81 |         } catch (e) {
82 |             console.error('[Code Squad] Failed to load threads', e);
83 |         }
84 |     }
85 | 
86 |     private persistThreads(): void {
87 |         if (this.storagePath) {
88 |             try {
89 |                 const data = this.threads.map(t => t.toData());
90 |                 fs.writeFileSync(this.storagePath, JSON.stringify(data, null, 2));
91 |             } catch (e) {
92 |                 console.error('[Code Squad] Failed to save threads', e);
93 |             }
94 |         }
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/test/application/useCases/TrackFileOwnershipUseCase.test.ts:
--------------------------------------------------------------------------------
 1 | import * as assert from 'assert';
 2 | import { TrackFileOwnershipUseCase } from '../../../application/useCases/TrackFileOwnershipUseCase';
 3 | import { IFileThreadMappingRepository } from '../../../application/ports/outbound/IFileThreadMappingRepository';
 4 | import { FileThreadMapping } from '../../../domain/entities/FileThreadMapping';
 5 | 
 6 | class MockFileThreadMappingRepository implements IFileThreadMappingRepository {
 7 |     public savedMappings: FileThreadMapping[] = [];
 8 | 
 9 |     async save(mapping: FileThreadMapping): Promise<void> {
10 |         this.savedMappings.push(mapping);
11 |     }
12 | 
13 |     async findByFilePath(_filePath: string): Promise<FileThreadMapping | null> {
14 |         return null;
15 |     }
16 | 
17 |     async findByThreadId(_threadId: string): Promise<FileThreadMapping[]> {
18 |         return [];
19 |     }
20 | 
21 |     async findAll(): Promise<FileThreadMapping[]> {
22 |         return [];
23 |     }
24 | 
25 |     async delete(_filePath: string): Promise<boolean> {
26 |         return false;
27 |     }
28 | 
29 |     async clear(): Promise<void> {
30 |         this.savedMappings = [];
31 |     }
32 | }
33 | 
34 | suite('TrackFileOwnershipUseCase', () => {
35 |     let useCase: TrackFileOwnershipUseCase;
36 |     let mockRepository: MockFileThreadMappingRepository;
37 | 
38 |     setup(() => {
39 |         mockRepository = new MockFileThreadMappingRepository();
40 |         useCase = new TrackFileOwnershipUseCase(mockRepository);
41 |     });
42 | 
43 |     suite('TS1: Happy Path', () => {
44 |         test('should save file-thread mapping', async () => {
45 |             // Arrange
46 |             const input = { filePath: 'src/app.ts', threadId: 'tid-a' };
47 | 
48 |             // Act
49 |             await useCase.execute(input);
50 | 
51 |             // Assert
52 |             assert.strictEqual(mockRepository.savedMappings.length, 1);
53 |             const saved = mockRepository.savedMappings[0];
54 |             assert.strictEqual(saved.filePath, 'src/app.ts');
55 |             assert.strictEqual(saved.threadId, 'tid-a');
56 |             assert.ok(typeof saved.lastModifiedAt === 'number');
57 |         });
58 |     });
59 | 
60 |     suite('TS2: Overwrite Existing Mapping', () => {
61 |         test('should save new mapping (repository handles overwrite)', async () => {
62 |             // Arrange - use real InMemory repository behavior
63 |             const input = { filePath: 'src/app.ts', threadId: 'new-tid' };
64 | 
65 |             // Act
66 |             await useCase.execute(input);
67 | 
68 |             // Assert
69 |             assert.strictEqual(mockRepository.savedMappings.length, 1);
70 |             const saved = mockRepository.savedMappings[0];
71 |             assert.strictEqual(saved.threadId, 'new-tid');
72 |         });
73 |     });
74 | 
75 |     suite('Edge Cases', () => {
76 |         test('should skip when threadId is empty', async () => {
77 |             // Arrange
78 |             const input = { filePath: 'src/app.ts', threadId: '' };
79 | 
80 |             // Act
81 |             await useCase.execute(input);
82 | 
83 |             // Assert
84 |             assert.strictEqual(mockRepository.savedMappings.length, 0);
85 |         });
86 | 
87 |         test('should handle multiple different files', async () => {
88 |             // Arrange & Act
89 |             await useCase.execute({ filePath: 'src/a.ts', threadId: 'tid-a' });
90 |             await useCase.execute({ filePath: 'src/b.ts', threadId: 'tid-b' });
91 | 
92 |             // Assert
93 |             assert.strictEqual(mockRepository.savedMappings.length, 2);
94 |         });
95 |     });
96 | });
97 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/state/StateManager.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * StateManager
  3 |  *
  4 |  * Centralized state management for webview UI.
  5 |  * Replaces global variables from script.ts with controlled state access.
  6 |  */
  7 | 
  8 | import type {
  9 |   WebviewState,
 10 |   SelectionState,
 11 |   UIState,
 12 |   SearchState,
 13 |   ViewState,
 14 | } from './types';
 15 | 
 16 | // Size limits for collections
 17 | export const MAX_COLLAPSED_FOLDERS = 1000;
 18 | export const MAX_SEARCH_MATCHES = 500;
 19 | export const MAX_HIGHLIGHT_ENTRIES = 10000;
 20 | 
 21 | export class StateManager {
 22 |   private state: WebviewState;
 23 | 
 24 |   constructor() {
 25 |     this.state = this.getInitialState();
 26 |   }
 27 | 
 28 |   private getInitialState(): WebviewState {
 29 |     return {
 30 |       selection: {
 31 |         selectedLineNum: null,
 32 |         selectedLineElement: null,
 33 |         selectionStartLine: null,
 34 |         selectionEndLine: null,
 35 |         selectionStartRow: null,
 36 |         selectionEndRow: null,
 37 |         isSelecting: false,
 38 |       },
 39 |       ui: {
 40 |         isResizing: false,
 41 |         sidebarWidth: 320,
 42 |         pendingScrollRestore: null,
 43 |         currentFile: null,
 44 |       },
 45 |       search: {
 46 |         currentSearchQuery: '',
 47 |         searchDebounceTimer: null,
 48 |         diffSearchQuery: '',
 49 |         diffSearchMatches: [],
 50 |         diffSearchCurrentIndex: -1,
 51 |       },
 52 |       view: {
 53 |         collapsedFolders: new Set(),
 54 |         scopedDiffCurrentFile: null,
 55 |         scopedDiffHighlightMap: new Map(),
 56 |         previewCurrentFile: null,
 57 |         previewDragStartBlock: null,
 58 |         previewDragEndBlock: null,
 59 |         previewIsDragging: false,
 60 |       },
 61 |     };
 62 |   }
 63 | 
 64 |   // Getters for read access
 65 |   getSelection(): SelectionState {
 66 |     return this.state.selection;
 67 |   }
 68 | 
 69 |   getUI(): UIState {
 70 |     return this.state.ui;
 71 |   }
 72 | 
 73 |   getSearch(): SearchState {
 74 |     return this.state.search;
 75 |   }
 76 | 
 77 |   getView(): ViewState {
 78 |     return this.state.view;
 79 |   }
 80 | 
 81 |   // Setters for controlled mutations
 82 |   setSelection(partial: Partial<SelectionState>): void {
 83 |     this.state.selection = { ...this.state.selection, ...partial };
 84 |   }
 85 | 
 86 |   setUI(partial: Partial<UIState>): void {
 87 |     this.state.ui = { ...this.state.ui, ...partial };
 88 |   }
 89 | 
 90 |   setSearch(partial: Partial<SearchState>): void {
 91 |     this.state.search = { ...this.state.search, ...partial };
 92 |   }
 93 | 
 94 |   setView(partial: Partial<ViewState>): void {
 95 |     this.state.view = { ...this.state.view, ...partial };
 96 |   }
 97 | 
 98 |   // Collection helpers with size limits
 99 |   addCollapsedFolder(folderPath: string): void {
100 |     if (this.state.view.collapsedFolders.size >= MAX_COLLAPSED_FOLDERS) {
101 |       const first = this.state.view.collapsedFolders.values().next().value;
102 |       if (first) this.state.view.collapsedFolders.delete(first);
103 |     }
104 |     this.state.view.collapsedFolders.add(folderPath);
105 |   }
106 | 
107 |   removeCollapsedFolder(folderPath: string): void {
108 |     this.state.view.collapsedFolders.delete(folderPath);
109 |   }
110 | 
111 |   // Cleanup
112 |   reset(): void {
113 |     // Clear collections
114 |     this.state.view.collapsedFolders.clear();
115 |     this.state.search.diffSearchMatches = [];
116 |     this.state.view.scopedDiffHighlightMap.clear();
117 | 
118 |     // Reset to initial state
119 |     this.state = this.getInitialState();
120 |   }
121 | }
122 | 
123 | // Export singleton instance (will be used by components)
124 | export const stateManager = new StateManager();
125 | 


--------------------------------------------------------------------------------
/src/application/useCases/FetchHNStoriesUseCase.ts:
--------------------------------------------------------------------------------
  1 | import { HNStory } from '../../domain/entities/HNStory';
  2 | import { IHNApiPort } from '../ports/outbound/IHNApiPort';
  3 | import { IFetchHNStoriesUseCase, FetchHNStoriesResult } from '../ports/inbound/IFetchHNStoriesUseCase';
  4 | 
  5 | const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
  6 | const PAGE_SIZE = 20;
  7 | const MAX_STORIES = 100; // Maximum total stories to load
  8 | 
  9 | export class FetchHNStoriesUseCase implements IFetchHNStoriesUseCase {
 10 |   private cachedStories: HNStory[] = [];
 11 |   private allStoryIds: number[] = [];
 12 |   private lastFetchTime: number = 0;
 13 |   private currentOffset: number = 0;
 14 | 
 15 |   constructor(private readonly hnApiPort: IHNApiPort) {}
 16 | 
 17 |   async execute(forceRefresh: boolean = false): Promise<FetchHNStoriesResult> {
 18 |     const now = Date.now();
 19 |     const cacheAge = now - this.lastFetchTime;
 20 |     const isCacheValid = cacheAge < CACHE_TTL_MS && this.cachedStories.length > 0;
 21 | 
 22 |     if (isCacheValid && !forceRefresh) {
 23 |       return {
 24 |         stories: this.cachedStories,
 25 |         fromCache: true,
 26 |         fetchedAt: this.lastFetchTime,
 27 |         hasMore: this.currentOffset < Math.min(this.allStoryIds.length, MAX_STORIES),
 28 |       };
 29 |     }
 30 | 
 31 |     try {
 32 |       // Fetch all story IDs and cache them
 33 |       this.allStoryIds = await this.hnApiPort.fetchTopStoryIds();
 34 |       const topIds = this.allStoryIds.slice(0, PAGE_SIZE);
 35 |       const stories = await this.hnApiPort.fetchStories(topIds);
 36 | 
 37 |       stories.sort((a, b) => b.score - a.score);
 38 | 
 39 |       this.cachedStories = stories;
 40 |       this.lastFetchTime = now;
 41 |       this.currentOffset = PAGE_SIZE;
 42 | 
 43 |       return {
 44 |         stories,
 45 |         fromCache: false,
 46 |         fetchedAt: now,
 47 |         hasMore: this.currentOffset < Math.min(this.allStoryIds.length, MAX_STORIES),
 48 |       };
 49 |     } catch (error) {
 50 |       if (this.cachedStories.length > 0) {
 51 |         return {
 52 |           stories: this.cachedStories,
 53 |           fromCache: true,
 54 |           fetchedAt: this.lastFetchTime,
 55 |           hasMore: this.currentOffset < Math.min(this.allStoryIds.length, MAX_STORIES),
 56 |         };
 57 |       }
 58 |       throw error;
 59 |     }
 60 |   }
 61 | 
 62 |   async loadMore(): Promise<FetchHNStoriesResult> {
 63 |     const maxAllowed = Math.min(this.allStoryIds.length, MAX_STORIES);
 64 | 
 65 |     if (this.currentOffset >= maxAllowed) {
 66 |       return {
 67 |         stories: this.cachedStories,
 68 |         fromCache: true,
 69 |         fetchedAt: this.lastFetchTime,
 70 |         hasMore: false,
 71 |       };
 72 |     }
 73 | 
 74 |     try {
 75 |       const nextIds = this.allStoryIds.slice(this.currentOffset, this.currentOffset + PAGE_SIZE);
 76 |       const newStories = await this.hnApiPort.fetchStories(nextIds);
 77 | 
 78 |       // Append new stories (keep original order, don't re-sort all)
 79 |       this.cachedStories = [...this.cachedStories, ...newStories];
 80 |       this.currentOffset += PAGE_SIZE;
 81 | 
 82 |       return {
 83 |         stories: this.cachedStories,
 84 |         fromCache: false,
 85 |         fetchedAt: this.lastFetchTime,
 86 |         hasMore: this.currentOffset < maxAllowed,
 87 |       };
 88 |     } catch (error) {
 89 |       // On error, return current cached stories
 90 |       return {
 91 |         stories: this.cachedStories,
 92 |         fromCache: true,
 93 |         fetchedAt: this.lastFetchTime,
 94 |         hasMore: this.currentOffset < maxAllowed,
 95 |       };
 96 |     }
 97 |   }
 98 | 
 99 |   clearCache(): void {
100 |     this.cachedStories = [];
101 |     this.allStoryIds = [];
102 |     this.lastFetchTime = 0;
103 |     this.currentOffset = 0;
104 |   }
105 | }
106 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/sidebar/Sidebar.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Sidebar Component
  3 |  *
  4 |  * Toggle and resize functionality for the sidebar panel.
  5 |  */
  6 | 
  7 | export interface SidebarState {
  8 |   isCollapsed: boolean;
  9 |   width: number;
 10 | }
 11 | 
 12 | export interface SidebarElements {
 13 |   body: HTMLElement;
 14 |   sidebar: HTMLElement;
 15 |   toggleButton: HTMLElement;
 16 |   resizer: HTMLElement;
 17 | }
 18 | 
 19 | /**
 20 |  * Expand sidebar to specified width
 21 |  */
 22 | export function expandSidebar(elements: SidebarElements, width: number): void {
 23 |   const { body, sidebar, toggleButton } = elements;
 24 |   body.classList.remove('sidebar-collapsed');
 25 |   sidebar.classList.remove('collapsed');
 26 |   body.style.gridTemplateColumns = `1fr 4px ${width}px`;
 27 |   toggleButton.textContent = '>';
 28 |   toggleButton.setAttribute('aria-label', 'Collapse file list panel');
 29 | }
 30 | 
 31 | /**
 32 |  * Collapse sidebar
 33 |  */
 34 | export function collapseSidebar(elements: SidebarElements): void {
 35 |   const { body, sidebar, toggleButton } = elements;
 36 |   body.classList.add('sidebar-collapsed');
 37 |   sidebar.classList.add('collapsed');
 38 |   body.style.gridTemplateColumns = '';
 39 |   toggleButton.textContent = '<';
 40 |   toggleButton.setAttribute('aria-label', 'Expand file list panel');
 41 | }
 42 | 
 43 | /**
 44 |  * Setup sidebar toggle button handler
 45 |  */
 46 | export function setupSidebarToggle(
 47 |   elements: SidebarElements,
 48 |   getState: () => SidebarState,
 49 |   signal: AbortSignal
 50 | ): void {
 51 |   elements.toggleButton.addEventListener(
 52 |     'click',
 53 |     () => {
 54 |       const state = getState();
 55 |       if (elements.body.classList.contains('sidebar-collapsed')) {
 56 |         expandSidebar(elements, state.width);
 57 |       } else {
 58 |         collapseSidebar(elements);
 59 |       }
 60 |     },
 61 |     { signal }
 62 |   );
 63 | }
 64 | 
 65 | /**
 66 |  * Setup panel resizer drag handlers
 67 |  */
 68 | export function setupResizer(
 69 |   elements: SidebarElements,
 70 |   onWidthChange: (width: number) => void,
 71 |   signal: AbortSignal
 72 | ): void {
 73 |   const { body, resizer } = elements;
 74 |   let isResizing = false;
 75 | 
 76 |   resizer.addEventListener(
 77 |     'mousedown',
 78 |     () => {
 79 |       if (body.classList.contains('sidebar-collapsed')) return;
 80 |       isResizing = true;
 81 |       body.classList.add('resizing');
 82 |       resizer.classList.add('dragging');
 83 |       body.style.transition = 'none';
 84 |     },
 85 |     { signal }
 86 |   );
 87 | 
 88 |   document.addEventListener(
 89 |     'mousemove',
 90 |     (e) => {
 91 |       if (!isResizing) return;
 92 |       const clampedWidth = Math.max(150, Math.min(600, window.innerWidth - e.clientX));
 93 |       onWidthChange(clampedWidth);
 94 |       body.style.gridTemplateColumns = `1fr 4px ${clampedWidth}px`;
 95 |     },
 96 |     { signal }
 97 |   );
 98 | 
 99 |   document.addEventListener(
100 |     'mouseup',
101 |     () => {
102 |       if (!isResizing) return;
103 |       isResizing = false;
104 |       body.classList.remove('resizing');
105 |       resizer.classList.remove('dragging');
106 |       body.style.transition = '';
107 |     },
108 |     { signal }
109 |   );
110 | }
111 | 
112 | /**
113 |  * Get sidebar DOM elements
114 |  * Returns null if any element is missing
115 |  */
116 | export function getSidebarElements(): SidebarElements | null {
117 |   const body = document.body;
118 |   const sidebar = document.querySelector('.sidebar') as HTMLElement | null;
119 |   const toggleButton = document.getElementById('toggle-sidebar');
120 |   const resizer = document.getElementById('panel-resizer');
121 | 
122 |   if (!sidebar || !toggleButton || !resizer) return null;
123 | 
124 |   return { body, sidebar, toggleButton, resizer };
125 | }
126 | 


--------------------------------------------------------------------------------
/src/application/useCases/GenerateDiffUseCase.ts:
--------------------------------------------------------------------------------
 1 | import { DiffService } from '../../domain/services/DiffService';
 2 | import { DiffResult } from '../../domain/entities/Diff';
 3 | import { ISnapshotRepository } from '../ports/outbound/ISnapshotRepository';
 4 | import { IFileSystemPort } from '../ports/outbound/IFileSystemPort';
 5 | import { IGitPort } from '../ports/outbound/IGitPort';
 6 | import { IGenerateDiffUseCase } from '../ports/inbound/IGenerateDiffUseCase';
 7 | 
 8 | export class GenerateDiffUseCase implements IGenerateDiffUseCase {
 9 |     private workspaceRootOverride?: string;
10 | 
11 |     constructor(
12 |         private readonly snapshotRepository: ISnapshotRepository,
13 |         private readonly fileSystemPort: IFileSystemPort,
14 |         private readonly gitPort: IGitPort,
15 |         private readonly diffService: DiffService,
16 |         workspaceRootOverride?: string
17 |     ) {
18 |         this.workspaceRootOverride = workspaceRootOverride;
19 |     }
20 | 
21 |     /**
22 |      * Set workspace root for worktree support.
23 |      * Call this when switching to a different worktree.
24 |      */
25 |     setWorkspaceRoot(workspaceRoot: string | undefined): void {
26 |         this.workspaceRootOverride = workspaceRoot;
27 |     }
28 | 
29 |     /**
30 |      * Get current workspace root.
31 |      */
32 |     getWorkspaceRoot(): string | undefined {
33 |         return this.workspaceRootOverride || this.fileSystemPort.getWorkspaceRoot();
34 |     }
35 | 
36 |     async execute(relativePath: string): Promise<DiffResult | null> {
37 |         // 세션별 workspaceRoot 우선 사용 (worktree 지원)
38 |         const workspaceRoot = this.workspaceRootOverride || this.fileSystemPort.getWorkspaceRoot();
39 |         if (!workspaceRoot) return null;
40 | 
41 |         let diffResult: DiffResult;
42 | 
43 |         if (this.snapshotRepository.has(relativePath)) {
44 |             diffResult = await this.generateSnapshotDiff(relativePath);
45 |         } else {
46 |             const rawDiff = await this.gitPort.getDiff(workspaceRoot, relativePath);
47 |             diffResult = this.diffService.parseUnifiedDiff(relativePath, rawDiff);
48 |         }
49 | 
50 |         if (diffResult.chunks.length === 0) {
51 |             return null;
52 |         }
53 | 
54 |         return diffResult;
55 |     }
56 | 
57 |     private async generateSnapshotDiff(relativePath: string): Promise<DiffResult> {
58 |         const snapshot = await this.snapshotRepository.findByPath(relativePath);
59 |         // Use workspaceRootOverride for worktree support
60 |         const workspaceRoot = this.getWorkspaceRoot();
61 |         const absolutePath = workspaceRoot
62 |             ? this.fileSystemPort.joinPath(workspaceRoot, relativePath)
63 |             : relativePath;
64 | 
65 |         let currentContent = '';
66 |         let fileExists = false;
67 |         try {
68 |             fileExists = await this.fileSystemPort.fileExists(absolutePath);
69 |             if (fileExists) {
70 |                 currentContent = await this.fileSystemPort.readFile(absolutePath);
71 |             }
72 |         } catch {
73 |             return { file: relativePath, chunks: [], stats: { additions: 0, deletions: 0 } };
74 |         }
75 | 
76 |         // Case 1: No snapshot exists
77 |         if (snapshot === undefined) {
78 |             if (!currentContent) {
79 |                 return { file: relativePath, chunks: [], stats: { additions: 0, deletions: 0 } };
80 |             }
81 |             return this.diffService.generateNewFileStructuredDiff(relativePath, currentContent);
82 |         }
83 | 
84 |         // Case 2: Snapshot exists but file was deleted
85 |         if (!fileExists || !currentContent) {
86 |             return this.diffService.generateDeletedFileStructuredDiff(relativePath, snapshot.content);
87 |         }
88 | 
89 |         // Case 3: Both snapshot and current content exist - compare them
90 |         return this.diffService.generateStructuredDiff(relativePath, snapshot.content, currentContent);
91 |     }
92 | }
93 | 


--------------------------------------------------------------------------------
/src/application/useCases/CreateThreadUseCase.ts:
--------------------------------------------------------------------------------
  1 | import * as path from 'path';
  2 | import { ThreadState } from '../../domain/entities/ThreadState';
  3 | import { IThreadStateRepository } from '../ports/outbound/IThreadStateRepository';
  4 | import { ITerminalPort } from '../ports/outbound/ITerminalPort';
  5 | import { IGitPort } from '../ports/outbound/IGitPort';
  6 | import { IFileSystemPort } from '../ports/outbound/IFileSystemPort';
  7 | import { IFileGlobber } from '../ports/outbound/IFileGlobber';
  8 | import {
  9 |     ICreateThreadUseCase,
 10 |     CreateThreadInput,
 11 |     CreateThreadOutput,
 12 | } from '../ports/inbound/ICreateThreadUseCase';
 13 | 
 14 | export class CreateThreadUseCase implements ICreateThreadUseCase {
 15 |     constructor(
 16 |         private readonly threadStateRepository: IThreadStateRepository,
 17 |         private readonly terminalPort: ITerminalPort,
 18 |         private readonly gitPort: IGitPort,
 19 |         private readonly fileSystemPort: IFileSystemPort,
 20 |         private readonly fileGlobber: IFileGlobber
 21 |     ) {}
 22 | 
 23 |     async execute(input: CreateThreadInput): Promise<CreateThreadOutput> {
 24 |         const { name, isolationMode, branchName, worktreePath: customWorktreePath, workspaceRoot } = input;
 25 |         const effectiveBranchName = branchName ?? name;
 26 | 
 27 |         let workingDir = workspaceRoot;
 28 |         let branch: string | undefined;
 29 |         let worktreePath: string | undefined;
 30 | 
 31 |         if (isolationMode === 'worktree') {
 32 |             if (customWorktreePath) {
 33 |                 // Resolve relative path to absolute path based on workspaceRoot
 34 |                 worktreePath = path.resolve(workspaceRoot, customWorktreePath);
 35 |             } else {
 36 |                 const workspaceName = path.basename(workspaceRoot);
 37 |                 const worktreeBaseDir = path.join(path.dirname(workspaceRoot), `${workspaceName}.worktree`);
 38 |                 worktreePath = path.join(worktreeBaseDir, effectiveBranchName);
 39 |             }
 40 |             await this.gitPort.createWorktree(worktreePath, effectiveBranchName, workspaceRoot);
 41 |             workingDir = worktreePath;
 42 |             branch = effectiveBranchName;
 43 | 
 44 |             // Copy gitignored files to worktree
 45 |             await this.copyWorktreeFiles(
 46 |                 workspaceRoot,
 47 |                 worktreePath,
 48 |                 input.worktreeCopyPatterns ?? []
 49 |             );
 50 |         }
 51 | 
 52 |         const terminalId = await this.terminalPort.createTerminal(name, workingDir);
 53 | 
 54 |         const threadState = ThreadState.create({
 55 |             name,
 56 |             terminalId,
 57 |             workingDir,
 58 |             branch,
 59 |             worktreePath,
 60 |             whitelistPatterns: [],
 61 |         });
 62 | 
 63 |         await this.threadStateRepository.save(threadState);
 64 | 
 65 |         return { threadState };
 66 |     }
 67 | 
 68 |     private async copyWorktreeFiles(
 69 |         sourceRoot: string,
 70 |         destRoot: string,
 71 |         patterns: string[]
 72 |     ): Promise<void> {
 73 |         if (patterns.length === 0) return;
 74 | 
 75 |         for (const pattern of patterns) {
 76 |             try {
 77 |                 const files = await this.fileGlobber.glob(pattern, sourceRoot);
 78 |                 for (const absolutePath of files) {
 79 |                     await this.copySingleFile(absolutePath, sourceRoot, destRoot);
 80 |                 }
 81 |             } catch (error) {
 82 |                 console.warn(`[Code Squad] Failed to glob pattern "${pattern}":`, error);
 83 |             }
 84 |         }
 85 |     }
 86 | 
 87 |     private async copySingleFile(
 88 |         absolutePath: string,
 89 |         sourceRoot: string,
 90 |         destRoot: string
 91 |     ): Promise<void> {
 92 |         try {
 93 |             const relativePath = path.relative(sourceRoot, absolutePath);
 94 |             const destPath = path.join(destRoot, relativePath);
 95 |             const destDir = path.dirname(destPath);
 96 | 
 97 |             await this.fileSystemPort.ensureDir(destDir);
 98 |             await this.fileSystemPort.copyFile(absolutePath, destPath);
 99 |         } catch (error) {
100 |             console.warn(`[Code Squad] Failed to copy "${absolutePath}":`, error);
101 |         }
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/diff/DiffHeader.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Diff Header Component
  3 |  *
  4 |  * Renders file path, stats badges, and view mode toggle.
  5 |  */
  6 | 
  7 | export interface DiffStats {
  8 |   additions: number;
  9 |   deletions: number;
 10 | }
 11 | 
 12 | export type ViewMode = 'diff' | 'scope' | 'preview';
 13 | 
 14 | export interface DiffHeaderProps {
 15 |   filePath: string;
 16 |   stats: DiffStats;
 17 |   viewMode: ViewMode;
 18 |   hasScopedDiff: boolean;
 19 |   isMarkdown: boolean;
 20 |   aiActive: boolean;
 21 |   ownerThreadName?: string;
 22 |   multipleThreadsExist: boolean;
 23 | }
 24 | 
 25 | /**
 26 |  * Check if file is markdown
 27 |  */
 28 | export function isMarkdownFile(filePath: string): boolean {
 29 |   return (
 30 |     filePath.endsWith('.md') ||
 31 |     filePath.endsWith('.markdown') ||
 32 |     filePath.endsWith('.mdx')
 33 |   );
 34 | }
 35 | 
 36 | /**
 37 |  * Render diff stats badges
 38 |  */
 39 | export function renderDiffStats(stats: DiffStats): string {
 40 |   return `
 41 |     <span class="stat-added">+${stats.additions}</span>
 42 |     <span class="stat-removed">-${stats.deletions}</span>
 43 |   `;
 44 | }
 45 | 
 46 | /**
 47 |  * Render view mode toggle button
 48 |  */
 49 | export function renderViewModeToggle(
 50 |   viewMode: ViewMode,
 51 |   hasScopedDiff: boolean,
 52 |   isMarkdown: boolean
 53 | ): string {
 54 |   if (isMarkdown) {
 55 |     return `
 56 |       <div class="view-mode-toggle">
 57 |         <button class="toggle-btn" onclick="toggleDiffViewMode()">${viewMode === 'preview' ? 'Diff' : 'Preview'}</button>
 58 |       </div>
 59 |     `;
 60 |   }
 61 | 
 62 |   if (hasScopedDiff) {
 63 |     return `
 64 |       <div class="view-mode-toggle">
 65 |         <button class="toggle-btn" onclick="toggleDiffViewMode()">Scope</button>
 66 |       </div>
 67 |     `;
 68 |   }
 69 | 
 70 |   return '';
 71 | }
 72 | 
 73 | /**
 74 |  * Render feed toggle button (only when AI is active)
 75 |  */
 76 | export function renderFeedToggle(aiActive: boolean): string {
 77 |   if (!aiActive) return '';
 78 |   return '<button class="feed-toggle-btn" onclick="toggleFeed()" title="Show HN Feed">📰</button>';
 79 | }
 80 | 
 81 | /**
 82 |  * Render thread badge (only when multiple threads exist)
 83 |  */
 84 | export function renderThreadBadge(ownerThreadName?: string, multipleThreadsExist?: boolean): string {
 85 |   if (!multipleThreadsExist || !ownerThreadName) return '';
 86 |   return `<span class="thread-badge">[${ownerThreadName}]</span>`;
 87 | }
 88 | 
 89 | /**
 90 |  * Render complete stats section
 91 |  */
 92 | export function renderStatsSection(props: DiffHeaderProps): string {
 93 |   const { stats, viewMode, hasScopedDiff, isMarkdown, aiActive } = props;
 94 | 
 95 |   const statsHtml = renderDiffStats(stats);
 96 |   const toggleHtml = renderViewModeToggle(viewMode, hasScopedDiff, isMarkdown);
 97 |   const feedToggleHtml = renderFeedToggle(aiActive);
 98 | 
 99 |   return `${statsHtml}${toggleHtml}${feedToggleHtml}`;
100 | }
101 | 
102 | /**
103 |  * Update diff header with file info
104 |  */
105 | export function updateDiffHeader(
106 |   headerEl: HTMLElement,
107 |   statsEl: HTMLElement,
108 |   props: DiffHeaderProps,
109 |   onOpenFile: (filePath: string) => void
110 | ): void {
111 |   const { filePath, stats, viewMode, hasScopedDiff, isMarkdown, aiActive, ownerThreadName, multipleThreadsExist } = props;
112 | 
113 |   // Render file path with optional thread badge
114 |   const threadBadge = renderThreadBadge(ownerThreadName, multipleThreadsExist);
115 |   headerEl.innerHTML = `<span class="file-path">${filePath}</span>${threadBadge}`;
116 |   headerEl.style.cursor = 'pointer';
117 |   headerEl.onclick = () => onOpenFile(filePath);
118 | 
119 |   statsEl.innerHTML = renderStatsSection({
120 |     filePath,
121 |     stats,
122 |     viewMode,
123 |     hasScopedDiff,
124 |     isMarkdown,
125 |     aiActive,
126 |     ownerThreadName,
127 |     multipleThreadsExist,
128 |   });
129 | }
130 | 
131 | /**
132 |  * Render placeholder when no file selected
133 |  */
134 | export function renderPlaceholder(selectedFile: string | null): string {
135 |   return `
136 |     <div class="placeholder">
137 |       <div class="placeholder-icon">${selectedFile ? '✓' : '📝'}</div>
138 |       <div class="placeholder-text">${selectedFile ? 'No changes in this file' : 'Select a modified file to view changes'}</div>
139 |     </div>
140 |   `;
141 | }
142 | 


--------------------------------------------------------------------------------
/src/infrastructure/repositories/JsonCommentRepository.ts:
--------------------------------------------------------------------------------
  1 | import * as fs from 'fs';
  2 | import * as path from 'path';
  3 | import { Comment, CommentData } from '../../domain/entities/Comment';
  4 | import { ICommentRepository } from '../../application/ports/outbound/ICommentRepository';
  5 | 
  6 | export class JsonCommentRepository implements ICommentRepository {
  7 |     private comments: Comment[] = [];
  8 |     private storagePath: string | undefined;
  9 | 
 10 |     constructor(workspaceRoot: string | undefined) {
 11 |         if (workspaceRoot) {
 12 |             const vscodeDir = path.join(workspaceRoot, '.vscode');
 13 |             if (!fs.existsSync(vscodeDir)) {
 14 |                 fs.mkdirSync(vscodeDir);
 15 |             }
 16 |             const legacyPath = path.join(vscodeDir, 'sidemirror-comments.json');
 17 |             const newPath = path.join(vscodeDir, 'code-squad-comments.json');
 18 | 
 19 |             this.storagePath = newPath;
 20 | 
 21 |             // Migrate legacy comment store if present
 22 |             if (fs.existsSync(legacyPath) && !fs.existsSync(newPath)) {
 23 |                 this.loadCommentsFrom(legacyPath);
 24 |                 this.persistComments();
 25 |             } else {
 26 |                 this.loadCommentsFrom(newPath);
 27 |             }
 28 |         }
 29 |     }
 30 | 
 31 |     async save(comment: Comment): Promise<void> {
 32 |         this.comments.push(comment);
 33 |         this.persistComments();
 34 |     }
 35 | 
 36 |     async findAll(): Promise<Comment[]> {
 37 |         return [...this.comments];
 38 |     }
 39 | 
 40 |     async findActive(): Promise<Comment[]> {
 41 |         return this.comments.filter(c => !c.isSubmitted);
 42 |     }
 43 | 
 44 |     async findByThreadId(threadId: string): Promise<Comment[]> {
 45 |         return this.comments.filter(c => c.threadId === threadId);
 46 |     }
 47 | 
 48 |     async findActiveByThreadId(threadId: string): Promise<Comment[]> {
 49 |         return this.comments.filter(c => c.threadId === threadId && !c.isSubmitted);
 50 |     }
 51 | 
 52 |     async markAsSubmitted(ids: string[]): Promise<void> {
 53 |         const idSet = new Set(ids);
 54 |         this.comments.forEach(c => {
 55 |             if (idSet.has(c.id)) {
 56 |                 c.markAsSubmitted();
 57 |             }
 58 |         });
 59 |         this.persistComments();
 60 |     }
 61 | 
 62 |     async update(id: string, text: string): Promise<Comment | null> {
 63 |         const index = this.comments.findIndex(c => c.id === id);
 64 |         if (index === -1) {
 65 |             return null;
 66 |         }
 67 | 
 68 |         const existing = this.comments[index];
 69 |         const updated = existing.withText(text);
 70 |         this.comments[index] = updated;
 71 |         this.persistComments();
 72 |         return updated;
 73 |     }
 74 | 
 75 |     async delete(id: string): Promise<boolean> {
 76 |         const index = this.comments.findIndex(c => c.id === id);
 77 |         if (index === -1) {
 78 |             return false;
 79 |         }
 80 | 
 81 |         this.comments.splice(index, 1);
 82 |         this.persistComments();
 83 |         return true;
 84 |     }
 85 | 
 86 |     async deleteByThreadId(threadId: string): Promise<number> {
 87 |         const initialCount = this.comments.length;
 88 |         this.comments = this.comments.filter(c => c.threadId !== threadId);
 89 |         const deletedCount = initialCount - this.comments.length;
 90 | 
 91 |         if (deletedCount > 0) {
 92 |             this.persistComments();
 93 |         }
 94 | 
 95 |         return deletedCount;
 96 |     }
 97 | 
 98 |     private loadCommentsFrom(filePath: string): void {
 99 |         if (!fs.existsSync(filePath)) {
100 |             return;
101 |         }
102 | 
103 |         try {
104 |             const data = fs.readFileSync(filePath, 'utf8');
105 |             const parsed: CommentData[] = JSON.parse(data);
106 |             this.comments = parsed.map(d => new Comment(d));
107 |         } catch (e) {
108 |             console.error('[Code Squad] Failed to load comments', e);
109 |         }
110 |     }
111 | 
112 |     private persistComments(): void {
113 |         if (this.storagePath) {
114 |             try {
115 |                 const data = this.comments.map(c => c.toData());
116 |                 fs.writeFileSync(this.storagePath, JSON.stringify(data, null, 2));
117 |             } catch (e) {
118 |                 console.error('[Code Squad] Failed to save comments', e);
119 |             }
120 |         }
121 |     }
122 | }
123 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/diff/DiffViewer.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Diff Viewer Component
  3 |  *
  4 |  * Main orchestrator for rendering diff views (unified, scope, preview).
  5 |  */
  6 | 
  7 | import type { DiffChunk, ChunkState, InlineComment } from './ChunkRenderer';
  8 | import type { DiffStats, ViewMode, DiffHeaderProps } from './DiffHeader';
  9 | import { renderStatsSection, renderPlaceholder } from './DiffHeader';
 10 | 
 11 | export interface DiffData {
 12 |   file: string;
 13 |   chunks: DiffChunk[];
 14 |   stats: DiffStats;
 15 |   chunkStates?: ChunkState[];
 16 | }
 17 | 
 18 | export interface DiffViewerProps {
 19 |   diff: DiffData | null;
 20 |   selectedFile: string | null;
 21 |   viewMode: ViewMode;
 22 |   comments: InlineComment[];
 23 |   hasScopedDiff: boolean;
 24 |   isMarkdown: boolean;
 25 |   aiActive: boolean;
 26 | }
 27 | 
 28 | export interface DiffViewerElements {
 29 |   header: HTMLElement;
 30 |   stats: HTMLElement;
 31 |   viewer: HTMLElement;
 32 |   toolbar: HTMLElement;
 33 |   collapseButton: HTMLElement;
 34 | }
 35 | 
 36 | /**
 37 |  * Get diff viewer elements
 38 |  */
 39 | export function getDiffViewerElements(): DiffViewerElements | null {
 40 |   const header = document.querySelector('.diff-header-title') as HTMLElement | null;
 41 |   const stats = document.getElementById('diff-stats');
 42 |   const viewer = document.getElementById('diff-viewer');
 43 |   const toolbar = document.getElementById('diff-toolbar');
 44 |   const collapseButton = document.getElementById('diff-collapse-all');
 45 | 
 46 |   if (!header || !stats || !viewer || !toolbar || !collapseButton) {
 47 |     return null;
 48 |   }
 49 | 
 50 |   return { header, stats, viewer, toolbar, collapseButton };
 51 | }
 52 | 
 53 | /**
 54 |  * Update diff header with file info
 55 |  */
 56 | export function updateDiffViewerHeader(
 57 |   elements: DiffViewerElements,
 58 |   props: DiffViewerProps,
 59 |   onOpenFile: (filePath: string) => void
 60 | ): void {
 61 |   const { header, stats, toolbar, collapseButton } = elements;
 62 |   const { diff, viewMode, hasScopedDiff, isMarkdown, aiActive } = props;
 63 | 
 64 |   if (!diff || !diff.chunks || diff.chunks.length === 0) {
 65 |     toolbar.style.display = 'none';
 66 |     return;
 67 |   }
 68 | 
 69 |   toolbar.style.display = 'flex';
 70 | 
 71 |   header.textContent = diff.file;
 72 |   header.style.cursor = 'pointer';
 73 |   header.onclick = () => onOpenFile(diff.file);
 74 | 
 75 |   const headerProps: DiffHeaderProps = {
 76 |     filePath: diff.file,
 77 |     stats: diff.stats,
 78 |     viewMode,
 79 |     hasScopedDiff,
 80 |     isMarkdown,
 81 |     aiActive,
 82 |   };
 83 | 
 84 |   stats.innerHTML = renderStatsSection(headerProps);
 85 | 
 86 |   // Update collapse button text
 87 |   const chunkStates = diff.chunkStates || [];
 88 |   const allCollapsed =
 89 |     chunkStates.length > 0 && chunkStates.every((s) => s.isCollapsed);
 90 |   collapseButton.textContent = allCollapsed ? 'Expand' : 'Collapse';
 91 | }
 92 | 
 93 | /**
 94 |  * Render empty/placeholder state
 95 |  */
 96 | export function renderEmptyState(
 97 |   elements: DiffViewerElements,
 98 |   selectedFile: string | null
 99 | ): void {
100 |   const { header, stats, viewer, toolbar } = elements;
101 | 
102 |   header.textContent = selectedFile || 'Select a file to review';
103 |   stats.innerHTML = '';
104 |   toolbar.style.display = 'none';
105 |   viewer.innerHTML = renderPlaceholder(selectedFile);
106 | }
107 | 
108 | /**
109 |  * Toggle diff view mode
110 |  */
111 | export function getNextViewMode(
112 |   currentMode: ViewMode,
113 |   isMarkdown: boolean,
114 |   hasScopedDiff: boolean
115 | ): ViewMode {
116 |   if (isMarkdown) {
117 |     return currentMode === 'preview' ? 'diff' : 'preview';
118 |   }
119 |   if (hasScopedDiff) {
120 |     return currentMode === 'scope' ? 'diff' : 'scope';
121 |   }
122 |   return 'diff';
123 | }
124 | 
125 | /**
126 |  * Register view mode toggle on window
127 |  */
128 | export function registerViewModeToggle(
129 |   onToggle: () => void
130 | ): void {
131 |   const win = window as unknown as Record<string, unknown>;
132 |   win.toggleDiffViewMode = onToggle;
133 | }
134 | 
135 | /**
136 |  * Register feed toggle on window
137 |  */
138 | export function registerFeedToggle(
139 |   onToggle: () => void
140 | ): void {
141 |   const win = window as unknown as Record<string, unknown>;
142 |   win.toggleFeed = onToggle;
143 | }
144 | 
145 | /**
146 |  * Render diff table wrapper
147 |  */
148 | export function renderDiffTableWrapper(tableContent: string): string {
149 |   return `
150 |     <table class="diff-table">
151 |       <colgroup>
152 |         <col class="col-gutter">
153 |         <col class="col-line-num">
154 |         <col class="col-content">
155 |       </colgroup>
156 |       ${tableContent}
157 |     </table>
158 |   `;
159 | }
160 | 


--------------------------------------------------------------------------------
/src/application/services/IPanelStateManager.ts:
--------------------------------------------------------------------------------
  1 | import { PanelState, FileInfo, CommentInfo, AIStatus, DiffDisplayState, DiffViewMode, DraftComment, ScopedDiffDisplayState, HNStoryInfo, AgentDisplayInfo } from '../ports/outbound/PanelState';
  2 | 
  3 | /**
  4 |  * Panel state manager - manages UI state and triggers rendering
  5 |  *
  6 |  * UseCase들이 이 인터페이스를 통해 UI 상태를 변경한다.
  7 |  * 상태 변경 시 자동으로 IPanelPort.render()가 호출된다.
  8 |  */
  9 | export interface IPanelStateManager {
 10 |     // State access
 11 |     getState(): PanelState;
 12 | 
 13 |     // Session file operations
 14 |     addSessionFile(file: FileInfo): void;
 15 |     removeSessionFile(path: string): void;
 16 |     selectFile(path: string | null): void;
 17 | 
 18 |     /**
 19 |      * Atomically update multiple session files in a single render.
 20 |      * Used by batch flush mechanism to prevent UI thrashing.
 21 |      */
 22 |     updateSessionFilesBatch(files: FileInfo[]): void;
 23 | 
 24 |     // Baseline operations
 25 |     setBaseline(files: FileInfo[]): void;
 26 |     isInBaseline(path: string): boolean;
 27 |     moveToSession(path: string): void;
 28 |     clearBaseline(): void;
 29 | 
 30 |     // Toggle
 31 |     toggleShowUncommitted(): void;
 32 |     setShowUncommitted(show: boolean): void;
 33 | 
 34 |     // Diff operations
 35 |     showDiff(diff: DiffDisplayState, scopedDiff?: ScopedDiffDisplayState): void;
 36 |     clearDiff(): void;
 37 | 
 38 |     // Chunk collapse operations
 39 |     toggleChunkCollapse(chunkIndex: number): void;
 40 |     collapseAllChunks(): void;
 41 |     expandAllChunks(): void;
 42 | 
 43 |     // Scoped diff operations
 44 |     clearScopedDiff(): void;
 45 |     toggleScopeCollapse(scopeId: string): void;
 46 |     expandAllScopes(): void;
 47 |     collapseAllScopes(): void;
 48 |     expandScopeChain(scopeId: string): void;
 49 | 
 50 |     // Comment operations
 51 |     addComment(comment: CommentInfo): void;
 52 |     updateComment(comment: CommentInfo): void;
 53 |     removeComment(id: string): void;
 54 |     clearComments(): void;
 55 |     markCommentsAsSubmitted(ids: string[]): void;
 56 |     findCommentById(id: string): CommentInfo | undefined;
 57 |     /**
 58 |      * Set all comments (replaces existing comments).
 59 |      * Used when switching threads to show only that thread's comments.
 60 |      */
 61 |     setComments(comments: CommentInfo[]): void;
 62 | 
 63 |     // AI status
 64 |     setAIStatus(status: AIStatus): void;
 65 | 
 66 |     // View mode
 67 |     setTreeView(isTree: boolean): void;
 68 |     setDiffViewMode(mode: DiffViewMode): void;
 69 | 
 70 |     // Search operations
 71 |     setSearchQuery(query: string): void;
 72 | 
 73 |     // Draft comment operations
 74 |     setDraftComment(draft: DraftComment | null): void;
 75 |     clearDraftComment(): void;
 76 | 
 77 |     // Scroll position operations
 78 |     setFileScrollPosition(filePath: string, scrollTop: number): void;
 79 |     getFileScrollPosition(filePath: string): number;
 80 | 
 81 |     // Reset state (e.g., when panel closes)
 82 |     reset(): void;
 83 | 
 84 |     // HN feed operations
 85 |     setHNFeedLoading(): void;
 86 |     setHNStories(stories: HNStoryInfo[], fetchedAt: number, hasMore: boolean): void;
 87 |     setHNFeedError(error: string): void;
 88 |     clearHNFeed(): void;
 89 |     setHNLoadingMore(loading: boolean): void;
 90 | 
 91 |     // HN feed visibility toggle
 92 |     setShowHNFeed(show: boolean): void;
 93 |     toggleHNFeed(): void;
 94 | 
 95 |     // Content view operations
 96 |     /**
 97 |      * Open content view with specified URL and title
 98 |      * @param url URL to display in iframe
 99 |      * @param title Title to show in content view header
100 |      */
101 |     openContentView(url: string, title: string): void;
102 | 
103 |     /**
104 |      * Close content view and return to previous view
105 |      */
106 |     closeContentView(): void;
107 | 
108 |     // Agent metadata operations
109 |     /**
110 |      * Set agent display info for multi-agent mode.
111 |      * Pass undefined to clear agent info.
112 |      */
113 |     setAgentInfo(info: AgentDisplayInfo | undefined): void;
114 | 
115 |     /**
116 |      * Set aggregated view mode.
117 |      * When true, panel shows files from all agents.
118 |      */
119 |     setAggregatedView(isAggregated: boolean): void;
120 | 
121 |     // Thread context operations
122 |     /**
123 |      * Set the thread ID for this panel.
124 |      * Comments will be associated with this thread.
125 |      */
126 |     setThreadId(threadId: string | undefined): void;
127 | 
128 |     /**
129 |      * Get the current thread ID.
130 |      */
131 |     getThreadId(): string | undefined;
132 | 
133 |     /**
134 |      * Set the total number of active threads.
135 |      * Used to determine whether to show thread badges on files.
136 |      */
137 |     setThreadCount(count: number): void;
138 | }
139 | 


--------------------------------------------------------------------------------
/src/test/domain/services/TerminalStatusDetector.test.ts:
--------------------------------------------------------------------------------
  1 | import * as assert from 'assert';
  2 | import { TerminalStatusDetector } from '../../../domain/services/TerminalStatusDetector';
  3 | 
  4 | suite('TerminalStatusDetector', () => {
  5 |     let detector: TerminalStatusDetector;
  6 | 
  7 |     setup(() => {
  8 |         detector = new TerminalStatusDetector();
  9 |     });
 10 | 
 11 |     // Note: 'working' status is detected by activity (output received), not patterns
 12 |     // The detector only returns 'waiting', 'idle', or 'inactive'
 13 | 
 14 |     suite('detect - Claude patterns', () => {
 15 |         test('detects waiting status from selection menu', () => {
 16 |             const output = 'Enter to select';
 17 |             const status = detector.detect('claude', output);
 18 |             assert.strictEqual(status, 'waiting');
 19 |         });
 20 | 
 21 |         test('detects waiting status from y/n prompt', () => {
 22 |             const output = 'Do you want to proceed? (y/n)';
 23 |             const status = detector.detect('claude', output);
 24 |             assert.strictEqual(status, 'waiting');
 25 |         });
 26 | 
 27 |         test('detects waiting status from Y/n prompt', () => {
 28 |             const output = 'Confirm [Y/n]';
 29 |             const status = detector.detect('claude', output);
 30 |             assert.strictEqual(status, 'waiting');
 31 |         });
 32 | 
 33 |         test('detects waiting status from Tab/Arrow navigation', () => {
 34 |             const output = 'Tab/Arrow keys to navigate';
 35 |             const status = detector.detect('claude', output);
 36 |             assert.strictEqual(status, 'waiting');
 37 |         });
 38 | 
 39 |         test('detects idle status from prompt', () => {
 40 |             const output = '> ';
 41 |             const status = detector.detect('claude', output);
 42 |             assert.strictEqual(status, 'idle');
 43 |         });
 44 | 
 45 |         test('returns inactive for unknown output', () => {
 46 |             const output = 'Some random text';
 47 |             const status = detector.detect('claude', output);
 48 |             assert.strictEqual(status, 'inactive');
 49 |         });
 50 | 
 51 |         test('priority: waiting takes precedence over idle', () => {
 52 |             // This output contains both waiting and idle patterns
 53 |             const output = '> Do you want to proceed? (y/n)';
 54 |             const status = detector.detect('claude', output);
 55 |             assert.strictEqual(status, 'waiting');
 56 |         });
 57 |     });
 58 | 
 59 |     suite('detect - strips ANSI codes', () => {
 60 |         test('strips ANSI cursor codes before matching', () => {
 61 |             const output = '\x1B[2K\x1B[1GEnter to select';
 62 |             const status = detector.detect('claude', output);
 63 |             assert.strictEqual(status, 'waiting');
 64 |         });
 65 | 
 66 |         test('strips ANSI codes and detects idle', () => {
 67 |             const output = '\x1B[32m> \x1B[0m';
 68 |             const status = detector.detect('claude', output);
 69 |             assert.strictEqual(status, 'idle');
 70 |         });
 71 |     });
 72 | 
 73 |     suite('detect - Codex patterns', () => {
 74 |         test('detects idle status from welcome message for codex', () => {
 75 |             const output = 'To get started, describe a task';
 76 |             const status = detector.detect('codex', output);
 77 |             assert.strictEqual(status, 'idle');
 78 |         });
 79 | 
 80 |         test('detects idle status from header banner for codex', () => {
 81 |             const output = '>_ OpenAI Codex (v0.36.0)';
 82 |             const status = detector.detect('codex', output);
 83 |             assert.strictEqual(status, 'idle');
 84 |         });
 85 |     });
 86 | 
 87 |     suite('detect - Gemini patterns', () => {
 88 |         test('detects waiting status for gemini (y/n)', () => {
 89 |             const output = '(y/n)';
 90 |             const status = detector.detect('gemini', output);
 91 |             assert.strictEqual(status, 'waiting');
 92 |         });
 93 | 
 94 |         // Removed: Confirm pattern was too broad, caused false positives
 95 | 
 96 |         test('detects waiting status for Waiting for user', () => {
 97 |             const output = 'Waiting for user confirmation...';
 98 |             const status = detector.detect('gemini', output);
 99 |             assert.strictEqual(status, 'waiting');
100 |         });
101 | 
102 |         test('detects idle status from Type your message for gemini', () => {
103 |             const output = '> Type your message or @path/to/file';
104 |             const status = detector.detect('gemini', output);
105 |             assert.strictEqual(status, 'idle');
106 |         });
107 | 
108 |         test('detects idle status from tips for gemini', () => {
109 |             const output = 'Tips for getting started:';
110 |             const status = detector.detect('gemini', output);
111 |             assert.strictEqual(status, 'idle');
112 |         });
113 |     });
114 | 
115 | });
116 | 


--------------------------------------------------------------------------------
/src/test/infrastructure/repositories/InMemoryFileThreadMappingRepository.test.ts:
--------------------------------------------------------------------------------
  1 | import * as assert from 'assert';
  2 | import { InMemoryFileThreadMappingRepository } from '../../../infrastructure/repositories/InMemoryFileThreadMappingRepository';
  3 | import { FileThreadMapping } from '../../../domain/entities/FileThreadMapping';
  4 | 
  5 | suite('InMemoryFileThreadMappingRepository', () => {
  6 |     let repository: InMemoryFileThreadMappingRepository;
  7 | 
  8 |     setup(() => {
  9 |         repository = new InMemoryFileThreadMappingRepository();
 10 |     });
 11 | 
 12 |     suite('TS8: Save and Find', () => {
 13 |         test('should save and find mapping by file path', async () => {
 14 |             // Arrange
 15 |             const mapping = FileThreadMapping.create('src/app.ts', 'tid-a');
 16 | 
 17 |             // Act
 18 |             await repository.save(mapping);
 19 |             const result = await repository.findByFilePath('src/app.ts');
 20 | 
 21 |             // Assert
 22 |             assert.notStrictEqual(result, null);
 23 |             assert.strictEqual(result!.threadId, 'tid-a');
 24 |             assert.strictEqual(result!.filePath, 'src/app.ts');
 25 |         });
 26 | 
 27 |         test('should return null for non-existent file path', async () => {
 28 |             const result = await repository.findByFilePath('non-existent.ts');
 29 |             assert.strictEqual(result, null);
 30 |         });
 31 | 
 32 |         test('should overwrite existing mapping for same file', async () => {
 33 |             // Arrange
 34 |             const mapping1 = FileThreadMapping.create('src/app.ts', 'tid-a');
 35 |             const mapping2 = FileThreadMapping.create('src/app.ts', 'tid-b');
 36 | 
 37 |             // Act
 38 |             await repository.save(mapping1);
 39 |             await repository.save(mapping2);
 40 |             const result = await repository.findByFilePath('src/app.ts');
 41 | 
 42 |             // Assert
 43 |             assert.notStrictEqual(result, null);
 44 |             assert.strictEqual(result!.threadId, 'tid-b');
 45 |         });
 46 |     });
 47 | 
 48 |     suite('TS9: Clear All', () => {
 49 |         test('should clear all mappings', async () => {
 50 |             // Arrange
 51 |             const mapping1 = FileThreadMapping.create('src/app.ts', 'tid-a');
 52 |             const mapping2 = FileThreadMapping.create('src/util.ts', 'tid-b');
 53 |             await repository.save(mapping1);
 54 |             await repository.save(mapping2);
 55 | 
 56 |             // Act
 57 |             await repository.clear();
 58 |             const result = await repository.findAll();
 59 | 
 60 |             // Assert
 61 |             assert.strictEqual(result.length, 0);
 62 |         });
 63 |     });
 64 | 
 65 |     suite('findByThreadId', () => {
 66 |         test('should find all mappings for a thread', async () => {
 67 |             // Arrange
 68 |             await repository.save(FileThreadMapping.create('src/a.ts', 'tid-a'));
 69 |             await repository.save(FileThreadMapping.create('src/b.ts', 'tid-a'));
 70 |             await repository.save(FileThreadMapping.create('src/c.ts', 'tid-b'));
 71 | 
 72 |             // Act
 73 |             const result = await repository.findByThreadId('tid-a');
 74 | 
 75 |             // Assert
 76 |             assert.strictEqual(result.length, 2);
 77 |             assert.ok(result.every(m => m.threadId === 'tid-a'));
 78 |         });
 79 | 
 80 |         test('should return empty array for non-existent thread', async () => {
 81 |             const result = await repository.findByThreadId('non-existent');
 82 |             assert.strictEqual(result.length, 0);
 83 |         });
 84 |     });
 85 | 
 86 |     suite('findAll', () => {
 87 |         test('should return all mappings', async () => {
 88 |             // Arrange
 89 |             await repository.save(FileThreadMapping.create('src/a.ts', 'tid-a'));
 90 |             await repository.save(FileThreadMapping.create('src/b.ts', 'tid-b'));
 91 | 
 92 |             // Act
 93 |             const result = await repository.findAll();
 94 | 
 95 |             // Assert
 96 |             assert.strictEqual(result.length, 2);
 97 |         });
 98 | 
 99 |         test('should return empty array when no mappings', async () => {
100 |             const result = await repository.findAll();
101 |             assert.strictEqual(result.length, 0);
102 |         });
103 |     });
104 | 
105 |     suite('delete', () => {
106 |         test('should delete existing mapping', async () => {
107 |             // Arrange
108 |             await repository.save(FileThreadMapping.create('src/app.ts', 'tid-a'));
109 | 
110 |             // Act
111 |             const deleted = await repository.delete('src/app.ts');
112 |             const result = await repository.findByFilePath('src/app.ts');
113 | 
114 |             // Assert
115 |             assert.strictEqual(deleted, true);
116 |             assert.strictEqual(result, null);
117 |         });
118 | 
119 |         test('should return false when deleting non-existent mapping', async () => {
120 |             const deleted = await repository.delete('non-existent.ts');
121 |             assert.strictEqual(deleted, false);
122 |         });
123 |     });
124 | });
125 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <div align="center">
  2 | 
  3 | <img alt="Code Squad" src="assets/code-squad-full.png" width="400">
  4 | 
  5 | <br />
  6 | 
  7 | **Immersive multi-agent coding.**
  8 | 
  9 | https://github.com/user-attachments/assets/cd1c6eb1-21fe-4179-91b8-a1abd920ea41
 10 | 
 11 | [![Open VSX Downloads](https://img.shields.io/open-vsx/dt/JakePark/code-squad?label=Downloads&color=teal)](https://open-vsx.org/extension/JakePark/code-squad)
 12 | [![GitHub Stars](https://img.shields.io/github/stars/team-attention/code-squad?style=flat&color=yellow)](https://github.com/team-attention/code-squad)
 13 | [![License](https://img.shields.io/github/license/team-attention/code-squad)](LICENSE)
 14 | 
 15 | </div>
 16 | 
 17 | <br />
 18 | 
 19 | > **Note**: This project was originally called "Sidecar". See [legacy documentation](SIDECAR_README.md).
 20 | 
 21 | ## Why Code Squad?
 22 | 
 23 | Running multiple AI agents in parallel is powerful — but switching between terminals, tracking changes across workspaces, and losing context is exhausting.
 24 | 
 25 | - Juggling multiple terminals breaks your focus
 26 | - Hard to see what changed across parallel sessions
 27 | - Context switching kills the flow
 28 | 
 29 | **Code Squad makes multi-agent coding immersive.**
 30 | 
 31 | Manage all your AI sessions in one place. See every change. Give feedback inline. Stay in the zone while your agents work in parallel.
 32 | 
 33 | ---
 34 | 
 35 | ## How It Works
 36 | 
 37 | ### 1. Start a Thread
 38 | 
 39 | Open **Thread Management** in the sidebar and click `+`.
 40 | 
 41 | - Enter a **task name**
 42 | - Choose **isolation mode**:
 43 |   - `Local` - Work in current branch
 44 |   - `Worktree` - Create isolated worktree (recommended for parallel work)
 45 | 
 46 | ### 2. Run Your AI Agent
 47 | 
 48 | A terminal opens. Run your preferred AI agent:
 49 | 
 50 | ```bash
 51 | claude    # Claude Code
 52 | codex     # OpenAI Codex CLI
 53 | gemini    # Gemini CLI
 54 | ```
 55 | 
 56 | ### 3. Review Changes
 57 | 
 58 | When AI modifies files, **Code Squad panel** shows all changes:
 59 | 
 60 | - File-by-file Diff view
 61 | - Scope view (grouped by function/class)
 62 | 
 63 | ### 4. Give Inline Feedback
 64 | 
 65 | Select lines that need changes. Write a comment. Hit **Submit** — it goes directly to the AI terminal.
 66 | 
 67 | ```
 68 | "Add error handling to this function"
 69 |     ↓
 70 | AI starts fixing immediately
 71 | ```
 72 | 
 73 | ---
 74 | 
 75 | ## Features
 76 | 
 77 | | Feature | Description |
 78 | |---------|-------------|
 79 | | **Thread Management** | Run multiple AI agents in isolated workspaces |
 80 | | **Isolation Modes** | `Local` (current branch) or `Worktree` (isolated directory) |
 81 | | **Attach to Worktree** | Connect Code Squad to existing git worktrees |
 82 | | **Auto-Detect** | Automatically detects `claude`, `codex`, `gemini` |
 83 | | **Diff View** | GitHub-style change comparison |
 84 | | **Inline Comments** | Select lines → Comment → Send to AI |
 85 | | **Scope View** | Changes grouped by function/class |
 86 | | **Status Tracking** | Real-time AI status with color indicators |
 87 | 
 88 | ### Thread Actions
 89 | 
 90 | Each thread in the sidebar has quick actions:
 91 | 
 92 | | Action | Description |
 93 | |--------|-------------|
 94 | | **Terminal** | Open/focus the thread's terminal |
 95 | | **Open in Editor** | Open worktree folder in new VS Code window |
 96 | | **Cleanup** | Delete thread and optionally remove worktree |
 97 | 
 98 | ### Status Indicators
 99 | 
100 | | Status | Color | Description |
101 | |--------|-------|-------------|
102 | | **Working** | 🟢 Green | AI is actively processing (pulsing) |
103 | | **Waiting** | 🟡 Yellow | AI waiting for confirmation (y/n) |
104 | | **Idle** | 🔵 Blue | AI ready for input |
105 | | **Inactive** | ⚪ Gray | No AI session running |
106 | 
107 | ---
108 | 
109 | ## Installation
110 | 
111 | **VS Code / Cursor Extension**
112 | 
113 | 1. Open Extensions (`Cmd+Shift+X`)
114 | 2. Search "Code Squad"
115 | 3. Click Install
116 | 
117 | Or download from [Open VSX](https://open-vsx.org/extension/JakePark/code-squad)
118 | 
119 | ---
120 | 
121 | ## Supported AI Tools
122 | 
123 | | Tool | Command |
124 | |------|---------|
125 | | [Claude Code](https://github.com/anthropics/claude-code) | `claude` |
126 | | [Codex CLI](https://github.com/openai/codex) | `codex` |
127 | | [Gemini CLI](https://github.com/google-gemini/gemini-cli) | `gemini` |
128 | 
129 | ---
130 | 
131 | ## Settings
132 | 
133 | | Setting | Default | Description |
134 | |---------|---------|-------------|
135 | | `codeSquad.autoDetect` | `true` | Auto-detect AI tools in terminal |
136 | | `codeSquad.autoShowPanel` | `true` | Open panel when AI detected |
137 | | `codeSquad.includeFiles` | `[]` | Glob patterns for gitignored files to track |
138 | | `codeSquad.worktreeCopyPatterns` | `[]` | Files to copy when creating worktree (e.g., `.env*`, `config/**`) |
139 | 
140 | ---
141 | 
142 | ## Requirements
143 | 
144 | - VS Code 1.93.0+ or Cursor
145 | 
146 | ---
147 | 
148 | ## Links
149 | 
150 | [GitHub](https://github.com/team-attention/code-squad) · [Issues](https://github.com/team-attention/code-squad/issues) · [Changelog](https://github.com/team-attention/code-squad/releases)
151 | 
152 | ---
153 | 
154 | <div align="center">
155 | 
156 | **MIT License**
157 | 
158 | </div>
159 | 


--------------------------------------------------------------------------------
/src/application/services/BatchEventCollector.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * File change event for batch processing.
  3 |  */
  4 | export interface FileChangeEvent {
  5 |     uri: { fsPath: string };
  6 |     type: 'create' | 'change' | 'delete';
  7 |     timestamp: number;
  8 |     source: 'git' | 'whitelist';
  9 | }
 10 | 
 11 | /**
 12 |  * Options for BatchEventCollector.
 13 |  */
 14 | export interface BatchEventCollectorOptions {
 15 |     /** Maximum time to collect events before flush (ms). Default: 100 */
 16 |     batchWindowMs?: number;
 17 |     /** Idle time after last event before flush (ms). Default: 50 */
 18 |     batchIdleMs?: number;
 19 | }
 20 | 
 21 | /**
 22 |  * Callback type for batch ready events.
 23 |  */
 24 | export type BatchReadyCallback = (events: FileChangeEvent[]) => void;
 25 | 
 26 | /**
 27 |  * Disposable subscription handle.
 28 |  */
 29 | export interface Disposable {
 30 |     dispose(): void;
 31 | }
 32 | 
 33 | /**
 34 |  * Interface for batch event collector.
 35 |  */
 36 | export interface IBatchEventCollector extends Disposable {
 37 |     /** Add event to current batch */
 38 |     addEvent(event: FileChangeEvent): void;
 39 | 
 40 |     /** Force immediate flush */
 41 |     flush(): Promise<void>;
 42 | 
 43 |     /** Cancel pending batch without firing */
 44 |     cancel(): void;
 45 | 
 46 |     /** Subscribe to batch ready events. Returns disposable to unsubscribe. */
 47 |     onBatchReady(callback: BatchReadyCallback): Disposable;
 48 | 
 49 |     /** Current pending event count */
 50 |     readonly pendingCount: number;
 51 | }
 52 | 
 53 | /**
 54 |  * Batch event collector with dual-timer strategy.
 55 |  *
 56 |  * - Window timer: Maximum latency guarantee (default: 100ms)
 57 |  * - Idle timer: Quick response when events stop (default: 50ms)
 58 |  *
 59 |  * Whichever timer fires first triggers the batch flush.
 60 |  */
 61 | export class BatchEventCollector implements IBatchEventCollector {
 62 |     private pendingEvents: FileChangeEvent[] = [];
 63 |     private windowTimer: NodeJS.Timeout | undefined;
 64 |     private idleTimer: NodeJS.Timeout | undefined;
 65 |     private listeners: BatchReadyCallback[] = [];
 66 | 
 67 |     private readonly batchWindowMs: number;
 68 |     private readonly batchIdleMs: number;
 69 | 
 70 |     constructor(options: BatchEventCollectorOptions = {}) {
 71 |         this.batchWindowMs = options.batchWindowMs ?? 100;
 72 |         this.batchIdleMs = options.batchIdleMs ?? 50;
 73 |     }
 74 | 
 75 |     addEvent(event: FileChangeEvent): void {
 76 |         this.pendingEvents.push(event);
 77 | 
 78 |         // Start window timer on first event
 79 |         if (!this.windowTimer) {
 80 |             this.windowTimer = setTimeout(() => this.doFlush(), this.batchWindowMs);
 81 |         }
 82 | 
 83 |         // Reset idle timer on every event
 84 |         if (this.idleTimer) {
 85 |             clearTimeout(this.idleTimer);
 86 |         }
 87 |         this.idleTimer = setTimeout(() => this.doFlush(), this.batchIdleMs);
 88 |     }
 89 | 
 90 |     async flush(): Promise<void> {
 91 |         this.doFlush();
 92 |     }
 93 | 
 94 |     cancel(): void {
 95 |         this.clearTimers();
 96 |         this.pendingEvents = [];
 97 |     }
 98 | 
 99 |     onBatchReady(callback: BatchReadyCallback): Disposable {
100 |         this.listeners.push(callback);
101 |         return {
102 |             dispose: () => {
103 |                 const index = this.listeners.indexOf(callback);
104 |                 if (index >= 0) {
105 |                     this.listeners.splice(index, 1);
106 |                 }
107 |             }
108 |         };
109 |     }
110 | 
111 |     private doFlush(): void {
112 |         this.clearTimers();
113 | 
114 |         if (this.pendingEvents.length === 0) return;
115 | 
116 |         const events = this.pendingEvents;
117 |         this.pendingEvents = [];
118 | 
119 |         // Notify all listeners
120 |         for (const listener of this.listeners) {
121 |             listener(events);
122 |         }
123 |     }
124 | 
125 |     private clearTimers(): void {
126 |         if (this.windowTimer) {
127 |             clearTimeout(this.windowTimer);
128 |             this.windowTimer = undefined;
129 |         }
130 |         if (this.idleTimer) {
131 |             clearTimeout(this.idleTimer);
132 |             this.idleTimer = undefined;
133 |         }
134 |     }
135 | 
136 |     get pendingCount(): number {
137 |         return this.pendingEvents.length;
138 |     }
139 | 
140 |     dispose(): void {
141 |         this.cancel();
142 |         this.listeners = [];
143 |     }
144 | }
145 | 
146 | /**
147 |  * Coalesce file events to keep only the latest event per path.
148 |  * Handles special cases:
149 |  * - Delete after create: removes the file entirely (no event)
150 |  * - Multiple changes: keeps latest event only
151 |  */
152 | export function coalesceFileEvents(events: FileChangeEvent[]): FileChangeEvent[] {
153 |     const latest = new Map<string, FileChangeEvent>();
154 | 
155 |     for (const event of events) {
156 |         const existing = latest.get(event.uri.fsPath);
157 | 
158 |         if (existing) {
159 |             // Handle delete after create: result is no event (file never existed)
160 |             if (event.type === 'delete' && existing.type === 'create') {
161 |                 latest.delete(event.uri.fsPath);
162 |                 continue;
163 |             }
164 |         }
165 | 
166 |         // Keep latest event for path
167 |         latest.set(event.uri.fsPath, event);
168 |     }
169 | 
170 |     return Array.from(latest.values());
171 | }
172 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "name": "code-squad",
  3 |   "displayName": "Code Squad",
  4 |   "description": "Immersive multi-agent coding - manage parallel AI sessions without context switching",
  5 |   "version": "0.1.19",
  6 |   "publisher": "JakePark",
  7 |   "repository": {
  8 |     "type": "git",
  9 |     "url": "https://github.com/team-attention/code-squad.git"
 10 |   },
 11 |   "license": "MIT",
 12 |   "icon": "assets/code-squad-icon.png",
 13 |   "engines": {
 14 |     "vscode": "^1.93.0"
 15 |   },
 16 |   "categories": [
 17 |     "Machine Learning",
 18 |     "Other"
 19 |   ],
 20 |   "keywords": [
 21 |     "codesquad",
 22 |     "code-squad",
 23 |     "code squad",
 24 |     "ai",
 25 |     "ai coding",
 26 |     "claude code",
 27 |     "codex cli",
 28 |     "gemini cli",
 29 |     "vibe coding",
 30 |     "multi-agent",
 31 |     "parallel",
 32 |     "terminal"
 33 |   ],
 34 |   "activationEvents": [
 35 |     "onStartupFinished"
 36 |   ],
 37 |   "main": "./dist/extension.js",
 38 |   "contributes": {
 39 |     "viewsContainers": {
 40 |       "activitybar": [
 41 |         {
 42 |           "id": "codeSquad",
 43 |           "title": "Code Squad",
 44 |           "icon": "assets/icon.svg"
 45 |         }
 46 |       ]
 47 |     },
 48 |     "views": {
 49 |       "codeSquad": [
 50 |         {
 51 |           "type": "webview",
 52 |           "id": "codeSquadThreadList",
 53 |           "name": "Threads",
 54 |           "icon": "$(list-tree)",
 55 |           "contextualTitle": "Code Squad Threads"
 56 |         }
 57 |       ]
 58 |     },
 59 |     "commands": [
 60 |       {
 61 |         "command": "codeSquad.openSidebar",
 62 |         "title": "Code Squad: Open Sidebar"
 63 |       },
 64 |       {
 65 |         "command": "codeSquad.resetAutoOpen",
 66 |         "title": "Code Squad: Reset Auto-Open Setting"
 67 |       },
 68 |       {
 69 |         "command": "codeSquad.attachToTerminal",
 70 |         "title": "Code Squad: Attach to Terminal"
 71 |       },
 72 |       {
 73 |         "command": "codeSquad.createAgent",
 74 |         "title": "Code Squad: Create New Agent",
 75 |         "icon": "$(add)"
 76 |       }
 77 |     ],
 78 |     "configuration": {
 79 |       "title": "Code Squad",
 80 |       "properties": {
 81 |         "codeSquad.autoDetect": {
 82 |           "type": "boolean",
 83 |           "default": true,
 84 |           "description": "Automatically detect Claude Code, Codex, and Gemini CLI execution"
 85 |         },
 86 |         "codeSquad.autoShowPanel": {
 87 |           "type": "boolean",
 88 |           "default": true,
 89 |           "description": "Automatically show Code Squad panel when AI is detected"
 90 |         },
 91 |         "codeSquad.includeFiles": {
 92 |           "type": "array",
 93 |           "default": [],
 94 |           "items": {
 95 |             "type": "string"
 96 |           },
 97 |           "description": "Glob patterns for files to track even if they are gitignored (e.g., ['dist/**', '.env.local'])"
 98 |         },
 99 |         "codeSquad.fileWatchDebounceMs": {
100 |           "type": "number",
101 |           "default": 300,
102 |           "minimum": 0,
103 |           "maximum": 2000,
104 |           "deprecationMessage": "Deprecated. Use codeSquad.fileWatchBatchWindowMs and codeSquad.fileWatchBatchIdleMs instead.",
105 |           "description": "DEPRECATED: Per-file debounce delay. Replaced by batch settings."
106 |         },
107 |         "codeSquad.fileWatchBatchWindowMs": {
108 |           "type": "number",
109 |           "default": 100,
110 |           "minimum": 0,
111 |           "maximum": 1000,
112 |           "description": "Maximum time to batch file change events before processing (ms). Higher values batch more aggressively."
113 |         },
114 |         "codeSquad.fileWatchBatchIdleMs": {
115 |           "type": "number",
116 |           "default": 50,
117 |           "minimum": 0,
118 |           "maximum": 500,
119 |           "description": "Idle time after last file event before batch flush (ms). Lower values provide faster response for single file changes."
120 |         },
121 |         "codeSquad.worktreeCopyPatterns": {
122 |           "type": "array",
123 |           "default": [],
124 |           "scope": "machine-overridable",
125 |           "items": {
126 |             "type": "string"
127 |           },
128 |           "description": "Glob patterns for files to copy from main workspace to worktrees (e.g., ['.env*', 'config/**'])"
129 |         }
130 |       }
131 |     }
132 |   },
133 |   "scripts": {
134 |     "vscode:prepublish": "npm run esbuild-base -- --minify && npm run esbuild-webview -- --minify",
135 |     "esbuild-base": "esbuild ./src/extension.ts --bundle --outfile=dist/extension.js --external:vscode --format=cjs --platform=node",
136 |     "esbuild-webview": "esbuild ./src/adapters/inbound/ui/webview/webview-entry.ts --bundle --outfile=dist/webview.js --format=iife --platform=browser --target=es2020",
137 |     "esbuild": "npm run esbuild-base -- --sourcemap && npm run esbuild-webview -- --sourcemap",
138 |     "esbuild-watch": "npm run esbuild-base -- --sourcemap --watch",
139 |     "compile": "tsc -p ./",
140 |     "watch": "tsc -watch -p ./",
141 |     "pretest": "npm run compile && npm run lint",
142 |     "lint": "eslint src --ext ts",
143 |     "test": "node ./out/test/runTest.js",
144 |     "test:unit": "npm run compile && mocha --ui tdd ./out/test/**/*.test.js"
145 |   },
146 |   "dependencies": {
147 |     "fast-glob": "^3.3.3",
148 |     "ignore": "^5.3.2",
149 |     "shiki": "^3.19.0"
150 |   },
151 |   "devDependencies": {
152 |     "@types/mocha": "^10.0.10",
153 |     "@types/node": "20.x",
154 |     "@types/vscode": "^1.93.0",
155 |     "@typescript-eslint/eslint-plugin": "^7.14.1",
156 |     "@typescript-eslint/parser": "^7.11.0",
157 |     "esbuild": "^0.27.0",
158 |     "eslint": "^8.57.0",
159 |     "mocha": "^11.0.1",
160 |     "typescript": "^5.4.5"
161 |   }
162 | }
163 | 


--------------------------------------------------------------------------------
/src/application/ports/outbound/PanelState.ts:
--------------------------------------------------------------------------------
  1 | import { DiffResult, DiffChunk, DiffLine } from '../../../domain/entities/Diff';
  2 | import { ScopeLine } from '../../../domain/entities/ScopedDiff';
  3 | import { ScopeInfo } from './ISymbolPort';
  4 | import { AgentStatus } from '../../../domain/entities/AISession';
  5 | 
  6 | export type DiffViewMode = 'diff' | 'preview' | 'scope';
  7 | 
  8 | export type HNFeedStatus = 'idle' | 'loading' | 'error' | 'success';
  9 | 
 10 | /**
 11 |  * HN story info for panel display (serializable)
 12 |  */
 13 | export interface HNStoryInfo {
 14 |     id: number;
 15 |     title: string;
 16 |     url: string | null;
 17 |     score: number;
 18 |     descendants: number;
 19 |     by: string;
 20 |     time: number;
 21 |     domain: string | null;
 22 |     discussionUrl: string;
 23 |     timeAgo: string;
 24 | }
 25 | 
 26 | /**
 27 |  * File information for panel display
 28 |  */
 29 | export interface FileInfo {
 30 |     path: string;
 31 |     name: string;
 32 |     status: 'modified' | 'added' | 'deleted';
 33 |     /** Agent name attribution for aggregated view */
 34 |     agentName?: string;
 35 |     /** Color index for agent badge (0-5 for 6-color palette, -1 for multi-agent) */
 36 |     agentColorIndex?: number;
 37 |     /** Thread ID that last modified this file */
 38 |     ownerThreadId?: string;
 39 |     /** Thread name for UI badge */
 40 |     ownerThreadName?: string;
 41 | }
 42 | 
 43 | /**
 44 |  * Extended chunk info for UI rendering
 45 |  */
 46 | export interface ChunkDisplayInfo {
 47 |     index: number;
 48 |     isCollapsed: boolean;
 49 |     scopeLabel: string | null;
 50 | }
 51 | 
 52 | /**
 53 |  * Deleted content info for markdown preview
 54 |  */
 55 | export interface DeletionInfo {
 56 |     /** Line number after which this deletion occurred (0 = before first line) */
 57 |     afterLine: number;
 58 |     /** Deleted content lines */
 59 |     content: string[];
 60 | }
 61 | 
 62 | /**
 63 |  * Diff display state (extends DiffResult for UI)
 64 |  */
 65 | export interface DiffDisplayState {
 66 |     file: string;
 67 |     chunks: DiffChunk[];
 68 |     stats: { additions: number; deletions: number };
 69 |     chunkStates: ChunkDisplayInfo[];
 70 |     scopes: ScopeInfo[];
 71 |     /** Full new file content for markdown preview */
 72 |     newFileContent?: string;
 73 |     /** Line numbers that were added/modified (1-indexed) */
 74 |     changedLineNumbers?: number[];
 75 |     /** Deleted content with position info */
 76 |     deletions?: DeletionInfo[];
 77 | }
 78 | 
 79 | /**
 80 |  * Display state for a scope chunk in scoped diff view
 81 |  */
 82 | export interface ScopedChunkDisplay {
 83 |     scopeId: string;
 84 |     scopeName: string;
 85 |     scopeKind: string;
 86 |     fullName: string;
 87 |     hasChanges: boolean;
 88 |     isCollapsed: boolean;
 89 |     lines: ScopeLine[];
 90 |     stats: { additions: number; deletions: number };
 91 |     children: ScopedChunkDisplay[];
 92 |     depth: number;
 93 | }
 94 | 
 95 | /**
 96 |  * Display state for scoped diff view
 97 |  */
 98 | export interface ScopedDiffDisplayState {
 99 |     file: string;
100 |     scopes: ScopedChunkDisplay[];
101 |     orphanLines: ScopeLine[];
102 |     stats: { additions: number; deletions: number };
103 |     hasScopeData: boolean;
104 | }
105 | 
106 | /**
107 |  * Comment information for panel display
108 |  */
109 | export interface CommentInfo {
110 |     id: string;
111 |     file: string;
112 |     line: number;
113 |     endLine?: number;
114 |     text: string;
115 |     isSubmitted: boolean;
116 |     codeContext: string;
117 |     timestamp: number;
118 | }
119 | 
120 | /**
121 |  * AI session status
122 |  */
123 | export interface AIStatus {
124 |     active: boolean;
125 |     type?: 'claude' | 'codex' | 'gemini' | string;
126 | }
127 | 
128 | /**
129 |  * State for displaying external content (HN articles, URLs) in main panel
130 |  */
131 | export interface ContentViewState {
132 |     /** URL to display in iframe */
133 |     url: string;
134 |     /** Title to show in header */
135 |     title: string;
136 | }
137 | 
138 | /**
139 |  * Agent display information for multi-agent mode
140 |  */
141 | export interface AgentDisplayInfo {
142 |     name: string;
143 |     status: AgentStatus;
144 | }
145 | 
146 | /**
147 |  * Draft comment being edited (not yet submitted)
148 |  */
149 | export interface DraftComment {
150 |     file: string;
151 |     startLine: number;
152 |     endLine: number;
153 |     text: string;
154 | }
155 | 
156 | /**
157 |  * Per-file scroll position storage
158 |  */
159 | export interface FileScrollPositions {
160 |     [filePath: string]: number;
161 | }
162 | 
163 | /**
164 |  * Complete panel state - single source of truth for UI
165 |  */
166 | export interface PanelState {
167 |     sessionFiles: FileInfo[];
168 |     uncommittedFiles: FileInfo[];
169 |     showUncommitted: boolean;
170 |     selectedFile: string | null;
171 |     diff: DiffDisplayState | null;
172 |     scopedDiff: ScopedDiffDisplayState | null;
173 |     comments: CommentInfo[];
174 |     aiStatus: AIStatus;
175 |     isTreeView: boolean;
176 |     diffViewMode: DiffViewMode;
177 |     searchQuery: string;
178 |     draftComment: DraftComment | null;
179 |     fileScrollPositions: FileScrollPositions;
180 |     hnStories: HNStoryInfo[];
181 |     hnFeedStatus: HNFeedStatus;
182 |     hnFeedError?: string;
183 |     hnLastFetchTime?: number;
184 |     hnHasMore: boolean;
185 |     hnLoadingMore: boolean;
186 |     showHNFeed: boolean;
187 |     /** Active content view state, null when not showing content */
188 |     contentView: ContentViewState | null;
189 |     /** Agent display info (name and status) for multi-agent mode */
190 |     agentInfo?: AgentDisplayInfo;
191 |     /** Whether currently showing aggregated view of all agents */
192 |     isAggregatedView?: boolean;
193 |     /** Thread ID for per-thread comment filtering */
194 |     threadId?: string;
195 |     /** Total number of active threads (for showing thread badges) */
196 |     threadCount: number;
197 | }
198 | 
199 | /**
200 |  * Create initial empty state
201 |  */
202 | export function createInitialPanelState(): PanelState {
203 |     return {
204 |         sessionFiles: [],
205 |         uncommittedFiles: [],
206 |         showUncommitted: false,
207 |         selectedFile: null,
208 |         diff: null,
209 |         scopedDiff: null,
210 |         comments: [],
211 |         aiStatus: { active: false },
212 |         isTreeView: true,
213 |         diffViewMode: 'diff',
214 |         searchQuery: '',
215 |         draftComment: null,
216 |         fileScrollPositions: {},
217 |         hnStories: [],
218 |         hnFeedStatus: 'idle',
219 |         hnFeedError: undefined,
220 |         hnLastFetchTime: undefined,
221 |         hnHasMore: true,
222 |         hnLoadingMore: false,
223 |         showHNFeed: false,
224 |         contentView: null,
225 |         agentInfo: undefined,
226 |         isAggregatedView: false,
227 |         threadCount: 0,
228 |     };
229 | }
230 | 


--------------------------------------------------------------------------------
/src/domain/services/TerminalStatusDetector.ts:
--------------------------------------------------------------------------------
  1 | import { AgentStatus, AIType } from '../entities/AISession';
  2 | 
  3 | interface StatusPattern {
  4 |     status: AgentStatus;
  5 |     patterns: RegExp[];
  6 |     priority: number;
  7 | }
  8 | 
  9 | export interface ITerminalStatusDetector {
 10 |     detect(aiType: AIType, output: string): AgentStatus;
 11 |     detectAIType(output: string): AIType | null;
 12 | }
 13 | 
 14 | // Status detection rules:
 15 | // - waiting: user input required (highest priority) - "Esc to cancel" in Claude
 16 | // - working: "Esc to interrupt" visible (AI processing)
 17 | // - idle: prompt ready for input
 18 | 
 19 | const CLAUDE_PATTERNS: StatusPattern[] = [
 20 |     {
 21 |         status: 'waiting',
 22 |         priority: 2,
 23 |         patterns: [
 24 |             /Esc to cancel/i,               // Permission dialog
 25 |             />\s*1\.\s*Yes/i,                // Permission menu option "> 1. Yes"
 26 |             /1\.\s*Yes,\s*allow/i,           // Confirmation menu with allow
 27 |             /Enter to select/,
 28 |             /\(y\/n\)/i,
 29 |             /\[Y\/n\]/i,
 30 |             /\[y\/N\]/i,
 31 |             /Tab\/Arrow keys/,
 32 |             /Press Enter to continue/,
 33 |             /Do you want to proceed\?/i,
 34 |             /Do you want to/i,
 35 |         ],
 36 |     },
 37 |     {
 38 |         status: 'working',
 39 |         priority: 1,
 40 |         patterns: [
 41 |             /Esc to interrupt/i,
 42 |         ],
 43 |     },
 44 |     {
 45 |         status: 'idle',
 46 |         priority: 0,
 47 |         patterns: [
 48 |             /^>\s*$/m,                        // Empty prompt (> ) - multiline mode
 49 |         ],
 50 |     },
 51 | ];
 52 | 
 53 | // Codex: Only idle detection - output arrives in large batches, making
 54 | // real-time working/waiting detection unreliable
 55 | const CODEX_PATTERNS: StatusPattern[] = [
 56 |     {
 57 |         status: 'idle',
 58 |         priority: 0,
 59 |         patterns: [
 60 |             /To get started,?\s*describe/i,   // Welcome message
 61 |             />_\s*OpenAI\s*Codex/i,           // Header banner
 62 |         ],
 63 |     },
 64 | ];
 65 | 
 66 | const GEMINI_PATTERNS: StatusPattern[] = [
 67 |     {
 68 |         status: 'waiting',
 69 |         priority: 2,
 70 |         patterns: [
 71 |             /\(y\/n\)/i,
 72 |             /\[Y\/n\]/i,
 73 |             /1\.\s*Yes,\s*allow once/i,      // Gemini confirmation menu
 74 |             /Waiting for user/i,
 75 |             /Allow execution/i,
 76 |             /Yes, allow/i,
 77 |             /suggest changes/i,
 78 |             /Enter to select/i,
 79 |             /Press Enter/i,
 80 |             /Do you want to/i,
 81 |         ],
 82 |     },
 83 |     {
 84 |         status: 'working',
 85 |         priority: 1,
 86 |         patterns: [
 87 |             /esc to cancel/i,                 // "(esc to cancel, 1s)"
 88 |         ],
 89 |     },
 90 |     {
 91 |         status: 'idle',
 92 |         priority: 0,
 93 |         patterns: [
 94 |             />\s*Type your message/i,         // Input prompt
 95 |             /Tips for getting started/i,      // Welcome tips
 96 |         ],
 97 |     },
 98 | ];
 99 | 
100 | const GENERIC_PATTERNS: StatusPattern[] = [
101 |     {
102 |         status: 'waiting',
103 |         priority: 2,
104 |         patterns: [
105 |             /1\.\s*Yes,\s*allow/i,           // Confirmation menu
106 |             /\(y\/n\)/i,
107 |             /\[Y\/n\]/i,
108 |         ],
109 |     },
110 |     {
111 |         status: 'working',
112 |         priority: 1,
113 |         patterns: [
114 |             /Esc to interrupt/i,
115 |         ],
116 |     },
117 | ];
118 | 
119 | // AI type detection patterns - used to identify which AI CLI is running
120 | // These patterns match startup banners and unique UI elements
121 | const AI_TYPE_PATTERNS: { type: AIType; patterns: RegExp[] }[] = [
122 |     {
123 |         type: 'gemini',
124 |         patterns: [
125 |             /Gemini CLI/i,                    // Gemini banner
126 |             /Tips for getting started/i,      // Gemini welcome message
127 |             />\s*Type your message/i,         // Gemini input prompt
128 |             /Gemini \d+\.\d+/i,               // Gemini version (e.g., "Gemini 2.5")
129 |         ],
130 |     },
131 |     {
132 |         type: 'codex',
133 |         patterns: [
134 |             /OpenAI\s*Codex/i,                // Codex banner
135 |             />_\s*OpenAI/i,                   // Codex header
136 |             /To get started,?\s*describe/i,   // Codex welcome
137 |         ],
138 |     },
139 |     {
140 |         type: 'claude',
141 |         patterns: [
142 |             /Claude Code/i,                   // Claude Code banner
143 |             /claude\.ai/i,                    // Claude domain reference
144 |             /Anthropic/i,                     // Anthropic reference
145 |             /\bclaude\b.*\bsonnet\b/i,        // Model name (claude sonnet)
146 |             /\bclaude\b.*\bopus\b/i,          // Model name (claude opus)
147 |             /\bclaude\b.*\bhaiku\b/i,         // Model name (claude haiku)
148 |         ],
149 |     },
150 | ];
151 | 
152 | function getPatternsForAI(aiType: AIType): StatusPattern[] {
153 |     switch (aiType) {
154 |         case 'claude':
155 |             return CLAUDE_PATTERNS;
156 |         case 'codex':
157 |             return CODEX_PATTERNS;
158 |         case 'gemini':
159 |             return GEMINI_PATTERNS;
160 |         default:
161 |             return GENERIC_PATTERNS;
162 |     }
163 | }
164 | 
165 | function stripAnsiCodes(text: string): string {
166 |     // eslint-disable-next-line no-control-regex
167 |     return text.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
168 | }
169 | 
170 | export class TerminalStatusDetector implements ITerminalStatusDetector {
171 |     detect(aiType: AIType, output: string): AgentStatus {
172 |         const cleanOutput = stripAnsiCodes(output);
173 |         const patterns = getPatternsForAI(aiType);
174 | 
175 |         // Sort by priority descending (check highest priority first)
176 |         const sortedPatterns = [...patterns].sort((a, b) => b.priority - a.priority);
177 | 
178 |         for (const { status, patterns: regexps } of sortedPatterns) {
179 |             for (const regex of regexps) {
180 |                 if (regex.test(cleanOutput)) {
181 |                     return status;
182 |                 }
183 |             }
184 |         }
185 | 
186 |         // No pattern matched - return inactive (no clear AI signal)
187 |         return 'inactive';
188 |     }
189 | 
190 |     /**
191 |      * Detect AI type from output content.
192 |      * Returns null if no AI type pattern is matched.
193 |      */
194 |     detectAIType(output: string): AIType | null {
195 |         const cleanOutput = stripAnsiCodes(output);
196 | 
197 |         for (const { type, patterns } of AI_TYPE_PATTERNS) {
198 |             for (const pattern of patterns) {
199 |                 if (pattern.test(cleanOutput)) {
200 |                     return type;
201 |                 }
202 |             }
203 |         }
204 | 
205 |         return null;
206 |     }
207 | }
208 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/webview-entry.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Webview Entry Point
  3 |  *
  4 |  * This file is the entry point for the bundled webview script.
  5 |  * It gets compiled separately by esbuild and the result is embedded in the webview.
  6 |  */
  7 | 
  8 | import {
  9 |     createHighlighterCore,
 10 |     type HighlighterCore,
 11 | } from 'shiki/core';
 12 | import { createJavaScriptRegexEngine } from 'shiki/engine/javascript';
 13 | 
 14 | // Import bundled languages (core set for smaller bundle)
 15 | import langTypescript from 'shiki/dist/langs/typescript.mjs';
 16 | import langTsx from 'shiki/dist/langs/tsx.mjs';
 17 | import langJavascript from 'shiki/dist/langs/javascript.mjs';
 18 | import langJsx from 'shiki/dist/langs/jsx.mjs';
 19 | import langPython from 'shiki/dist/langs/python.mjs';
 20 | import langJson from 'shiki/dist/langs/json.mjs';
 21 | import langYaml from 'shiki/dist/langs/yaml.mjs';
 22 | import langHtml from 'shiki/dist/langs/html.mjs';
 23 | import langCss from 'shiki/dist/langs/css.mjs';
 24 | import langMarkdown from 'shiki/dist/langs/markdown.mjs';
 25 | import langShellscript from 'shiki/dist/langs/shellscript.mjs';
 26 | 
 27 | // Themes - both light and dark for VSCode theme support
 28 | import themeGithubDark from 'shiki/dist/themes/github-dark.mjs';
 29 | import themeGithubLight from 'shiki/dist/themes/github-light.mjs';
 30 | 
 31 | // ===== Syntax Highlighter =====
 32 | 
 33 | let highlighterPromise: Promise<HighlighterCore> | null = null;
 34 | let highlighter: HighlighterCore | null = null;
 35 | 
 36 | /**
 37 |  * Detect if VSCode is using a light or dark theme
 38 |  * VSCode adds 'vscode-dark', 'vscode-light', or 'vscode-high-contrast' class to body
 39 |  */
 40 | function isLightTheme(): boolean {
 41 |     return document.body.classList.contains('vscode-light');
 42 | }
 43 | 
 44 | /**
 45 |  * Get the appropriate theme name based on VSCode's current theme
 46 |  */
 47 | function getThemeName(): 'github-dark' | 'github-light' {
 48 |     return isLightTheme() ? 'github-light' : 'github-dark';
 49 | }
 50 | 
 51 | const SUPPORTED_LANGUAGES = [
 52 |     langTypescript,
 53 |     langTsx,
 54 |     langJavascript,
 55 |     langJsx,
 56 |     langPython,
 57 |     langJson,
 58 |     langYaml,
 59 |     langHtml,
 60 |     langCss,
 61 |     langMarkdown,
 62 |     langShellscript,
 63 | ];
 64 | 
 65 | async function initHighlighter(): Promise<HighlighterCore> {
 66 |     if (highlighter) {
 67 |         return highlighter;
 68 |     }
 69 | 
 70 |     if (!highlighterPromise) {
 71 |         highlighterPromise = createHighlighterCore({
 72 |             themes: [themeGithubDark, themeGithubLight],
 73 |             langs: SUPPORTED_LANGUAGES,
 74 |             engine: createJavaScriptRegexEngine(),
 75 |         });
 76 |     }
 77 | 
 78 |     highlighter = await highlighterPromise;
 79 |     return highlighter;
 80 | }
 81 | 
 82 | function escapeHtmlForHighlight(text: string): string {
 83 |     return text
 84 |         .replace(/&/g, '&amp;')
 85 |         .replace(/</g, '&lt;')
 86 |         .replace(/>/g, '&gt;')
 87 |         .replace(/"/g, '&quot;');
 88 | }
 89 | 
 90 | /**
 91 |  * Highlight multiple lines efficiently
 92 |  */
 93 | async function highlightLines(
 94 |     lines: string[],
 95 |     language: string
 96 | ): Promise<string[]> {
 97 |     const hl = await initHighlighter();
 98 | 
 99 |     const loadedLangs = hl.getLoadedLanguages();
100 |     if (!loadedLangs.includes(language)) {
101 |         return lines.map(escapeHtmlForHighlight);
102 |     }
103 | 
104 |     const code = lines.join('\n');
105 |     try {
106 |         const html = hl.codeToHtml(code, {
107 |             lang: language,
108 |             theme: getThemeName(),
109 |         });
110 | 
111 |         const match = html.match(/<code[^>]*>([\s\S]*)<\/code>/);
112 |         if (match) {
113 |             return match[1].split('\n');
114 |         }
115 |     } catch {
116 |         // Fall through to plain text
117 |     }
118 | 
119 |     return lines.map(escapeHtmlForHighlight);
120 | }
121 | 
122 | /**
123 |  * Highlight code block for markdown
124 |  */
125 | async function highlightCodeBlock(
126 |     code: string,
127 |     language: string
128 | ): Promise<string> {
129 |     const langMap: Record<string, string> = {
130 |         js: 'javascript',
131 |         ts: 'typescript',
132 |         py: 'python',
133 |         sh: 'shellscript',
134 |         bash: 'shellscript',
135 |         yml: 'yaml',
136 |     };
137 | 
138 |     const normalizedLang = langMap[language] || language || 'plaintext';
139 |     const hl = await initHighlighter();
140 | 
141 |     const loadedLangs = hl.getLoadedLanguages();
142 |     if (!loadedLangs.includes(normalizedLang)) {
143 |         return escapeHtmlForHighlight(code);
144 |     }
145 | 
146 |     try {
147 |         const html = hl.codeToHtml(code, {
148 |             lang: normalizedLang,
149 |             theme: getThemeName(),
150 |         });
151 | 
152 |         const match = html.match(/<code[^>]*>([\s\S]*)<\/code>/);
153 |         return match ? match[1] : escapeHtmlForHighlight(code);
154 |     } catch {
155 |         return escapeHtmlForHighlight(code);
156 |     }
157 | }
158 | 
159 | // ===== Language Detection =====
160 | 
161 | const EXTENSION_TO_LANGUAGE: Record<string, string> = {
162 |     '.ts': 'typescript',
163 |     '.tsx': 'tsx',
164 |     '.mts': 'typescript',
165 |     '.cts': 'typescript',
166 |     '.js': 'javascript',
167 |     '.jsx': 'jsx',
168 |     '.mjs': 'javascript',
169 |     '.cjs': 'javascript',
170 |     '.py': 'python',
171 |     '.pyw': 'python',
172 |     '.pyi': 'python',
173 |     '.json': 'json',
174 |     '.jsonc': 'json',
175 |     '.yaml': 'yaml',
176 |     '.yml': 'yaml',
177 |     '.html': 'html',
178 |     '.htm': 'html',
179 |     '.css': 'css',
180 |     '.md': 'markdown',
181 |     '.mdx': 'markdown',
182 |     '.sh': 'shellscript',
183 |     '.bash': 'shellscript',
184 |     '.zsh': 'shellscript',
185 | };
186 | 
187 | function getLanguageFromPath(filePath: string): string {
188 |     const parts = filePath.split(/[/\\]/);
189 |     const filename = parts[parts.length - 1].toLowerCase();
190 | 
191 |     const lastDot = filename.lastIndexOf('.');
192 |     if (lastDot === -1) {
193 |         return 'plaintext';
194 |     }
195 | 
196 |     const extension = filename.slice(lastDot).toLowerCase();
197 |     return EXTENSION_TO_LANGUAGE[extension] || 'plaintext';
198 | }
199 | 
200 | // ===== Expose to window =====
201 | declare global {
202 |     interface Window {
203 |         CodeSquadHighlighter: {
204 |             highlightLines: typeof highlightLines;
205 |             highlightCodeBlock: typeof highlightCodeBlock;
206 |             getLanguageFromPath: typeof getLanguageFromPath;
207 |             preload: () => void;
208 |         };
209 |     }
210 | }
211 | 
212 | window.CodeSquadHighlighter = {
213 |     highlightLines,
214 |     highlightCodeBlock,
215 |     getLanguageFromPath,
216 |     preload: () => {
217 |         initHighlighter().catch(console.error);
218 |     },
219 | };
220 | 
221 | // Preload highlighter
222 | window.CodeSquadHighlighter.preload();
223 | 
224 | // Import and initialize the main application
225 | import './webview-app';
226 | 


--------------------------------------------------------------------------------
/src/adapters/inbound/ui/webview/components/waiting/HNFeed.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Hacker News Feed Component
  3 |  *
  4 |  * Renders Hacker News stories in the webview.
  5 |  * Used in waiting screen and feed toggle.
  6 |  */
  7 | 
  8 | import { escapeHtml } from '../../utils/dom';
  9 | 
 10 | /**
 11 |  * Domains known to block iframe embedding via X-Frame-Options or CSP.
 12 |  * These will be marked with an external link indicator.
 13 |  */
 14 | const IFRAME_BLOCKED_DOMAINS = new Set([
 15 |   'github.com',
 16 |   'twitter.com',
 17 |   'x.com',
 18 |   'linkedin.com',
 19 |   'facebook.com',
 20 |   'youtube.com',
 21 |   'medium.com',
 22 |   'nytimes.com',
 23 |   'wsj.com',
 24 |   'bloomberg.com',
 25 |   'washingtonpost.com',
 26 |   'reddit.com',
 27 |   'instagram.com',
 28 |   'stackoverflow.com',
 29 |   'apple.com',
 30 |   'google.com',
 31 |   'docs.google.com',
 32 |   'drive.google.com',
 33 |   'amazon.com',
 34 |   'notion.so',
 35 |   'figma.com',
 36 |   'dropbox.com',
 37 |   'pinterest.com',
 38 |   'tumblr.com',
 39 |   'quora.com',
 40 |   'substack.com',
 41 | ]);
 42 | 
 43 | /**
 44 |  * Check if a domain blocks iframe embedding
 45 |  */
 46 | function isIframeBlocked(domain: string | undefined): boolean {
 47 |   if (!domain) return false;
 48 |   const lowerDomain = domain.toLowerCase();
 49 |   // Check exact match or subdomain match
 50 |   for (const blocked of IFRAME_BLOCKED_DOMAINS) {
 51 |     if (lowerDomain === blocked || lowerDomain.endsWith('.' + blocked)) {
 52 |       return true;
 53 |     }
 54 |   }
 55 |   return false;
 56 | }
 57 | 
 58 | export interface HNStory {
 59 |   id: number;
 60 |   title: string;
 61 |   url: string;
 62 |   discussionUrl: string;
 63 |   score: number;
 64 |   descendants: number;
 65 |   domain?: string;
 66 |   timeAgo: string;
 67 | }
 68 | 
 69 | export type HNFeedStatus = 'idle' | 'loading' | 'error';
 70 | 
 71 | /**
 72 |  * Render a single HN story item
 73 |  */
 74 | function renderHNStory(story: HNStory): string {
 75 |   const isBlocked = isIframeBlocked(story.domain);
 76 |   const externalIndicator = isBlocked
 77 |     ? '<span class="hn-external-indicator" title="Opens in browser">↗</span>'
 78 |     : '';
 79 |   const domainDisplay = story.domain
 80 |     ? `<span class="hn-story-domain">(${escapeHtml(story.domain)})${externalIndicator}</span>`
 81 |     : '';
 82 |   const storyUrl = story.url || story.discussionUrl;
 83 |   // Escape title for use in onclick attribute (escape both HTML and quotes)
 84 |   const escapedTitleForAttr = escapeHtml(story.title).replace(/'/g, "\\'");
 85 | 
 86 |   // For blocked domains, open directly in browser instead of webview
 87 |   const clickHandler = isBlocked
 88 |     ? `openHNStoryExternal('${escapeHtml(storyUrl)}')`
 89 |     : `openHNStory('${escapeHtml(storyUrl)}', '${escapedTitleForAttr}')`;
 90 | 
 91 |   return `
 92 |     <div class="hn-story${isBlocked ? ' hn-story-external' : ''}">
 93 |       <span class="hn-story-title" onclick="${clickHandler}" title="${escapeHtml(story.title)}">
 94 |         ${escapeHtml(story.title)}
 95 |       </span>
 96 |       <div class="hn-story-meta">
 97 |         <span class="hn-story-score">▲ ${story.score}</span>
 98 |         <span class="hn-story-comments" onclick="openHNStory('${escapeHtml(story.discussionUrl)}', '${escapedTitleForAttr} - HN Discussion')">
 99 |           💬 ${story.descendants} comments
100 |         </span>
101 |         ${domainDisplay}
102 |         <span class="hn-story-time">${escapeHtml(story.timeAgo)}</span>
103 |       </div>
104 |     </div>
105 |   `;
106 | }
107 | 
108 | /**
109 |  * Render the complete HN feed with header and stories
110 |  */
111 | export function renderHNFeed(
112 |   stories: HNStory[],
113 |   status: HNFeedStatus,
114 |   error: string | null,
115 |   hasMore: boolean = true,
116 |   loadingMore: boolean = false
117 | ): string {
118 |   const isLoading = status === 'loading';
119 | 
120 |   let content = '';
121 | 
122 |   if (status === 'loading') {
123 |     content = `
124 |       <div class="hn-loading">
125 |         <div class="hn-loading-spinner"></div>
126 |         <div>Loading stories...</div>
127 |       </div>
128 |     `;
129 |   } else if (status === 'error') {
130 |     content = `
131 |       <div class="hn-error">
132 |         <div class="hn-error-icon">⚠️</div>
133 |         <div class="hn-error-message">${escapeHtml(error || 'Failed to load stories')}</div>
134 |         <div class="hn-error-retry">
135 |           <button class="hn-refresh-btn" onclick="refreshHNFeed()">
136 |             <span class="refresh-icon">↻</span> Retry
137 |           </button>
138 |         </div>
139 |       </div>
140 |     `;
141 |   } else if (!stories || stories.length === 0) {
142 |     content = `
143 |       <div class="hn-empty">
144 |         <div>No stories available</div>
145 |         <button class="hn-refresh-btn" onclick="refreshHNFeed()">
146 |           <span class="refresh-icon">↻</span> Load Stories
147 |         </button>
148 |       </div>
149 |     `;
150 |   } else {
151 |     const loadMoreHtml = hasMore
152 |       ? `<div class="hn-load-more">
153 |           <button class="hn-load-more-btn ${loadingMore ? 'loading' : ''}" onclick="loadMoreHNFeed()" ${loadingMore ? 'disabled' : ''}>
154 |             ${loadingMore ? '<span class="hn-loading-spinner-small"></span> Loading...' : 'Load More'}
155 |           </button>
156 |         </div>`
157 |       : '<div class="hn-end-of-list">No more stories</div>';
158 | 
159 |     content = `
160 |       <div class="hn-story-list" id="hn-story-list">
161 |         ${stories.map((story) => renderHNStory(story)).join('')}
162 |         ${loadMoreHtml}
163 |       </div>
164 |     `;
165 |   }
166 | 
167 |   return `
168 |     <div class="hn-feed">
169 |       <div class="hn-feed-header">
170 |         <div class="hn-feed-title">
171 |           <span class="hn-icon">Y</span>
172 |           <span>Hacker News</span>
173 |         </div>
174 |         <button class="hn-refresh-btn ${isLoading ? 'loading' : ''}" onclick="refreshHNFeed()" ${isLoading ? 'disabled' : ''}>
175 |           <span class="refresh-icon">↻</span> Refresh
176 |         </button>
177 |       </div>
178 |       ${content}
179 |     </div>
180 |   `;
181 | }
182 | 
183 | interface VSCodeAPI {
184 |   postMessage(message: unknown): void;
185 | }
186 | 
187 | /**
188 |  * Setup HN feed event handlers
189 |  * These are global window functions called from onclick attributes
190 |  */
191 | export function setupHNFeedHandlers(vscode: VSCodeAPI): void {
192 |   (window as unknown as Record<string, unknown>).refreshHNFeed = function () {
193 |     vscode.postMessage({ type: 'refreshHNFeed' });
194 |   };
195 | 
196 |   (window as unknown as Record<string, unknown>).loadMoreHNFeed = function () {
197 |     vscode.postMessage({ type: 'loadMoreHNFeed' });
198 |   };
199 | 
200 |   (window as unknown as Record<string, unknown>).toggleFeed = function () {
201 |     vscode.postMessage({ type: 'toggleFeed' });
202 |   };
203 | 
204 |   (window as unknown as Record<string, unknown>).openHNStory = function (
205 |     url: string,
206 |     title: string
207 |   ) {
208 |     if (url) {
209 |       vscode.postMessage({
210 |         type: 'openHNStoryInPanel',
211 |         url: url,
212 |         title: title || 'HN Story',
213 |       });
214 |     }
215 |   };
216 | 
217 |   (window as unknown as Record<string, unknown>).openHNStoryExternal =
218 |     function (url: string) {
219 |       if (url) {
220 |         vscode.postMessage({
221 |           type: 'openContentExternal',
222 |           url: url,
223 |         });
224 |       }
225 |     };
226 | 
227 |   (window as unknown as Record<string, unknown>).openHNComments = function (
228 |     storyId: number
229 |   ) {
230 |     vscode.postMessage({ type: 'openHNComments', storyId: storyId });
231 |   };
232 | }
233 | 


--------------------------------------------------------------------------------