tmux-team 2.0.0-alpha.1 → 2.0.0-alpha.3

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "tmux-team",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.3",
   "description": "CLI tool for AI agent collaboration in tmux - manage cross-pane communication",
   "type": "module",
   "bin": {
-    "tmux-team": "./bin/tmux-team"
+    "tmux-team": "./bin/tmux-team",
+    "tmt": "./bin/tmux-team"
   },
   "scripts": {
     "dev": "tsx src/cli.ts",
+    "tmt": "./bin/tmux-team",
     "test": "vitest",
     "test:run": "vitest run",
     "lint": "oxlint src/",

package/src/cli.ts

@@ -17,6 +17,8 @@ import { cmdTalk } from './commands/talk.js';
 import { cmdCheck } from './commands/check.js';
 import { cmdCompletion } from './commands/completion.js';
 import { cmdPm } from './pm/commands.js';
+import { cmdConfig } from './commands/config.js';
+import { cmdPreamble } from './commands/preamble.js';
 
 // ─────────────────────────────────────────────────────────────
 // Argument parsing
@@ -193,6 +195,14 @@ function main(): void {
         await cmdPm(ctx, args);
         break;
 
+      case 'config':
+        cmdConfig(ctx, args);
+        break;
+
+      case 'preamble':
+        cmdPreamble(ctx, args);
+        break;
+
       default:
         ctx.ui.error(`Unknown command: ${command}. Run 'tmux-team help' for usage.`);
         ctx.exit(ExitCodes.ERROR);

package/src/commands/config.ts

@@ -0,0 +1,187 @@
+// ─────────────────────────────────────────────────────────────
+// Config command - view and modify settings
+// ─────────────────────────────────────────────────────────────
+
+import type { Context } from '../types.js';
+import { ExitCodes } from '../context.js';
+import {
+  loadGlobalConfig,
+  saveGlobalConfig,
+  loadLocalConfigFile,
+  saveLocalConfigFile,
+  updateLocalSettings,
+  clearLocalSettings,
+} from '../config.js';
+
+type ConfigKey = 'mode' | 'preambleMode';
+
+const VALID_KEYS: ConfigKey[] = ['mode', 'preambleMode'];
+
+const VALID_VALUES: Record<ConfigKey, string[]> = {
+  mode: ['polling', 'wait'],
+  preambleMode: ['always', 'disabled'],
+};
+
+function isValidKey(key: string): key is ConfigKey {
+  return VALID_KEYS.includes(key as ConfigKey);
+}
+
+function isValidValue(key: ConfigKey, value: string): boolean {
+  return VALID_VALUES[key].includes(value);
+}
+
+/**
+ * Show resolved config with source indicators.
+ */
+function showConfig(ctx: Context): void {
+  const globalConfig = loadGlobalConfig(ctx.paths);
+  const localConfigFile = loadLocalConfigFile(ctx.paths);
+  const localSettings = localConfigFile.$config;
+
+  if (ctx.flags.json) {
+    ctx.ui.json({
+      resolved: {
+        mode: ctx.config.mode,
+        preambleMode: ctx.config.preambleMode,
+        defaults: ctx.config.defaults,
+      },
+      sources: {
+        mode: localSettings?.mode ? 'local' : globalConfig.mode ? 'global' : 'default',
+        preambleMode: localSettings?.preambleMode
+          ? 'local'
+          : globalConfig.preambleMode
+            ? 'global'
+            : 'default',
+      },
+      paths: {
+        global: ctx.paths.globalConfig,
+        local: ctx.paths.localConfig,
+      },
+    });
+    return;
+  }
+
+  // Determine sources
+  const modeSource = localSettings?.mode ? '(local)' : globalConfig.mode ? '(global)' : '(default)';
+  const preambleSource = localSettings?.preambleMode
+    ? '(local)'
+    : globalConfig.preambleMode
+      ? '(global)'
+      : '(default)';
+
+  ctx.ui.info('Current configuration:\n');
+  ctx.ui.table(
+    ['Key', 'Value', 'Source'],
+    [
+      ['mode', ctx.config.mode, modeSource],
+      ['preambleMode', ctx.config.preambleMode, preambleSource],
+      ['defaults.timeout', String(ctx.config.defaults.timeout), '(global)'],
+      ['defaults.pollInterval', String(ctx.config.defaults.pollInterval), '(global)'],
+      ['defaults.captureLines', String(ctx.config.defaults.captureLines), '(global)'],
+    ]
+  );
+
+  ctx.ui.info(`\nPaths:`);
+  ctx.ui.info(`  Global: ${ctx.paths.globalConfig}`);
+  ctx.ui.info(`  Local:  ${ctx.paths.localConfig}`);
+}
+
+/**
+ * Set a config value.
+ */
+function setConfig(ctx: Context, key: string, value: string, global: boolean): void {
+  if (!isValidKey(key)) {
+    ctx.ui.error(`Invalid key: ${key}. Valid keys: ${VALID_KEYS.join(', ')}`);
+    ctx.exit(ExitCodes.ERROR);
+  }
+
+  if (!isValidValue(key, value)) {
+    ctx.ui.error(
+      `Invalid value for ${key}: ${value}. Valid values: ${VALID_VALUES[key].join(', ')}`
+    );
+    ctx.exit(ExitCodes.ERROR);
+  }
+
+  if (global) {
+    // Set in global config
+    const globalConfig = loadGlobalConfig(ctx.paths);
+    if (key === 'mode') {
+      globalConfig.mode = value as 'polling' | 'wait';
+    } else if (key === 'preambleMode') {
+      globalConfig.preambleMode = value as 'always' | 'disabled';
+    }
+    saveGlobalConfig(ctx.paths, globalConfig);
+    ctx.ui.success(`Set ${key}=${value} in global config`);
+  } else {
+    // Set in local config
+    if (key === 'mode') {
+      updateLocalSettings(ctx.paths, { mode: value as 'polling' | 'wait' });
+    } else if (key === 'preambleMode') {
+      updateLocalSettings(ctx.paths, { preambleMode: value as 'always' | 'disabled' });
+    }
+    ctx.ui.success(`Set ${key}=${value} in local config (repo override)`);
+  }
+}
+
+/**
+ * Clear local config override.
+ */
+function clearConfig(ctx: Context, key?: string): void {
+  if (key) {
+    if (!isValidKey(key)) {
+      ctx.ui.error(`Invalid key: ${key}. Valid keys: ${VALID_KEYS.join(', ')}`);
+      ctx.exit(ExitCodes.ERROR);
+    }
+
+    // Clear specific key from local settings
+    const localConfigFile = loadLocalConfigFile(ctx.paths);
+    if (localConfigFile.$config) {
+      delete localConfigFile.$config[key];
+      // Remove $config if empty
+      if (Object.keys(localConfigFile.$config).length === 0) {
+        delete localConfigFile.$config;
+      }
+      saveLocalConfigFile(ctx.paths, localConfigFile);
+    }
+    ctx.ui.success(`Cleared local override for ${key}`);
+  } else {
+    // Clear all local settings
+    clearLocalSettings(ctx.paths);
+    ctx.ui.success('Cleared all local config overrides');
+  }
+}
+
+/**
+ * Config command entry point.
+ */
+export function cmdConfig(ctx: Context, args: string[]): void {
+  const subcommand = args[0];
+
+  // Parse --global flag
+  const globalFlag = args.includes('--global') || args.includes('-g');
+  const filteredArgs = args.filter((a) => a !== '--global' && a !== '-g');
+
+  switch (subcommand) {
+    case undefined:
+    case 'show':
+      showConfig(ctx);
+      break;
+
+    case 'set':
+      if (filteredArgs.length < 3) {
+        ctx.ui.error('Usage: tmux-team config set <key> <value> [--global]');
+        ctx.exit(ExitCodes.ERROR);
+      }
+      setConfig(ctx, filteredArgs[1], filteredArgs[2], globalFlag);
+      break;
+
+    case 'clear':
+      clearConfig(ctx, filteredArgs[1]);
+      break;
+
+    default:
+      ctx.ui.error(`Unknown config subcommand: ${subcommand}`);
+      ctx.ui.error('Usage: tmux-team config [show|set|clear]');
+      ctx.exit(ExitCodes.ERROR);
+  }
+}

package/src/commands/help.ts

@@ -20,6 +20,8 @@ ${colors.yellow('COMMANDS')}
   ${colors.green('update')} <name> [options]     Update an agent's config
   ${colors.green('remove')} <name>               Remove an agent
   ${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('completion')}                  Output shell completion script
   ${colors.green('help')}                        Show this help message
@@ -45,7 +47,20 @@ ${colors.yellow('EXAMPLES')}
   tmux-team remove codex
 
 ${colors.yellow('CONFIG')}
-  Local:  ./tmux-team.json (pane registry)
+  Local:  ./tmux-team.json (pane registry + $config override)
   Global: ~/.config/tmux-team/config.json (settings)
+
+${colors.yellow('CONFIG EXAMPLES')}
+  tmux-team config                     Show current settings
+  tmux-team config set mode wait       Set mode in local config (repo override)
+  tmux-team config set mode polling --global  Set mode in global config
+  tmux-team config clear mode          Clear local override for mode
+  tmux-team config clear               Clear all local overrides
+
+${colors.yellow('PREAMBLE EXAMPLES')}
+  tmux-team preamble                   Show all preambles
+  tmux-team preamble show codex        Show preamble for codex
+  tmux-team preamble set codex "You are a code reviewer. Be concise."
+  tmux-team preamble clear codex       Clear preamble for codex
 `);
 }

package/src/commands/preamble.ts

@@ -0,0 +1,153 @@
+// ─────────────────────────────────────────────────────────────
+// Preamble command - manage agent preambles
+// ─────────────────────────────────────────────────────────────
+
+import type { Context } from '../types.js';
+import { ExitCodes } from '../context.js';
+import { loadGlobalConfig, saveGlobalConfig } from '../config.js';
+
+/**
+ * Show preamble(s) for agent(s).
+ */
+function showPreamble(ctx: Context, agentName?: string): void {
+  const { ui, config, flags } = ctx;
+
+  if (agentName) {
+    // Show specific agent's preamble
+    const agentConfig = config.agents[agentName];
+    const preamble = agentConfig?.preamble;
+
+    if (flags.json) {
+      ui.json({ agent: agentName, preamble: preamble ?? null });
+      return;
+    }
+
+    if (preamble) {
+      ui.info(`Preamble for ${agentName}:`);
+      console.log(preamble);
+    } else {
+      ui.info(`No preamble set for ${agentName}`);
+    }
+  } else {
+    // Show all preambles
+    const preambles: { agent: string; preamble: string }[] = [];
+
+    for (const [name, agentConfig] of Object.entries(config.agents)) {
+      if (agentConfig.preamble) {
+        preambles.push({ agent: name, preamble: agentConfig.preamble });
+      }
+    }
+
+    if (flags.json) {
+      ui.json({ preambles });
+      return;
+    }
+
+    if (preambles.length === 0) {
+      ui.info('No preambles configured');
+      return;
+    }
+
+    for (const { agent, preamble } of preambles) {
+      console.log(`─── ${agent} ───`);
+      console.log(preamble);
+      console.log();
+    }
+  }
+}
+
+/**
+ * Set preamble for an agent.
+ */
+function setPreamble(ctx: Context, agentName: string, preamble: string): void {
+  const { ui, paths, flags } = ctx;
+
+  const globalConfig = loadGlobalConfig(paths);
+
+  // Ensure agents object exists
+  if (!globalConfig.agents) {
+    globalConfig.agents = {};
+  }
+
+  // Ensure agent config exists
+  if (!globalConfig.agents[agentName]) {
+    globalConfig.agents[agentName] = {};
+  }
+
+  globalConfig.agents[agentName].preamble = preamble;
+  saveGlobalConfig(paths, globalConfig);
+
+  if (flags.json) {
+    ui.json({ agent: agentName, preamble, status: 'set' });
+  } else {
+    ui.success(`Set preamble for ${agentName}`);
+  }
+}
+
+/**
+ * Clear preamble for an agent.
+ */
+function clearPreamble(ctx: Context, agentName: string): void {
+  const { ui, paths, flags } = ctx;
+
+  const globalConfig = loadGlobalConfig(paths);
+
+  if (globalConfig.agents?.[agentName]?.preamble) {
+    delete globalConfig.agents[agentName].preamble;
+
+    // Clean up empty agent config
+    if (Object.keys(globalConfig.agents[agentName]).length === 0) {
+      delete globalConfig.agents[agentName];
+    }
+
+    saveGlobalConfig(paths, globalConfig);
+
+    if (flags.json) {
+      ui.json({ agent: agentName, status: 'cleared' });
+    } else {
+      ui.success(`Cleared preamble for ${agentName}`);
+    }
+  } else {
+    if (flags.json) {
+      ui.json({ agent: agentName, status: 'not_set' });
+    } else {
+      ui.info(`No preamble was set for ${agentName}`);
+    }
+  }
+}
+
+/**
+ * Preamble command entry point.
+ */
+export function cmdPreamble(ctx: Context, args: string[]): void {
+  const subcommand = args[0];
+
+  switch (subcommand) {
+    case undefined:
+    case 'show':
+      showPreamble(ctx, args[1]);
+      break;
+
+    case 'set':
+      if (args.length < 3) {
+        ctx.ui.error('Usage: tmux-team preamble set <agent> <preamble>');
+        ctx.exit(ExitCodes.ERROR);
+      }
+      // Join remaining args as preamble (allows spaces without quotes)
+      setPreamble(ctx, args[1], args.slice(2).join(' '));
+      break;
+
+    case 'clear':
+      if (args.length < 2) {
+        ctx.ui.error('Usage: tmux-team preamble clear <agent>');
+        ctx.exit(ExitCodes.ERROR);
+      }
+      clearPreamble(ctx, args[1]);
+      break;
+
+    default:
+      ctx.ui.error(`Unknown preamble subcommand: ${subcommand}`);
+      ctx.ui.error('Usage: tmux-team preamble [show|set|clear]');
+      ctx.exit(ExitCodes.ERROR);
+  }
+}

package/src/commands/talk.test.ts

@@ -203,12 +203,18 @@ describe('buildMessage (via cmdTalk)', () => {
 
 describe('cmdTalk - basic send', () => {
   let testDir: string;
+  const originalEnv = { ...process.env };
 
   beforeEach(() => {
+    // Disable pane detection in tests
+    delete process.env.TMUX;
+    delete process.env.TMT_AGENT_NAME;
+    delete process.env.TMUX_TEAM_ACTOR;
     testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'talk-test-'));
   });
 
   afterEach(() => {
+    process.env = { ...originalEnv };
     if (fs.existsSync(testDir)) {
       fs.rmSync(testDir, { recursive: true, force: true });
     }
@@ -235,6 +241,27 @@ describe('cmdTalk - basic send', () => {
     expect(tmux.sends.map((s) => s.pane).sort()).toEqual(['1.0', '1.1', '1.2']);
   });
 
+  it('skips self when sending to all (via env var)', async () => {
+    // Simulate being an agent via env var (when not in tmux)
+    const originalEnv = { ...process.env };
+    delete process.env.TMUX; // Ensure pane detection is disabled
+    process.env.TMT_AGENT_NAME = 'claude';
+
+    try {
+      const tmux = createMockTmux();
+      const ui = createMockUI();
+      const ctx = createContext({ tmux, ui, paths: createTestPaths(testDir) });
+
+      await cmdTalk(ctx, 'all', 'Hello team');
+
+      // Should skip claude (self) and only send to codex and gemini
+      expect(tmux.sends).toHaveLength(2);
+      expect(tmux.sends.map((s) => s.pane).sort()).toEqual(['1.1', '1.2']);
+    } finally {
+      process.env = originalEnv;
+    }
+  });
+
   it('removes exclamation marks for gemini agent', async () => {
     const tmux = createMockTmux();
     const ctx = createContext({ tmux, paths: createTestPaths(testDir) });

package/src/commands/talk.ts

@@ -8,6 +8,7 @@ import { ExitCodes } from '../exits.js';
 import { colors } from '../ui.js';
 import crypto from 'crypto';
 import { cleanupState, clearActiveRequest, setActiveRequest } from '../state.js';
+import { resolveActor } from '../pm/permissions.js';
 
 function sleepMs(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -65,6 +66,9 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
       exit(ExitCodes.CONFIG_MISSING);
     }
 
+    // Determine current agent to skip self
+    const { actor: self } = resolveActor(config.paneRegistry);
+
     if (flags.delay && flags.delay > 0) {
       await sleepMs(flags.delay * 1000);
     }
@@ -72,6 +76,15 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
     const results: { agent: string; pane: string; status: string }[] = [];
 
     for (const [name, data] of agents) {
+      // Skip sending to self
+      if (name === self) {
+        results.push({ agent: name, pane: data.pane, status: 'skipped (self)' });
+        if (!flags.json) {
+          console.log(`${colors.dim('○')} Skipped ${colors.cyan(name)} (self)`);
+        }
+        continue;
+      }
+
       try {
         // Build message with preamble, then apply Gemini filter
         let msg = buildMessage(message, name, ctx);

package/src/config.ts

@@ -5,7 +5,14 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import type { GlobalConfig, LocalConfig, ResolvedConfig, Paths } from './types.js';
+import type {
+  GlobalConfig,
+  LocalConfig,
+  LocalConfigFile,
+  LocalSettings,
+  ResolvedConfig,
+  Paths,
+} from './types.js';
 
 const CONFIG_FILENAME = 'config.json';
 const LOCAL_CONFIG_FILENAME = 'tmux-team.json';
@@ -136,10 +143,20 @@ export function loadConfig(paths: Paths): ResolvedConfig {
     }
   }
 
-  // Load local config (pane registry)
-  const localConfig = loadJsonFile<LocalConfig>(paths.localConfig);
-  if (localConfig) {
-    config.paneRegistry = localConfig;
+  // Load local config (pane registry + optional settings)
+  const localConfigFile = loadJsonFile<LocalConfigFile>(paths.localConfig);
+  if (localConfigFile) {
+    // Extract local settings if present
+    const { $config: localSettings, ...paneEntries } = localConfigFile;
+
+    // Merge local settings (override global)
+    if (localSettings) {
+      if (localSettings.mode) config.mode = localSettings.mode;
+      if (localSettings.preambleMode) config.preambleMode = localSettings.preambleMode;
+    }
+
+    // Set pane registry (filter out $config)
+    config.paneRegistry = paneEntries as LocalConfig;
   }
 
   return config;
@@ -157,3 +174,50 @@ export function ensureGlobalDir(paths: Paths): void {
     fs.mkdirSync(paths.globalDir, { recursive: true });
   }
 }
+
+/**
+ * Load raw global config file (for editing).
+ */
+export function loadGlobalConfig(paths: Paths): Partial<GlobalConfig> {
+  return loadJsonFile<Partial<GlobalConfig>>(paths.globalConfig) ?? {};
+}
+
+/**
+ * Save global config file.
+ */
+export function saveGlobalConfig(paths: Paths, config: Partial<GlobalConfig>): void {
+  ensureGlobalDir(paths);
+  fs.writeFileSync(paths.globalConfig, JSON.stringify(config, null, 2) + '\n');
+}
+
+/**
+ * Load raw local config file (for editing).
+ */
+export function loadLocalConfigFile(paths: Paths): LocalConfigFile {
+  return loadJsonFile<LocalConfigFile>(paths.localConfig) ?? {};
+}
+
+/**
+ * Save local config file (preserves both $config and pane entries).
+ */
+export function saveLocalConfigFile(paths: Paths, configFile: LocalConfigFile): void {
+  fs.writeFileSync(paths.localConfig, JSON.stringify(configFile, null, 2) + '\n');
+}
+
+/**
+ * Update local settings (creates $config if needed).
+ */
+export function updateLocalSettings(paths: Paths, settings: LocalSettings): void {
+  const configFile = loadLocalConfigFile(paths);
+  configFile.$config = { ...configFile.$config, ...settings };
+  saveLocalConfigFile(paths, configFile);
+}
+
+/**
+ * Clear local settings.
+ */
+export function clearLocalSettings(paths: Paths): void {
+  const configFile = loadLocalConfigFile(paths);
+  delete configFile.$config;
+  saveLocalConfigFile(paths, configFile);
+}