ccmanager 3.6.11 → 3.7.0

package/dist/components/ConfigureCommand.js

@@ -21,6 +21,7 @@ const createStrategyItems = () => {
         },
         cline: { label: 'Cline', value: 'cline' },
         opencode: { label: 'OpenCode', value: 'opencode' },
+        kimi: { label: 'Kimi', value: 'kimi' },
     };
     return Object.values(strategies);
 };
@@ -35,6 +36,7 @@ const DEFAULT_COMMANDS = {
     'github-copilot': 'copilot',
     cline: 'cline',
     opencode: 'opencode',
+    kimi: 'kimi',
 };
 const formatDetectionStrategy = (strategy) => {
     const value = strategy || 'claude';
@@ -51,6 +53,8 @@ const formatDetectionStrategy = (strategy) => {
             return 'Cline';
         case 'opencode':
             return 'OpenCode';
+        case 'kimi':
+            return 'Kimi';
         default:
             return 'Claude';
     }

package/dist/services/stateDetector/claude.js

@@ -1,16 +1,18 @@
 import { BaseStateDetector } from './base.js';
 export class ClaudeStateDetector extends BaseStateDetector {
     detectState(terminal, currentState) {
-        const content = this.getTerminalContent(terminal);
+        // Check for search prompt (⌕ Search…) within 200 lines - always idle
+        const extendedContent = this.getTerminalContent(terminal, 200);
+        if (extendedContent.includes('⌕ Search…')) {
+            return 'idle';
+        }
+        // Existing logic with 30 lines
+        const content = this.getTerminalContent(terminal, 30);
         const lowerContent = content.toLowerCase();
         // Check for ctrl+r toggle prompt - maintain current state
         if (lowerContent.includes('ctrl+r to toggle')) {
             return currentState;
         }
-        // Check for search prompt (⌕ Search…) - always idle
-        if (content.includes('⌕ Search…')) {
-            return 'idle';
-        }
         // Check for "Do you want" or "Would you like" pattern with options
         // Handles both simple ("Do you want...\nYes") and complex (numbered options) formats
         if (/(?:do you want|would you like).+\n+[\s\S]*?(?:yes|❯)/.test(lowerContent)) {

package/dist/services/stateDetector/cline.js

@@ -2,7 +2,7 @@ import { BaseStateDetector } from './base.js';
 // https://github.com/cline/cline/blob/580db36476b6b52def03c8aeda325aae1c817cde/cli/pkg/cli/task/input_handler.go
 export class ClineStateDetector extends BaseStateDetector {
     detectState(terminal, _currentState) {
-        const content = this.getTerminalContent(terminal);
+        const content = this.getTerminalContent(terminal, 30);
         const lowerContent = content.toLowerCase();
         // Check for waiting prompts with tool permission - Priority 1
         // Pattern: [\[act|plan\] mode].*?\n.*yes (when mode indicator present)

package/dist/services/stateDetector/codex.js

@@ -1,7 +1,7 @@
 import { BaseStateDetector } from './base.js';
 export class CodexStateDetector extends BaseStateDetector {
     detectState(terminal, _currentState) {
-        const content = this.getTerminalContent(terminal);
+        const content = this.getTerminalContent(terminal, 30);
         const lowerContent = content.toLowerCase();
         // Check for confirmation prompt patterns - highest priority
         if (lowerContent.includes('press enter to confirm or esc to cancel') ||

package/dist/services/stateDetector/cursor.js

@@ -1,7 +1,7 @@
 import { BaseStateDetector } from './base.js';
 export class CursorStateDetector extends BaseStateDetector {
     detectState(terminal, _currentState) {
-        const content = this.getTerminalContent(terminal);
+        const content = this.getTerminalContent(terminal, 30);
         const lowerContent = content.toLowerCase();
         // Check for waiting prompts - Priority 1
         if (lowerContent.includes('(y) (enter)') ||

package/dist/services/stateDetector/gemini.js

@@ -2,7 +2,7 @@ import { BaseStateDetector } from './base.js';
 // https://github.com/google-gemini/gemini-cli/blob/main/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
 export class GeminiStateDetector extends BaseStateDetector {
     detectState(terminal, _currentState) {
-        const content = this.getTerminalContent(terminal);
+        const content = this.getTerminalContent(terminal, 30);
         const lowerContent = content.toLowerCase();
         // Check for explicit user confirmation message - highest priority
         if (lowerContent.includes('waiting for user confirmation')) {

package/dist/services/stateDetector/github-copilot.js

@@ -1,7 +1,7 @@
 import { BaseStateDetector } from './base.js';
 export class GitHubCopilotStateDetector extends BaseStateDetector {
     detectState(terminal, _currentState) {
-        const content = this.getTerminalContent(terminal);
+        const content = this.getTerminalContent(terminal, 30);
         const lowerContent = content.toLowerCase();
         // Check for confirmation prompt pattern - highest priority
         if (/confirm with .+ enter/i.test(content)) {

package/dist/services/stateDetector/index.js

@@ -5,6 +5,7 @@ import { CursorStateDetector } from './cursor.js';
 import { GitHubCopilotStateDetector } from './github-copilot.js';
 import { ClineStateDetector } from './cline.js';
 import { OpenCodeStateDetector } from './opencode.js';
+import { KimiStateDetector } from './kimi.js';
 export function createStateDetector(strategy = 'claude') {
     switch (strategy) {
         case 'claude':
@@ -21,6 +22,8 @@ export function createStateDetector(strategy = 'claude') {
             return new ClineStateDetector();
         case 'opencode':
             return new OpenCodeStateDetector();
+        case 'kimi':
+            return new KimiStateDetector();
         default:
             return new ClaudeStateDetector();
     }

package/dist/services/stateDetector/kimi.d.ts

@@ -0,0 +1,12 @@
+import { SessionState, Terminal } from '../../types/index.js';
+import { BaseStateDetector } from './base.js';
+/**
+ * State detector for Kimi CLI (kimi-cli).
+ * Kimi CLI is an AI coding assistant by Moonshot AI.
+ * Command: kimi
+ * Installation: uv tool install --python 3.13 kimi-cli
+ */
+export declare class KimiStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+    detectBackgroundTask(_terminal: Terminal): number;
+}

package/dist/services/stateDetector/kimi.js

@@ -0,0 +1,44 @@
+import { BaseStateDetector } from './base.js';
+/**
+ * State detector for Kimi CLI (kimi-cli).
+ * Kimi CLI is an AI coding assistant by Moonshot AI.
+ * Command: kimi
+ * Installation: uv tool install --python 3.13 kimi-cli
+ */
+export class KimiStateDetector extends BaseStateDetector {
+    detectState(terminal, _currentState) {
+        const content = this.getTerminalContent(terminal);
+        const lowerContent = content.toLowerCase();
+        // Check for permission/confirmation prompts - waiting_input state
+        // Kimi CLI uses prompts like "Allow?", "Confirm?", "Yes/No" patterns
+        if (lowerContent.includes('allow?') ||
+            lowerContent.includes('confirm?') ||
+            lowerContent.includes('approve?') ||
+            lowerContent.includes('proceed?')) {
+            return 'waiting_input';
+        }
+        // Check for Yes/No option patterns
+        if (/\[y\/n\]/.test(lowerContent) || /\(y\/n\)/.test(lowerContent)) {
+            return 'waiting_input';
+        }
+        // Check for busy state - processing indicators
+        if (lowerContent.includes('thinking') ||
+            lowerContent.includes('processing') ||
+            lowerContent.includes('generating') ||
+            lowerContent.includes('waiting for response')) {
+            return 'busy';
+        }
+        // Check for common interrupt patterns
+        if (lowerContent.includes('ctrl+c to cancel') ||
+            lowerContent.includes('ctrl-c to cancel') ||
+            lowerContent.includes('press ctrl+c')) {
+            return 'busy';
+        }
+        // Otherwise idle
+        return 'idle';
+    }
+    detectBackgroundTask(_terminal) {
+        // Kimi CLI does not currently support background tasks
+        return 0;
+    }
+}

package/dist/services/stateDetector/kimi.test.d.ts

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

package/dist/services/stateDetector/kimi.test.js

@@ -0,0 +1,195 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { KimiStateDetector } from './kimi.js';
+import { createMockTerminal } from './testUtils.js';
+describe('KimiStateDetector', () => {
+    let detector;
+    let terminal;
+    beforeEach(() => {
+        detector = new KimiStateDetector();
+    });
+    describe('detectState', () => {
+        it('should detect idle when no specific patterns are found', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Command completed successfully',
+                'Ready for next command',
+                '> ',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('idle');
+        });
+        it('should handle empty terminal', () => {
+            // Arrange
+            terminal = createMockTerminal([]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('idle');
+        });
+        it('should detect waiting_input when "Allow?" prompt is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Kimi wants to execute a command',
+                'Allow?',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "Confirm?" prompt is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'About to make changes to file.ts',
+                'Confirm?',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "Approve?" prompt is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Requesting permission to modify config',
+                'Approve?',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "Proceed?" prompt is present', () => {
+            // Arrange
+            terminal = createMockTerminal(['Ready to execute action', 'Proceed?']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "[y/n]" pattern is present', () => {
+            // Arrange
+            terminal = createMockTerminal(['Do you want to continue? [y/n]', '> ']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "(y/n)" pattern is present', () => {
+            // Arrange
+            terminal = createMockTerminal(['Apply changes? (y/n)', '> ']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect busy when "thinking" is present', () => {
+            // Arrange
+            terminal = createMockTerminal(['Processing your request...', 'thinking']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect busy when "processing" is present', () => {
+            // Arrange
+            terminal = createMockTerminal(['Analyzing code...', 'processing']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect busy when "generating" is present', () => {
+            // Arrange
+            terminal = createMockTerminal(['Working on solution...', 'generating']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect busy when "waiting for response" is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Request sent',
+                'waiting for response from API',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect busy when "ctrl+c to cancel" is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Running task...',
+                'Press ctrl+c to cancel',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect busy when "ctrl-c to cancel" is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Executing command...',
+                'ctrl-c to cancel',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect busy when "press ctrl+c" is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Working...',
+                'Press Ctrl+C to stop the operation',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect patterns case-insensitively', () => {
+            // Arrange
+            terminal = createMockTerminal(['THINKING about the problem...']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should prioritize waiting_input over busy when both patterns present', () => {
+            // Arrange
+            terminal = createMockTerminal(['Processing...', 'thinking', 'Allow?']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+    });
+    describe('detectBackgroundTask', () => {
+        it('should return 0 as Kimi CLI does not support background tasks', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Some output',
+                'More output',
+                'Status bar',
+            ]);
+            // Act
+            const count = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(count).toBe(0);
+        });
+        it('should return 0 for empty terminal', () => {
+            // Arrange
+            terminal = createMockTerminal([]);
+            // Act
+            const count = detector.detectBackgroundTask(terminal);
+            // Assert
+            expect(count).toBe(0);
+        });
+    });
+});

package/dist/services/stateDetector/opencode.js

@@ -1,7 +1,7 @@
 import { BaseStateDetector } from './base.js';
 export class OpenCodeStateDetector extends BaseStateDetector {
     detectState(terminal, _currentState) {
-        const content = this.getTerminalContent(terminal);
+        const content = this.getTerminalContent(terminal, 30);
         // Check for waiting input state - permission required prompt
         // The triangle symbol (△) indicates permission is required
         if (content.includes('△ Permission required')) {

package/dist/types/index.d.ts

@@ -5,7 +5,7 @@ import { Mutex, SessionStateData } from '../utils/mutex.js';
 import type { StateDetector } from '../services/stateDetector/types.js';
 export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input' | 'pending_auto_approval';
-export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor' | 'github-copilot' | 'cline' | 'opencode';
+export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor' | 'github-copilot' | 'cline' | 'opencode' | 'kimi';
 export interface Worktree {
     path: string;
     branch?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.6.11",
+	"version": "3.7.0",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "3.6.11",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.6.11",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.6.11",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.6.11",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.6.11"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.7.0",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.7.0",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.7.0",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.7.0",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.7.0"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",