@ebowwa/coder 0.7.63 → 0.7.64

package/packages/src/interfaces/ui/terminal/shared/args.ts

@@ -0,0 +1,222 @@
+/**
+ * CLI Argument Parsing
+ * Shared between CLI and TUI modes
+ */
+
+import type { PermissionMode, ClaudeModel, EffortLevel } from "../../../../types/index.js";
+import { VERSION } from "./status-line.js";
+import { DEFAULT_MODEL, resolveModelAlias } from "../../../../core/models.js";
+
+// ============================================
+// CLI ARGUMENTS INTERFACE
+// ============================================
+
+export interface CLIArgs {
+  model: ClaudeModel;
+  permissionMode: PermissionMode;
+  maxTokens: number;
+  systemPrompt?: string;
+  appendSystemPrompt?: string;
+  configFile?: string;
+  mcpConfig?: string;
+  resumeSession?: string;
+  listSessions?: boolean;
+  teammateMode?: boolean;
+  agentId?: string;
+  agentName?: string;
+  teamName?: string;
+  agentColor?: string;
+  /** Enable extended thinking with effort level */
+  extendedThinking?: boolean;
+  /** Effort level: low, medium, high, max */
+  effort?: EffortLevel;
+  /** Enable interleaved thinking (default: true) */
+  interleaved?: boolean;
+  query?: string;
+  /** Disable progress indicators */
+  noProgress?: boolean;
+  /** Show version and exit */
+  showVersion?: boolean;
+  /** Enable debug output */
+  debug?: boolean;
+}
+
+// ============================================
+// ARGUMENT PARSING
+// ============================================
+
+export function parseArgs(): CLIArgs {
+  const args = process.argv.slice(2);
+  const result: CLIArgs = {
+    // Read from environment variables (can be configured via Doppler)
+    model: process.env.ANTHROPIC_MODEL || process.env.ANTHROPIC_DEFAULT_SONNET_MODEL || DEFAULT_MODEL,
+    permissionMode: (process.env.CODER_PERMISSION_MODE || "default") as PermissionMode,
+    maxTokens: parseInt(process.env.ANTHROPIC_MAX_TOKENS || process.env.CODER_MAX_TOKENS || "4096"),
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    switch (arg) {
+      case "--model":
+      case "-m":
+        result.model = resolveModelAlias(args[++i] ?? DEFAULT_MODEL) as ClaudeModel;
+        break;
+      case "--permission-mode":
+      case "-p":
+        result.permissionMode = (args[++i] ?? "default") as PermissionMode;
+        break;
+      case "--max-tokens":
+        result.maxTokens = parseInt(args[++i] ?? "4096", 10);
+        break;
+      case "--system-prompt":
+        result.systemPrompt = args[++i];
+        break;
+      case "--append-system-prompt":
+        result.appendSystemPrompt = args[++i];
+        break;
+      case "--config":
+        result.configFile = args[++i];
+        break;
+      case "--mcp-config":
+        result.mcpConfig = args[++i];
+        break;
+      case "--resume":
+        result.resumeSession = args[++i];
+        break;
+      case "--sessions":
+        result.listSessions = true;
+        break;
+      case "--teammate-mode":
+        result.teammateMode = true;
+        break;
+      case "--agent-id":
+        result.agentId = args[++i];
+        break;
+      case "--agent-name":
+        result.agentName = args[++i];
+        break;
+      case "--team-name":
+        result.teamName = args[++i];
+        break;
+      case "--agent-color":
+        result.agentColor = args[++i];
+        break;
+      case "--interleaved":
+        result.interleaved = true;
+        break;
+      case "--no-interleaved":
+        result.interleaved = false;
+        break;
+      case "--extended-thinking":
+      case "-e":
+        result.extendedThinking = true;
+        break;
+      case "--effort":
+        result.effort = (args[++i] as EffortLevel) ?? "medium";
+        break;
+      case "--query":
+      case "-q":
+        result.query = args[++i];
+        break;
+      case "--no-progress":
+        result.noProgress = true;
+        break;
+      case "--version":
+      case "-v":
+        result.showVersion = true;
+        break;
+      case "--debug":
+      case "-d":
+        result.debug = true;
+        break;
+      case "--help":
+      case "-h":
+        printHelp();
+        process.exit(0);
+    }
+  }
+
+  return result;
+}
+
+// ============================================
+// HELP TEXT
+// ============================================
+
+export function printHelp(): void {
+  console.log(`
+Coder v${VERSION}
+AI-powered terminal coding assistant
+
+USAGE:
+  coder [OPTIONS] [QUERY]
+
+  With Doppler (recommended):
+    doppler run -- coder [OPTIONS] [QUERY]
+
+OPTIONS:
+  -m, --model <model>           Model to use (default: ${DEFAULT_MODEL})
+  -p, --permission-mode <mode>  Permission mode (default, acceptEdits, bypassPermissions)
+  --max-tokens <tokens>         Maximum output tokens (default: 4096)
+  -v, --version                 Show version and exit
+  -d, --debug                   Enable debug output
+
+Extended Thinking:
+  -e, --extended-thinking       Enable extended thinking mode
+  --effort <level>              Thinking effort: low, medium, high, max
+  --interleaved                 Enable interleaved thinking (default: true)
+  --no-interleaved              Disable interleaved thinking
+  --system-prompt <prompt>      Override system prompt
+  --append-system-prompt <p>    Append to system prompt
+  --config <file>               Configuration file path
+  --mcp-config <file>           MCP server configuration file
+  --resume <session-id>         Resume a previous session
+  --sessions                    List recent sessions
+  --teammate-mode               Run as teammate agent
+  --agent-id <id>               Agent identifier
+  --agent-name <name>           Agent display name
+  --team-name <name>            Team name
+  --agent-color <color>         Agent color for UI
+  -q, --query <query>           Single query to execute
+  --no-progress                 Disable progress indicators
+  -h, --help                    Show this help message
+
+EXAMPLES:
+  # Interactive mode (with Doppler for secrets)
+  doppler run -- coder
+
+  # Single query
+  doppler run -- coder -q "What files are in this directory?"
+
+  # Use a specific model
+  doppler run -- coder -m claude-opus-4-6 "Explain this codebase"
+
+  # Resume a session
+  doppler run -- coder --resume abc123-def456
+
+  # Show version
+  coder --version
+`);
+}
+
+// ============================================
+// API KEY RESOLUTION
+// ============================================
+
+export function getApiKey(): string | null {
+  return process.env.ANTHROPIC_API_KEY ||
+    process.env.CLAUDE_API_KEY ||
+    process.env.ANTHROPIC_AUTH_TOKEN ||
+    process.env.Z_AI_API_KEY ||
+    null;
+}
+
+export function requireApiKey(): string {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error("Error: ANTHROPIC_API_KEY, CLAUDE_API_KEY, ANTHROPIC_AUTH_TOKEN, or Z_AI_API_KEY environment variable required");
+    process.exit(1);
+  }
+  return apiKey;
+}

package/packages/src/interfaces/ui/terminal/shared/index.ts

@@ -0,0 +1,71 @@
+/**
+ * Shared Terminal Utilities
+ * Common code shared between CLI and TUI modes
+ */
+
+// Argument parsing
+export {
+  parseArgs,
+  printHelp,
+  getApiKey,
+  requireApiKey,
+  type CLIArgs,
+} from "./args.js";
+
+// Session setup
+export {
+  setupSession,
+  loadMCPConfig,
+  mcpToolsToToolDefinitions,
+  type SessionSetup,
+  type SetupOptions,
+} from "./setup.js";
+
+// System prompt building
+export {
+  buildDefaultSystemPrompt,
+  buildCompleteSystemPrompt,
+  fetchGitStatus,
+  type GitStatusInfo,
+} from "./system-prompt.js";
+
+// Single query execution
+export {
+  runSingleQuery,
+  type QueryOptions,
+} from "./query.js";
+
+// Loading State
+export {
+  LoadingState,
+  getLoadingState,
+  setLoading,
+  stopLoading,
+  updateLoading,
+  startTool,
+  endTool,
+  type LoadingPhase,
+  type LoadingStateData,
+  type LoadingStateEvents,
+} from "./loading-state.js";
+
+// Status Line
+export {
+  VERSION,
+  BUILD_TIME,
+  renderStatusLine,
+  renderCompactStatusLine,
+  renderMinimalStatusLine,
+  renderFooterStatus,
+  renderAutoCompactWarning,
+  calculateContextInfo,
+  formatPermissionMode,
+  formatTokenCount,
+  formatContextPercent,
+  getContextWindow,
+  shouldShowAutoCompactWarning,
+  getModelDisplayName,
+  getPermissionModeDisplay,
+  type StatusLineOptions,
+  type ContextInfo,
+} from "./status-line.js";

package/packages/src/interfaces/ui/terminal/shared/loading-state.ts

@@ -0,0 +1,322 @@
+/**
+ * Loading State Manager for Coder CLI
+ * Tracks global loading state across the application
+ */
+
+import { EventEmitter } from "events";
+
+// ============================================
+// TYPES
+// ============================================
+
+export type LoadingPhase =
+  | "idle"
+  | "initializing"
+  | "loading-config"
+  | "connecting-mcp"
+  | "api-request"
+  | "streaming"
+  | "tool-execution"
+  | "processing"
+  | "checkpointing";
+
+export interface LoadingStateData {
+  isLoading: boolean;
+  phase: LoadingPhase;
+  message: string;
+  startTime: number;
+  activeTools: Set<string>;
+  activeToolCount: number;
+  hasActiveTools: boolean;
+  responseLength: number;
+  paused: boolean;
+  pausedTime: number;
+}
+
+export interface LoadingStateEvents {
+  "state-change": (state: LoadingStateData) => void;
+  "tool-start": (toolName: string) => void;
+  "tool-end": (toolName: string) => void;
+  "phase-change": (phase: LoadingPhase, previousPhase: LoadingPhase) => void;
+  "progress": (message: string) => void;
+}
+
+// ============================================
+// LOADING STATE CLASS
+// ============================================
+
+export class LoadingState extends EventEmitter {
+  private state: LoadingStateData;
+  private static instance: LoadingState | null = null;
+
+  private constructor() {
+    super();
+    this.state = {
+      isLoading: false,
+      phase: "idle",
+      message: "",
+      startTime: 0,
+      activeTools: new Set(),
+      activeToolCount: 0,
+      hasActiveTools: false,
+      responseLength: 0,
+      paused: false,
+      pausedTime: 0,
+    };
+  }
+
+  /**
+   * Get singleton instance
+   */
+  static getInstance(): LoadingState {
+    if (!LoadingState.instance) {
+      LoadingState.instance = new LoadingState();
+    }
+    return LoadingState.instance;
+  }
+
+  /**
+   * Reset singleton (for testing)
+   */
+  static reset(): void {
+    if (LoadingState.instance) {
+      LoadingState.instance.removeAllListeners();
+      LoadingState.instance = null;
+    }
+  }
+
+  /**
+   * Start loading
+   */
+  start(phase: LoadingPhase = "processing", message = ""): void {
+    const previousPhase = this.state.phase;
+
+    this.state.isLoading = true;
+    this.state.phase = phase;
+    this.state.message = message;
+    this.state.startTime = Date.now();
+
+    this.emit("state-change", this.getState());
+    if (previousPhase !== phase) {
+      this.emit("phase-change", phase, previousPhase);
+    }
+  }
+
+  /**
+   * Stop loading
+   */
+  stop(): void {
+    const previousPhase = this.state.phase;
+
+    this.state.isLoading = false;
+    this.state.phase = "idle";
+    this.state.message = "";
+    this.state.activeTools.clear();
+    this.state.activeToolCount = 0;
+    this.state.responseLength = 0;
+
+    this.emit("state-change", this.getState());
+    this.emit("phase-change", "idle", previousPhase);
+  }
+
+  /**
+   * Update phase
+   */
+  setPhase(phase: LoadingPhase): void {
+    const previousPhase = this.state.phase;
+    this.state.phase = phase;
+    this.emit("phase-change", phase, previousPhase);
+    this.emit("state-change", this.getState());
+  }
+
+  /**
+   * Update message
+   */
+  setMessage(message: string): void {
+    this.state.message = message;
+    this.emit("state-change", this.getState());
+  }
+
+  /**
+   * Update both phase and message
+   */
+  update(phase: LoadingPhase, message: string): void {
+    const previousPhase = this.state.phase;
+    this.state.phase = phase;
+    this.state.message = message;
+    this.emit("phase-change", phase, previousPhase);
+    this.emit("state-change", this.getState());
+  }
+
+  /**
+   * Report progress
+   */
+  progress(message: string): void {
+    this.state.message = message;
+    this.emit("progress", message);
+    this.emit("state-change", this.getState());
+  }
+
+  /**
+   * Mark tool as started
+   */
+  toolStart(toolName: string): void {
+    this.state.activeTools.add(toolName);
+    this.state.activeToolCount = this.state.activeTools.size;
+    this.state.hasActiveTools = true;
+    this.emit("tool-start", toolName);
+    this.emit("state-change", this.getState());
+  }
+
+  /**
+   * Mark tool as completed
+   */
+  toolEnd(toolName: string): void {
+    this.state.activeTools.delete(toolName);
+    this.state.activeToolCount = this.state.activeTools.size;
+    if (this.state.activeTools.size === 0) {
+      this.state.hasActiveTools = false;
+    }
+    this.emit("tool-end", toolName);
+    this.emit("state-change", this.getState());
+  }
+
+  /**
+   * Update response length (for streaming)
+   */
+  setResponseLength(length: number): void {
+    this.state.responseLength = length;
+    this.emit("state-change", this.getState());
+  }
+
+  /**
+   * Pause loading state
+   */
+  pause(): void {
+    if (!this.state.paused) {
+      this.state.paused = true;
+      this.state.pausedTime = Date.now();
+      this.emit("state-change", this.getState());
+    }
+  }
+
+  /**
+   * Resume loading state
+   */
+  resume(): void {
+    if (this.state.paused) {
+      this.state.paused = false;
+      this.state.pausedTime = 0;
+      this.emit("state-change", this.getState());
+    }
+  }
+
+  /**
+   * Get current state (copy)
+   */
+  getState(): LoadingStateData {
+    return {
+      ...this.state,
+      activeTools: new Set(this.state.activeTools),
+    };
+  }
+
+  /**
+   * Check if loading
+   */
+  isLoading(): boolean {
+    return this.state.isLoading;
+  }
+
+  /**
+   * Get current phase
+   */
+  getPhase(): LoadingPhase {
+    return this.state.phase;
+  }
+
+  /**
+   * Get elapsed time in ms
+   */
+  getElapsedMs(): number {
+    if (this.state.startTime === 0) {
+      return 0;
+    }
+    return Date.now() - this.state.startTime;
+  }
+
+  /**
+   * Get active tool names
+   */
+  getActiveTools(): string[] {
+    return Array.from(this.state.activeTools);
+  }
+
+  /**
+   * Check if specific tool is active
+   */
+  isToolActive(toolName: string): boolean {
+    return this.state.activeTools.has(toolName);
+  }
+
+  /**
+   * Get formatted state for display
+   */
+  getFormattedState(): string {
+    if (!this.state.isLoading) {
+      return "Ready";
+    }
+
+    const parts: string[] = [];
+
+    if (this.state.message) {
+      parts.push(this.state.message);
+    }
+
+    if (this.state.activeToolCount > 0) {
+      parts.push(`(${this.state.activeToolCount} tool${this.state.activeToolCount > 1 ? "s" : ""} active)`);
+    }
+
+    const elapsed = Math.floor(this.getElapsedMs() / 1000);
+    if (elapsed > 0) {
+      parts.push(`[${elapsed}s]`);
+    }
+
+    return parts.join(" ") || this.state.phase;
+  }
+}
+
+// ============================================
+// CONVENIENCE EXPORTS
+// ============================================
+
+/**
+ * Get the global loading state instance
+ */
+export function getLoadingState(): LoadingState {
+  return LoadingState.getInstance();
+}
+
+/**
+ * Quick access to loading state methods
+ * These call getInstance() each time to handle reset() properly
+ */
+export const setLoading = (phase: LoadingPhase, message?: string) => {
+  LoadingState.getInstance().start(phase, message);
+};
+
+export const stopLoading = () => {
+  LoadingState.getInstance().stop();
+};
+
+export const updateLoading = (message: string) => {
+  LoadingState.getInstance().progress(message);
+};
+
+export const startTool = (toolName: string) => {
+  LoadingState.getInstance().toolStart(toolName);
+};
+
+export const endTool = (toolName: string) => {
+  LoadingState.getInstance().toolEnd(toolName);
+};