@xortex/xcode 3.0.1 → 3.0.3

package/tasks/pillLabel.ts

@@ -0,0 +1,82 @@
+import { DIAMOND_FILLED, DIAMOND_OPEN } from '../constants/figures.js'
+import { count } from '../utils/array.js'
+import type { BackgroundTaskState } from './types.js'
+
+/**
+ * Produces the compact footer-pill label for a set of background tasks.
+ * Used by both the footer pill and the turn-duration transcript line so the
+ * two surfaces agree on terminology.
+ */
+export function getPillLabel(tasks: BackgroundTaskState[]): string {
+  const n = tasks.length
+  const allSameType = tasks.every(t => t.type === tasks[0]!.type)
+
+  if (allSameType) {
+    switch (tasks[0]!.type) {
+      case 'local_bash': {
+        const monitors = count(
+          tasks,
+          t => t.type === 'local_bash' && t.kind === 'monitor',
+        )
+        const shells = n - monitors
+        const parts: string[] = []
+        if (shells > 0)
+          parts.push(shells === 1 ? '1 shell' : `${shells} shells`)
+        if (monitors > 0)
+          parts.push(monitors === 1 ? '1 monitor' : `${monitors} monitors`)
+        return parts.join(', ')
+      }
+      case 'in_process_teammate': {
+        const teamCount = new Set(
+          tasks.map(t =>
+            t.type === 'in_process_teammate' ? t.identity.teamName : '',
+          ),
+        ).size
+        return teamCount === 1 ? '1 team' : `${teamCount} teams`
+      }
+      case 'local_agent':
+        return n === 1 ? '1 local agent' : `${n} local agents`
+      case 'remote_agent': {
+        const first = tasks[0]!
+        // Per design mockup: ◇ open diamond while running/needs-input,
+        // ◆ filled once ExitPlanMode is awaiting approval.
+        if (n === 1 && first.type === 'remote_agent' && first.isUltraplan) {
+          switch (first.ultraplanPhase) {
+            case 'plan_ready':
+              return `${DIAMOND_FILLED} ultraplan ready`
+            case 'needs_input':
+              return `${DIAMOND_OPEN} ultraplan needs your input`
+            default:
+              return `${DIAMOND_OPEN} ultraplan`
+          }
+        }
+        return n === 1
+          ? `${DIAMOND_OPEN} 1 cloud session`
+          : `${DIAMOND_OPEN} ${n} cloud sessions`
+      }
+      case 'local_workflow':
+        return n === 1 ? '1 background workflow' : `${n} background workflows`
+      case 'monitor_mcp':
+        return n === 1 ? '1 monitor' : `${n} monitors`
+      case 'dream':
+        return 'dreaming'
+    }
+  }
+
+  return `${n} background ${n === 1 ? 'task' : 'tasks'}`
+}
+
+/**
+ * True when the pill should show the dimmed " · ↓ to view" call-to-action.
+ * Per the state diagram: only the two attention states (needs_input,
+ * plan_ready) surface the CTA; plain running shows just the diamond + label.
+ */
+export function pillNeedsCta(tasks: BackgroundTaskState[]): boolean {
+  if (tasks.length !== 1) return false
+  const t = tasks[0]!
+  return (
+    t.type === 'remote_agent' &&
+    t.isUltraplan === true &&
+    t.ultraplanPhase !== undefined
+  )
+}

package/tasks/stopTask.ts

@@ -0,0 +1,100 @@
+// Shared logic for stopping a running task.
+// Used by TaskStopTool (LLM-invoked) and SDK stop_task control request.
+
+import type { AppState } from '../state/AppState.js'
+import type { TaskStateBase } from '../Task.js'
+import { getTaskByType } from '../tasks.js'
+import { emitTaskTerminatedSdk } from '../utils/sdkEventQueue.js'
+import { isLocalShellTask } from './LocalShellTask/guards.js'
+
+export class StopTaskError extends Error {
+  constructor(
+    message: string,
+    public readonly code: 'not_found' | 'not_running' | 'unsupported_type',
+  ) {
+    super(message)
+    this.name = 'StopTaskError'
+  }
+}
+
+type StopTaskContext = {
+  getAppState: () => AppState
+  setAppState: (f: (prev: AppState) => AppState) => void
+}
+
+type StopTaskResult = {
+  taskId: string
+  taskType: string
+  command: string | undefined
+}
+
+/**
+ * Look up a task by ID, validate it is running, kill it, and mark it as notified.
+ *
+ * Throws {@link StopTaskError} when the task cannot be stopped (not found,
+ * not running, or unsupported type). Callers can inspect `error.code` to
+ * distinguish the failure reason.
+ */
+export async function stopTask(
+  taskId: string,
+  context: StopTaskContext,
+): Promise<StopTaskResult> {
+  const { getAppState, setAppState } = context
+  const appState = getAppState()
+  const task = appState.tasks?.[taskId] as TaskStateBase | undefined
+
+  if (!task) {
+    throw new StopTaskError(`No task found with ID: ${taskId}`, 'not_found')
+  }
+
+  if (task.status !== 'running') {
+    throw new StopTaskError(
+      `Task ${taskId} is not running (status: ${task.status})`,
+      'not_running',
+    )
+  }
+
+  const taskImpl = getTaskByType(task.type)
+  if (!taskImpl) {
+    throw new StopTaskError(
+      `Unsupported task type: ${task.type}`,
+      'unsupported_type',
+    )
+  }
+
+  await taskImpl.kill(taskId, setAppState)
+
+  // Bash: suppress the "exit code 137" notification (noise). Agent tasks: don't
+  // suppress — the AbortError catch sends a notification carrying
+  // extractPartialResult(agentMessages), which is the payload not noise.
+  if (isLocalShellTask(task)) {
+    let suppressed = false
+    setAppState(prev => {
+      const prevTask = prev.tasks[taskId]
+      if (!prevTask || prevTask.notified) {
+        return prev
+      }
+      suppressed = true
+      return {
+        ...prev,
+        tasks: {
+          ...prev.tasks,
+          [taskId]: { ...prevTask, notified: true },
+        },
+      }
+    })
+    // Suppressing the XML notification also suppresses print.ts's parsed
+    // task_notification SDK event — emit it directly so SDK consumers see
+    // the task close.
+    if (suppressed) {
+      emitTaskTerminatedSdk(taskId, 'stopped', {
+        toolUseId: task.toolUseId,
+        summary: task.description,
+      })
+    }
+  }
+
+  const command = isLocalShellTask(task) ? task.command : task.description
+
+  return { taskId, taskType: task.type, command }
+}

package/tasks/types.ts

@@ -0,0 +1,46 @@
+// Union of all concrete task state types
+// Use this for components that need to work with any task type
+
+import type { DreamTaskState } from './DreamTask/DreamTask.js'
+import type { InProcessTeammateTaskState } from './InProcessTeammateTask/types.js'
+import type { LocalAgentTaskState } from './LocalAgentTask/LocalAgentTask.js'
+import type { LocalShellTaskState } from './LocalShellTask/guards.js'
+import type { LocalWorkflowTaskState } from './LocalWorkflowTask/LocalWorkflowTask.js'
+import type { MonitorMcpTaskState } from './MonitorMcpTask/MonitorMcpTask.js'
+import type { RemoteAgentTaskState } from './RemoteAgentTask/RemoteAgentTask.js'
+
+export type TaskState =
+  | LocalShellTaskState
+  | LocalAgentTaskState
+  | RemoteAgentTaskState
+  | InProcessTeammateTaskState
+  | LocalWorkflowTaskState
+  | MonitorMcpTaskState
+  | DreamTaskState
+
+// Task types that can appear in the background tasks indicator
+export type BackgroundTaskState =
+  | LocalShellTaskState
+  | LocalAgentTaskState
+  | RemoteAgentTaskState
+  | InProcessTeammateTaskState
+  | LocalWorkflowTaskState
+  | MonitorMcpTaskState
+  | DreamTaskState
+
+/**
+ * Check if a task should be shown in the background tasks indicator.
+ * A task is considered a background task if:
+ * 1. It is running or pending
+ * 2. It has been explicitly backgrounded (not a foreground task)
+ */
+export function isBackgroundTask(task: TaskState): task is BackgroundTaskState {
+  if (task.status !== 'running' && task.status !== 'pending') {
+    return false
+  }
+  // Foreground tasks (isBackgrounded === false) are not yet "background tasks"
+  if ('isBackgrounded' in task && task.isBackgrounded === false) {
+    return false
+  }
+  return true
+}

package/types/command.ts

@@ -0,0 +1,216 @@
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'
+import type { UUID } from 'crypto'
+import type { CanUseToolFn } from '../hooks/useCanUseTool.js'
+import type { CompactionResult } from '../services/compact/compact.js'
+import type { ScopedMcpServerConfig } from '../services/mcp/types.js'
+import type { ToolUseContext } from '../Tool.js'
+import type { EffortValue } from '../utils/effort.js'
+import type { IDEExtensionInstallationStatus, IdeType } from '../utils/ide.js'
+import type { SettingSource } from '../utils/settings/constants.js'
+import type { HooksSettings } from '../utils/settings/types.js'
+import type { ThemeName } from '../utils/theme.js'
+import type { LogOption } from './logs.js'
+import type { Message } from './message.js'
+import type { PluginManifest } from './plugin.js'
+
+export type LocalCommandResult =
+  | { type: 'text'; value: string }
+  | {
+      type: 'compact'
+      compactionResult: CompactionResult
+      displayText?: string
+    }
+  | { type: 'skip' } // Skip messages
+
+export type PromptCommand = {
+  type: 'prompt'
+  progressMessage: string
+  contentLength: number // Length of command content in characters (used for token estimation)
+  argNames?: string[]
+  allowedTools?: string[]
+  model?: string
+  source: SettingSource | 'builtin' | 'mcp' | 'plugin' | 'bundled'
+  pluginInfo?: {
+    pluginManifest: PluginManifest
+    repository: string
+  }
+  disableNonInteractive?: boolean
+  // Hooks to register when this skill is invoked
+  hooks?: HooksSettings
+  // Base directory for skill resources (used to set CLAUDE_PLUGIN_ROOT environment variable for skill hooks)
+  skillRoot?: string
+  // Execution context: 'inline' (default) or 'fork' (run as sub-agent)
+  // 'inline' = skill content expands into the current conversation
+  // 'fork' = skill runs in a sub-agent with separate context and token budget
+  context?: 'inline' | 'fork'
+  // Agent type to use when forked (e.g., 'Bash', 'general-purpose')
+  // Only applicable when context is 'fork'
+  agent?: string
+  effort?: EffortValue
+  // Glob patterns for file paths this skill applies to
+  // When set, the skill is only visible after the model touches matching files
+  paths?: string[]
+  getPromptForCommand(
+    args: string,
+    context: ToolUseContext,
+  ): Promise<ContentBlockParam[]>
+}
+
+/**
+ * The call signature for a local command implementation.
+ */
+export type LocalCommandCall = (
+  args: string,
+  context: LocalJSXCommandContext,
+) => Promise<LocalCommandResult>
+
+/**
+ * Module shape returned by load() for lazy-loaded local commands.
+ */
+export type LocalCommandModule = {
+  call: LocalCommandCall
+}
+
+type LocalCommand = {
+  type: 'local'
+  supportsNonInteractive: boolean
+  load: () => Promise<LocalCommandModule>
+}
+
+export type LocalJSXCommandContext = ToolUseContext & {
+  canUseTool?: CanUseToolFn
+  setMessages: (updater: (prev: Message[]) => Message[]) => void
+  options: {
+    dynamicMcpConfig?: Record<string, ScopedMcpServerConfig>
+    ideInstallationStatus: IDEExtensionInstallationStatus | null
+    theme: ThemeName
+  }
+  onChangeAPIKey: () => void
+  onChangeDynamicMcpConfig?: (
+    config: Record<string, ScopedMcpServerConfig>,
+  ) => void
+  onInstallIDEExtension?: (ide: IdeType) => void
+  resume?: (
+    sessionId: UUID,
+    log: LogOption,
+    entrypoint: ResumeEntrypoint,
+  ) => Promise<void>
+}
+
+export type ResumeEntrypoint =
+  | 'cli_flag'
+  | 'slash_command_picker'
+  | 'slash_command_session_id'
+  | 'slash_command_title'
+  | 'fork'
+
+export type CommandResultDisplay = 'skip' | 'system' | 'user'
+
+/**
+ * Callback when a command completes.
+ * @param result - Optional user-visible message to display
+ * @param options - Optional configuration for command completion
+ * @param options.display - How to display the result: 'skip' | 'system' | 'user' (default)
+ * @param options.shouldQuery - If true, send messages to the model after command completes
+ * @param options.metaMessages - Additional messages to insert as isMeta (model-visible but hidden)
+ */
+export type LocalJSXCommandOnDone = (
+  result?: string,
+  options?: {
+    display?: CommandResultDisplay
+    shouldQuery?: boolean
+    metaMessages?: string[]
+    nextInput?: string
+    submitNextInput?: boolean
+  },
+) => void
+
+/**
+ * The call signature for a local JSX command implementation.
+ */
+export type LocalJSXCommandCall = (
+  onDone: LocalJSXCommandOnDone,
+  context: ToolUseContext & LocalJSXCommandContext,
+  args: string,
+) => Promise<React.ReactNode>
+
+/**
+ * Module shape returned by load() for lazy-loaded commands.
+ */
+export type LocalJSXCommandModule = {
+  call: LocalJSXCommandCall
+}
+
+type LocalJSXCommand = {
+  type: 'local-jsx'
+  /**
+   * Lazy-load the command implementation.
+   * Returns a module with a call() function.
+   * This defers loading heavy dependencies until the command is invoked.
+   */
+  load: () => Promise<LocalJSXCommandModule>
+}
+
+/**
+ * Declares which auth/provider environments a command is available in.
+ *
+ * This is separate from `isEnabled()`:
+ *   - `availability` = who can use this (auth/provider requirement, static)
+ *   - `isEnabled()`  = is this turned on right now (GrowthBook, platform, env vars)
+ *
+ * Commands without `availability` are available everywhere.
+ * Commands with `availability` are only shown if the user matches at least one
+ * of the listed auth types. See meetsAvailabilityRequirement() in commands.ts.
+ *
+ * Example: `availability: ['claude-ai', 'console']` shows the command to
+ * claude.ai subscribers and direct Console API key users (api.anthropic.com),
+ * but hides it from Bedrock/Vertex/Foundry users and custom base URL users.
+ */
+export type CommandAvailability =
+  // claude.ai OAuth subscriber (Pro/Max/Team/Enterprise via claude.ai)
+  | 'claude-ai'
+  // Console API key user (direct api.anthropic.com, not via claude.ai OAuth)
+  | 'console'
+
+export type CommandBase = {
+  availability?: CommandAvailability[]
+  description: string
+  hasUserSpecifiedDescription?: boolean
+  /** Defaults to true. Only set when the command has conditional enablement (feature flags, env checks, etc). */
+  isEnabled?: () => boolean
+  /** Defaults to false. Only set when the command should be hidden from typeahead/help. */
+  isHidden?: boolean
+  name: string
+  aliases?: string[]
+  isMcp?: boolean
+  argumentHint?: string // Hint text for command arguments (displayed in gray after command)
+  whenToUse?: string // From the "Skill" spec. Detailed usage scenarios for when to use this command
+  version?: string // Version of the command/skill
+  disableModelInvocation?: boolean // Whether to disable this command from being invoked by models
+  userInvocable?: boolean // Whether users can invoke this skill by typing /skill-name
+  loadedFrom?:
+    | 'commands_DEPRECATED'
+    | 'skills'
+    | 'plugin'
+    | 'managed'
+    | 'bundled'
+    | 'mcp' // Where the command was loaded from
+  kind?: 'workflow' // Distinguishes workflow-backed commands (badged in autocomplete)
+  immediate?: boolean // If true, command executes immediately without waiting for a stop point (bypasses queue)
+  isSensitive?: boolean // If true, args are redacted from the conversation history
+  /** Defaults to `name`. Only override when the displayed name differs (e.g. plugin prefix stripping). */
+  userFacingName?: () => string
+}
+
+export type Command = CommandBase &
+  (PromptCommand | LocalCommand | LocalJSXCommand)
+
+/** Resolves the user-visible name, falling back to `cmd.name` when not overridden. */
+export function getCommandName(cmd: CommandBase): string {
+  return cmd.userFacingName?.() ?? cmd.name
+}
+
+/** Resolves whether the command is enabled, defaulting to true. */
+export function isCommandEnabled(cmd: CommandBase): boolean {
+  return cmd.isEnabled?.() ?? true
+}

package/types/connectorText.ts

@@ -0,0 +1,13 @@
+export function isConnectorTextBlock(block: any): boolean {
+  return block?.type === 'connector_text';
+}
+
+export type ConnectorTextBlock = {
+  type: 'connector_text';
+  text: string;
+};
+
+export type ConnectorTextDelta = {
+  type: 'connector_text_delta';
+  text: string;
+};