tmux-team 2.2.0 → 3.0.0-alpha.2

package/src/commands/config.ts

@@ -15,13 +15,11 @@ import {
 
 type EnumConfigKey = 'mode' | 'preambleMode';
 type NumericConfigKey = 'preambleEvery';
-type BoolConfigKey = 'hideOrphanTasks';
-type ConfigKey = EnumConfigKey | NumericConfigKey | BoolConfigKey;
+type ConfigKey = EnumConfigKey | NumericConfigKey;
 
 const ENUM_KEYS: EnumConfigKey[] = ['mode', 'preambleMode'];
 const NUMERIC_KEYS: NumericConfigKey[] = ['preambleEvery'];
-const BOOL_KEYS: BoolConfigKey[] = ['hideOrphanTasks'];
-const VALID_KEYS: ConfigKey[] = [...ENUM_KEYS, ...NUMERIC_KEYS, ...BOOL_KEYS];
+const VALID_KEYS: ConfigKey[] = [...ENUM_KEYS, ...NUMERIC_KEYS];
 
 const VALID_VALUES: Record<EnumConfigKey, string[]> = {
   mode: ['polling', 'wait'],
@@ -40,10 +38,6 @@ function isNumericKey(key: ConfigKey): key is NumericConfigKey {
   return NUMERIC_KEYS.includes(key as NumericConfigKey);
 }
 
-function isBoolKey(key: ConfigKey): key is BoolConfigKey {
-  return BOOL_KEYS.includes(key as BoolConfigKey);
-}
-
 function isValidValue(key: EnumConfigKey, value: string): boolean {
   return VALID_VALUES[key].includes(value);
 }
@@ -62,7 +56,6 @@ function showConfig(ctx: Context): void {
         mode: ctx.config.mode,
         preambleMode: ctx.config.preambleMode,
         preambleEvery: ctx.config.defaults.preambleEvery,
-        hideOrphanTasks: ctx.config.defaults.hideOrphanTasks,
         defaults: ctx.config.defaults,
       },
       sources: {
@@ -78,8 +71,6 @@ function showConfig(ctx: Context): void {
             : globalConfig.defaults?.preambleEvery !== undefined
               ? 'global'
               : 'default',
-        hideOrphanTasks:
-          globalConfig.defaults?.hideOrphanTasks !== undefined ? 'global' : 'default',
       },
       paths: {
         global: ctx.paths.globalConfig,
@@ -102,8 +93,6 @@ function showConfig(ctx: Context): void {
       : globalConfig.defaults?.preambleEvery !== undefined
         ? '(global)'
         : '(default)';
-  const hideOrphanSource =
-    globalConfig.defaults?.hideOrphanTasks !== undefined ? '(global)' : '(default)';
 
   ctx.ui.info('Current configuration:\n');
   ctx.ui.table(
@@ -112,7 +101,6 @@ function showConfig(ctx: Context): void {
       ['mode', ctx.config.mode, modeSource],
       ['preambleMode', ctx.config.preambleMode, preambleSource],
       ['preambleEvery', String(ctx.config.defaults.preambleEvery), preambleEverySource],
-      ['hideOrphanTasks', String(ctx.config.defaults.hideOrphanTasks), hideOrphanSource],
       ['defaults.timeout', String(ctx.config.defaults.timeout), '(global)'],
       ['defaults.pollInterval', String(ctx.config.defaults.pollInterval), '(global)'],
       ['defaults.captureLines', String(ctx.config.defaults.captureLines), '(global)'],
@@ -154,31 +142,6 @@ function setConfig(ctx: Context, key: string, value: string, global: boolean): v
     }
   }
 
-  if (isBoolKey(validKey)) {
-    if (value !== 'true' && value !== 'false') {
-      ctx.ui.error(`Invalid value for ${key}: ${value}. Use true or false.`);
-      ctx.exit(ExitCodes.ERROR);
-    }
-  }
-
-  if (key === 'hideOrphanTasks') {
-    const globalConfig = loadGlobalConfig(ctx.paths);
-    if (!globalConfig.defaults) {
-      globalConfig.defaults = {
-        timeout: 180,
-        pollInterval: 1,
-        captureLines: 100,
-        preambleEvery: ctx.config.defaults.preambleEvery,
-        hideOrphanTasks: value === 'true',
-      };
-    } else {
-      globalConfig.defaults.hideOrphanTasks = value === 'true';
-    }
-    saveGlobalConfig(ctx.paths, globalConfig);
-    ctx.ui.success(`Set ${key}=${value} in global config`);
-    return;
-  }
-
   if (global) {
     // Set in global config
     const globalConfig = loadGlobalConfig(ctx.paths);
@@ -193,7 +156,6 @@ function setConfig(ctx: Context, key: string, value: string, global: boolean): v
           pollInterval: 1,
           captureLines: 100,
           preambleEvery: parseInt(value, 10),
-          hideOrphanTasks: ctx.config.defaults.hideOrphanTasks,
         };
       } else {
         globalConfig.defaults.preambleEvery = parseInt(value, 10);
@@ -223,10 +185,6 @@ function clearConfig(ctx: Context, key?: string): void {
       ctx.ui.error(`Invalid key: ${key}. Valid keys: ${VALID_KEYS.join(', ')}`);
       ctx.exit(ExitCodes.ERROR);
     }
-    if (key === 'hideOrphanTasks') {
-      ctx.ui.error(`Cannot clear global-only key: ${key}. Edit global config instead.`);
-      ctx.exit(ExitCodes.ERROR);
-    }
 
     // Clear specific key from local settings
     const localConfigFile = loadLocalConfigFile(ctx.paths);

package/src/commands/help.ts

@@ -42,7 +42,7 @@ ${colors.yellow('COMMANDS')}
   ${colors.green('init')}                        Create empty tmux-team.json
   ${colors.green('config')} [show|set|clear]     View/modify settings
   ${colors.green('preamble')} [show|set|clear]   Manage agent preambles
-  ${colors.green('pm')} <subcommand>             Project management (run 'pm help')
+  ${colors.green('install-skill')} <agent>       Install skill for AI agent
   ${colors.green('completion')}                  Output shell completion script
   ${colors.green('help')}                        Show this help message
 
@@ -80,6 +80,5 @@ ${colors.yellow('CHANGE MODE')}
   tmux-team config set mode polling         ${colors.dim('Enable polling mode (local)')}
   tmux-team config set preambleMode disabled ${colors.dim('Disable preambles (local)')}
   tmux-team config set preambleEvery 5      ${colors.dim('Inject preamble every 5 messages')}
-  tmux-team config set hideOrphanTasks true ${colors.dim('Hide tasks without milestones (global)')}
 `);
 }

package/src/commands/install-skill.ts

@@ -0,0 +1,148 @@
+// ─────────────────────────────────────────────────────────────
+// 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');
+    }
+  }
+}