tmux-team 3.0.0 → 3.1.0

package/src/tmux.ts

@@ -1,9 +1,30 @@
 // ─────────────────────────────────────────────────────────────
-// Pure tmux wrapper - send-keys, capture-pane
+// Pure tmux wrapper - send-keys, capture-pane, pane detection
 // ─────────────────────────────────────────────────────────────
 
 import { execSync } from 'child_process';
-import type { Tmux } from './types.js';
+import type { Tmux, PaneInfo } from './types.js';
+
+// Known agent patterns for auto-detection
+const KNOWN_AGENTS: Record<string, string[]> = {
+  claude: ['claude', 'claude-code'],
+  codex: ['codex'],
+  gemini: ['gemini'],
+  aider: ['aider'],
+  cursor: ['cursor'],
+};
+
+function detectAgentName(command: string): string | null {
+  const lowerCommand = command.toLowerCase();
+  for (const [agentName, patterns] of Object.entries(KNOWN_AGENTS)) {
+    for (const pattern of patterns) {
+      if (lowerCommand.includes(pattern)) {
+        return agentName;
+      }
+    }
+  }
+  return null;
+}
 
 export function createTmux(): Tmux {
   return {
@@ -23,5 +44,48 @@ export function createTmux(): Tmux {
       });
       return output;
     },
+
+    listPanes(): PaneInfo[] {
+      try {
+        // Get all panes with their IDs and current commands
+        const output = execSync('tmux list-panes -a -F "#{pane_id}\t#{pane_current_command}"', {
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+
+        return output
+          .trim()
+          .split('\n')
+          .filter((line) => line.trim())
+          .map((line) => {
+            const [id, command] = line.split('\t');
+            return {
+              id: id || '',
+              command: command || '',
+              suggestedName: detectAgentName(command || ''),
+            };
+          });
+      } catch {
+        return [];
+      }
+    },
+
+    getCurrentPaneId(): string | null {
+      // First check environment variable
+      if (process.env.TMUX_PANE) {
+        return process.env.TMUX_PANE;
+      }
+
+      // Fall back to tmux command
+      try {
+        const output = execSync('tmux display-message -p "#{pane_id}"', {
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return output.trim() || null;
+      } catch {
+        return null;
+      }
+    },
   };
 }

package/src/types.ts

@@ -53,11 +53,13 @@ export interface ResolvedConfig {
 export interface Flags {
   json: boolean;
   verbose: boolean;
+  debug?: boolean;
   config?: string;
   force?: boolean;
   delay?: number; // seconds
   wait?: boolean;
   timeout?: number; // seconds
+  lines?: number; // lines to capture before end marker
   noPreamble?: boolean;
 }
 
@@ -77,15 +79,22 @@ export interface UI {
   json: (data: unknown) => void;
 }
 
+export interface PaneInfo {
+  id: string; // e.g., "%1"
+  command: string; // e.g., "node", "python", "zsh"
+  suggestedName: string | null; // e.g., "codex" if detected from command
+}
+
 export interface Tmux {
   send: (paneId: string, message: string) => void;
   capture: (paneId: string, lines: number) => string;
+  listPanes: () => PaneInfo[];
+  getCurrentPaneId: () => string | null;
 }
 
 export interface WaitResult {
   requestId: string;
   nonce: string;
-  startMarker: string;
   endMarker: string;
   response: string;
 }

package/src/ui.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+describe('ui', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('createUI(jsonMode=true) suppresses human output and emits JSON errors', async () => {
+    vi.resetModules();
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const { createUI } = await import('./ui.js');
+    const ui = createUI(true);
+
+    ui.info('x');
+    ui.success('x');
+    ui.warn('x');
+    ui.table(['A'], [['B']]);
+    expect(logSpy).not.toHaveBeenCalled();
+
+    ui.error('boom');
+    expect(errSpy).toHaveBeenCalledWith(JSON.stringify({ error: 'boom' }));
+
+    ui.json({ ok: true });
+    expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ ok: true }, null, 2));
+  });
+
+  it('createUI(jsonMode=false) prints messages and table', async () => {
+    vi.resetModules();
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const { createUI } = await import('./ui.js');
+    const ui = createUI(false);
+
+    ui.info('hello');
+    ui.success('ok');
+    ui.warn('warn');
+    ui.error('err');
+
+    expect(logSpy).toHaveBeenCalled();
+    expect(errSpy).toHaveBeenCalled();
+
+    logSpy.mockClear();
+    ui.table(
+      ['Name', 'Pane'],
+      [
+        ['claude', '1.0'],
+        ['codex', '1.1'],
+      ]
+    );
+    const output = logSpy.mock.calls.map((c) => String(c[0])).join('\n');
+    expect(output).toContain('Name');
+    expect(output).toContain('Pane');
+    expect(output).toContain('claude');
+    expect(output).toContain('1.0');
+  });
+});

package/src/version.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+describe('version', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('reads VERSION from package.json when possible', async () => {
+    vi.resetModules();
+    const { VERSION } = await import('./version.js');
+    expect(typeof VERSION).toBe('string');
+    expect(VERSION.length).toBeGreaterThan(0);
+  });
+
+  it('falls back to hardcoded version when package.json read fails', async () => {
+    vi.resetModules();
+    vi.doMock('fs', () => ({
+      default: {
+        readFileSync: () => {
+          throw new Error('read fail');
+        },
+      },
+      readFileSync: () => {
+        throw new Error('read fail');
+      },
+    }));
+
+    const { VERSION } = await import('./version.js');
+    expect(VERSION).toBe('3.0.1');
+  });
+});

package/src/version.ts

@@ -14,7 +14,7 @@ function getVersion(): string {
     const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
     return pkg.version;
   } catch {
-    return '3.0.0';
+    return '3.0.1';
   }
 }
 

package/src/commands/install-skill.ts

@@ -1,148 +0,0 @@
-// ─────────────────────────────────────────────────────────────
-// install-skill command - install tmux-team skills for AI agents
-// ─────────────────────────────────────────────────────────────
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { fileURLToPath } from 'node:url';
-import type { Context } from '../types.js';
-import { ExitCodes } from '../context.js';
-
-type AgentType = 'claude' | 'codex';
-type Scope = 'user' | 'local';
-
-interface SkillConfig {
-  sourceFile: string;
-  userDir: string;
-  localDir: string;
-  targetFile: string;
-}
-
-function getCodexHome(): string {
-  return process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
-}
-
-const SKILL_CONFIGS: Record<AgentType, SkillConfig> = {
-  claude: {
-    sourceFile: 'skills/claude/team.md',
-    userDir: path.join(os.homedir(), '.claude', 'commands'),
-    localDir: '.claude/commands',
-    targetFile: 'team.md',
-  },
-  codex: {
-    sourceFile: 'skills/codex/SKILL.md',
-    userDir: path.join(getCodexHome(), 'skills', 'tmux-team'),
-    localDir: '.codex/skills/tmux-team',
-    targetFile: 'SKILL.md',
-  },
-};
-
-const SUPPORTED_AGENTS = Object.keys(SKILL_CONFIGS) as AgentType[];
-
-function findPackageRoot(): string {
-  // Get current file's directory (ES modules don't have __dirname)
-  const currentFile = fileURLToPath(import.meta.url);
-  let dir = path.dirname(currentFile);
-
-  // Try to find the package root by looking for package.json
-  for (let i = 0; i < 5; i++) {
-    const pkgPath = path.join(dir, 'package.json');
-    if (fs.existsSync(pkgPath)) {
-      return dir;
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  // Fallback: assume we're in src/commands
-  return path.resolve(path.dirname(currentFile), '..', '..');
-}
-
-function exitWithError(ctx: Context, error: string, hint?: string): never {
-  if (ctx.flags.json) {
-    ctx.ui.json({ success: false, error, hint });
-  } else {
-    ctx.ui.error(error);
-    if (hint) ctx.ui.info(hint);
-  }
-  ctx.exit(ExitCodes.ERROR);
-}
-
-export function cmdInstallSkill(ctx: Context, agent?: string, scope: string = 'user'): void {
-  // Validate agent
-  if (!agent) {
-    exitWithError(
-      ctx,
-      'Usage: tmux-team install-skill <agent> [--local|--user]',
-      `Supported agents: ${SUPPORTED_AGENTS.join(', ')}`
-    );
-  }
-
-  const agentLower = agent.toLowerCase() as AgentType;
-  if (!SUPPORTED_AGENTS.includes(agentLower)) {
-    exitWithError(
-      ctx,
-      `Unknown agent: ${agent}`,
-      `Supported agents: ${SUPPORTED_AGENTS.join(', ')}`
-    );
-  }
-
-  // Validate scope
-  const scopeLower = scope.toLowerCase() as Scope;
-  if (scopeLower !== 'user' && scopeLower !== 'local') {
-    exitWithError(ctx, `Invalid scope: ${scope}. Use 'user' or 'local'.`);
-  }
-
-  const config = SKILL_CONFIGS[agentLower];
-  const pkgRoot = findPackageRoot();
-  const sourcePath = path.join(pkgRoot, config.sourceFile);
-
-  // Check source file exists
-  if (!fs.existsSync(sourcePath)) {
-    exitWithError(
-      ctx,
-      `Skill file not found: ${sourcePath}`,
-      'Make sure tmux-team is properly installed.'
-    );
-  }
-
-  // Determine target directory
-  const targetDir = scopeLower === 'user' ? config.userDir : path.resolve(config.localDir);
-  const targetPath = path.join(targetDir, config.targetFile);
-
-  // Check if already exists
-  if (fs.existsSync(targetPath) && !ctx.flags.force) {
-    exitWithError(ctx, `Skill already exists: ${targetPath}`, 'Use --force to overwrite.');
-  }
-
-  // Create directory if needed
-  if (!fs.existsSync(targetDir)) {
-    fs.mkdirSync(targetDir, { recursive: true });
-    if (ctx.flags.verbose) {
-      ctx.ui.info(`Created directory: ${targetDir}`);
-    }
-  }
-
-  // Copy file
-  fs.copyFileSync(sourcePath, targetPath);
-
-  if (ctx.flags.json) {
-    ctx.ui.json({
-      success: true,
-      agent: agentLower,
-      scope: scopeLower,
-      path: targetPath,
-    });
-  } else {
-    ctx.ui.success(`Installed ${agentLower} skill to ${targetPath}`);
-
-    // Show usage hint
-    if (agentLower === 'claude') {
-      ctx.ui.info('Usage: /team talk codex "message"');
-    } else if (agentLower === 'codex') {
-      ctx.ui.info('Enable skills: codex --enable skills');
-      ctx.ui.info('Usage: $tmux-team or implicit invocation');
-    }
-  }
-}