aegiscode 3.1.8 → 3.1.10

package/src/slash-commands/types.ts

@@ -0,0 +1,201 @@
+/**
+ * Slash 命令类型定义
+ */
+
+/**
+ * 
+ */
+export type CommandCategory = 
+  | 'general'      // 通用命
+  | 'session'      // 会话相
+  | 'config'       // 配置相
+  | 'skills'       // Skills 相
+  | 'hooks'        // Hooks 相
+  | 'git'          // Git 相
+  | 'mcp'          // MCP 相
+  | 'custom';      // 自定义命
+
+/**
+ * 
+ */
+export interface SelectorOption<T = string> {
+  value: T;
+  label: string;
+  description?: string;
+  isCurrent?: boolean;
+}
+
+/**
+ * Slash 命令上下文
+ */
+export interface SlashCommandContext {
+  /** 当前工作目录 */
+  cwd: string;
+  /** 会话 ID */
+  sessionId?: string;
+  /** 用户消息历史 */
+  messages?: any[];
+  /** ContextManager 实例（用于 /compact 等命令） */
+  contextManager?: any;
+  /** ChatService 实例（用于 LLM 调用） */
+  chatService?: any;
+  /** 模型名称 */
+  modelName?: string;
+  /** 显示选择器的回调 */
+  showSelector?: <T>(options: {
+    title: string;
+    options: SelectorOption<T>[];
+    onSelect: (value: T) => void;
+    onCancel: () => void;
+  }) => void;
+  /** 隐藏选择器的回调 */
+  hideSelector?: () => void;
+  /** 流式内容回调（增量文本） */
+  onContentDelta?: (delta: string) => void;
+  /** 流式思考回调 */
+  onThinkingDelta?: (delta: string) => void;
+  /** 工具调用开始回调 */
+  onToolCallStart?: (toolCall: { id: string; name: string; input: string }) => void;
+  /** 确认处理器（供管道交互式批准工具调用） */
+  confirmationHandler?: { requestConfirmation: (details: any) => Promise<any> };
+}
+
+/**
+ * Slash 命令结果
+ */
+export interface SlashCommandResult {
+  /** 是否成功 */
+  success: boolean;
+  /** 结果类型（用于 UI 展示） */
+  type?: 'success' | 'error' | 'info' | 'silent' | 'selector';
+  /** 内容（Markdown 格式） */
+  content?: string;
+  /** 消息（简短提示） */
+  message?: string;
+  /** 错误信息 */
+  error?: string;
+  /** 是否继续处理（用于某些命令可能需要修改后续流程） */
+  shouldContinue?: boolean;
+  /** 额外数据 */
+  data?: any;
+  /** 选择器配置（type 为 'selector' 时使用） */
+  selector?: {
+    title: string;
+    options: SelectorOption[];
+    /** 选择后的处理器名称 */
+    handler: 'theme' | 'model';
+  };
+  /** 是否将内容发送给 Agent（自定义命令默认 true） */
+  sendToAgent?: boolean;
+}
+
+/**
+ * Slash 命令定义
+ */
+export interface SlashCommand {
+  /** 命令名称（不含 /） */
+  name: string;
+  /** 命令别名 */
+  aliases?: string[];
+  /** 命令描述 */
+  description: string;
+  /** 详细描述 */
+  fullDescription?: string;
+  /** 使用示例 */
+  usage?: string;
+  /** 命令分类 */
+  category?: CommandCategory;
+  /** 示例列表 */
+  examples?: string[];
+  /** 命令处理函数 */
+  handler: (args: string, context: SlashCommandContext) => Promise<SlashCommandResult>;
+}
+
+/**
+ * 
+ */
+export interface CommandSuggestion {
+  /** 完整命令（含 /） */
+  command: string;
+  /** 命令描述 */
+  description: string;
+  /** 匹配分数 (0-100) */
+  matchScore?: number;
+}
+
+/**
+ * 
+ */
+export type SlashCommandRegistry = Record<string, SlashCommand>;
+
+// ==================== 自定义命令类
+
+/**
+ * 
+ */
+export interface CustomCommandConfig {
+  /** 命令描述（AI 调用必需） */
+  description?: string;
+  /** 参数提示，如 [message] */
+  argumentHint?: string;
+  /** 限制可用工具列表 */
+  allowedTools?: string[];
+  /** 指定执行模型 */
+  model?: string;
+  /** 禁止 AI 调用（默认 false） */
+  disableModelInvocation?: boolean;
+}
+
+/**
+ * 
+ */
+export type CustomCommandSource = 'user' | 'project';
+
+/**
+ * 
+ */
+export type CustomCommandSourceDir = 'claude' | 'aegis';
+
+/**
+ * 
+ */
+export interface CustomCommand {
+  /** 命令名（不含 /） */
+  name: string;
+  /** 命名空间（子目录名） */
+  namespace?: string;
+  /** Frontmatter 配置 */
+  config: CustomCommandConfig;
+  /** Markdown 正文 */
+  content: string;
+  /** 文件完整路径 */
+  path: string;
+  /** 来源类型 */
+  source: CustomCommandSource;
+  /** 目录类型 */
+  sourceDir: CustomCommandSourceDir;
+}
+
+/**
+ * 
+ */
+export interface CustomCommandExecutionContext {
+  /** 命令参数 */
+  args: string[];
+  /** 工作目录 */
+  workspaceRoot: string;
+  /** 中断信号 */
+  signal?: AbortSignal;
+}
+
+/**
+ * 
+ */
+export interface CustomCommandDiscoveryResult {
+  /** 发现的命令列表 */
+  commands: CustomCommand[];
+  /** 警告信息 */
+  warnings: string[];
+  /** 扫描的目录 */
+  scannedDirs: string[];
+}

package/src/store/index.ts

@@ -0,0 +1,76 @@
+/**
+ * Zustand Store 模块导出
+ * 
+ * 
+ */
+
+// 类
+export * from './types.js';
+
+// Vanilla Store（非 React 环
+export {
+  vanillaStore,
+  getState,
+  subscribe,
+  sessionActions,
+  configActions,
+  appActions,
+  focusActions,
+  commandActions,
+  getConfig,
+  getCurrentModel,
+  getPermissionMode,
+  ensureStoreInitialized,
+  subscribeToState,
+  subscribeToTodos,
+  subscribeToMessages,
+} from './vanilla.js';
+
+// React 选择器
+export {
+  useClawdStore,
+  // Session
+  useSessionId,
+  useMessages,
+  useIsThinking,
+  useIsCompacting,
+  useSessionError,
+  useCurrentCommand,
+  useTokenUsage,
+  // Config
+  useConfig,
+  useTheme,
+  usePermissionMode,
+  useAllModels,
+  useCurrentModel,
+  // App
+  useInitializationStatus,
+  useInitializationError,
+  useActiveModal,
+  useTodos,
+  useAwaitingSecondCtrlC,
+  useShowAllThinking,
+  useAutoRouterActiveModel,
+  useRouterEnabled,
+  useWorkflow,
+  // Focus
+  useCurrentFocus,
+  usePreviousFocus,
+  // Command
+  useIsProcessing,
+  usePendingCommands,
+  // 派生选择
+  useContextRemaining,
+  useIsInputDisabled,
+  useIsBusy,
+  useTodoStats,
+  // 细粒度消息选择
+  useMessageCount,
+  useMessageById,
+  useMessageIds,
+  useHasStreamingMessage,
+  useStreamingMessageId,
+  // 组合选择
+  useSessionState,
+  useAppState,
+} from './selectors.js';

package/src/store/selectors.ts

@@ -0,0 +1,246 @@
+/**
+ * Store 选择器
+ * 
+ * 
+ */
+
+import { useStore } from 'zustand';
+import { useShallow } from 'zustand/react/shallow';
+import { vanillaStore } from './vanilla.js';
+import type { ClawdStore, SessionMessage, TodoItem, FocusId, WorkflowState } from './types.js';
+import type { ModelConfig, PermissionMode } from '../config/types.js';
+
+// ========== 基
+
+/**
+ * React Hook - 订阅 Clawd Store
+ */
+export function useClawdStore<T>(selector: (state: ClawdStore) => T): T {
+  return useStore(vanillaStore, selector);
+}
+
+// ========== Session 选择
+
+export const useSessionId = () =>
+  useClawdStore((state) => state.session.sessionId);
+
+export const useMessages = () =>
+  useClawdStore((state) => state.session.messages);
+
+export const useIsThinking = () =>
+  useClawdStore((state) => state.session.isThinking);
+
+export const useIsCompacting = () =>
+  useClawdStore((state) => state.session.isCompacting);
+
+export const useSessionError = () =>
+  useClawdStore((state) => state.session.error);
+
+export const useCurrentCommand = () =>
+  useClawdStore((state) => state.session.currentCommand);
+
+export const useTokenUsage = () =>
+  useClawdStore((state) => state.session.tokenUsage);
+
+// ========== Config 选择
+
+export const useConfig = () =>
+  useClawdStore((state) => state.config.config);
+
+export const useTheme = () =>
+  useClawdStore((state) => state.config.config?.theme || 'dark');
+
+export const usePermissionMode = () =>
+  useClawdStore(
+    (state) => (state.config.config?.defaultPermissionMode || 'default') as PermissionMode
+  );
+
+// 常量空引用，避免重渲
+const EMPTY_MODELS: ModelConfig[] = [];
+
+export const useAllModels = () =>
+  useClawdStore(
+    (state) => state.config.config?.models ?? EMPTY_MODELS
+  );
+
+/**
+ * 
+ */
+export const useCurrentModel = () =>
+  useClawdStore((state) => {
+    const config = state.config.config;
+    if (!config) return undefined;
+
+    // 优先使
+    if (config.currentModelId && config.models) {
+      const model = config.models.find((m) => m.id === config.currentModelId);
+      if (model) return model;
+    }
+
+    // 回退
+    if (config.models && config.models.length > 0) {
+      return config.models[0];
+    }
+
+    // 回退
+    return config.default;
+  });
+
+// ========== App 选择
+
+export const useInitializationStatus = () =>
+  useClawdStore((state) => state.app.initializationStatus);
+
+export const useInitializationError = () =>
+  useClawdStore((state) => state.app.initializationError);
+
+export const useActiveModal = () =>
+  useClawdStore((state) => state.app.activeModal);
+
+export const useTodos = () =>
+  useClawdStore((state) => state.app.todos);
+
+export const useAwaitingSecondCtrlC = () =>
+  useClawdStore((state) => state.app.awaitingSecondCtrlC);
+
+export const useShowAllThinking = () =>
+  useClawdStore((state) => state.app.showAllThinking);
+
+export const useAutoRouterActiveModel = () =>
+  useClawdStore((state) => state.app.autoRouterActiveModel);
+
+export const useRouterEnabled = () =>
+  useClawdStore((state) => state.config.config?.autoRouter?.enabled ?? false);
+
+export const useWorkflow = () =>
+  useClawdStore((state) => state.app.workflow);
+
+// ========== Focus 选择
+
+export const useCurrentFocus = () =>
+  useClawdStore((state) => state.focus.currentFocus);
+
+export const usePreviousFocus = () =>
+  useClawdStore((state) => state.focus.previousFocus);
+
+// ========== Command 选择
+
+export const useIsProcessing = () =>
+  useClawdStore((state) => state.command.isProcessing);
+
+export const usePendingCommands = () =>
+  useClawdStore((state) => state.command.pendingCommands);
+
+// ========== 派生选择
+
+/**
+ * 
+ */
+export const useContextRemaining = () =>
+  useClawdStore((state) => {
+    const { inputTokens, maxContextTokens } = state.session.tokenUsage;
+    if (maxContextTokens <= 0) return 100;
+    return Math.round(Math.max(0, 100 - (inputTokens / maxContextTokens) * 100));
+  });
+
+/**
+ * 
+ */
+export const useIsInputDisabled = () =>
+  useClawdStore((state) => {
+    const isThinking = state.session.isThinking;
+    const isReady = state.app.initializationStatus === 'ready';
+    const hasModal =
+      state.app.activeModal !== 'none' &&
+      state.app.activeModal !== 'shortcuts';
+    return isThinking || !isReady || hasModal;
+  });
+
+/**
+ * 
+ */
+export const useIsBusy = () =>
+  useClawdStore(
+    (state) => state.session.isThinking || state.command.isProcessing
+  );
+
+/**
+ * 
+ */
+export const useTodoStats = () =>
+  useClawdStore(
+    useShallow((state) => {
+      const todos = state.app.todos;
+      return {
+        total: todos.length,
+        completed: todos.filter((t) => t.status === 'completed').length,
+        inProgress: todos.filter((t) => t.status === 'in_progress').length,
+        pending: todos.filter((t) => t.status === 'pending').length,
+      };
+    })
+  );
+
+// ========== 细粒度消息选择
+
+/**
+ * 
+ */
+export const useMessageCount = () =>
+  useClawdStore((state) => state.session.messages.length);
+
+/**
+ * 
+ */
+export const useMessageById = (id: string) =>
+  useClawdStore((state) => state.session.messages.find(m => m.id === id));
+
+/**
+ * 
+ */
+export const useMessageIds = () =>
+  useClawdStore(
+    useShallow((state) => state.session.messages.map(m => m.id))
+  );
+
+/**
+ * 
+ */
+export const useHasStreamingMessage = () =>
+  useClawdStore((state) => state.session.messages.some(m => m.isStreaming));
+
+/**
+ * 
+ */
+export const useStreamingMessageId = () =>
+  useClawdStore((state) => {
+    const streaming = state.session.messages.find(m => m.isStreaming);
+    return streaming?.id ?? null;
+  });
+
+// ========== 组合选择器（使
+
+/**
+ * 
+ */
+export const useSessionState = () =>
+  useClawdStore(
+    useShallow((state) => ({
+      sessionId: state.session.sessionId,
+      messages: state.session.messages,
+      isThinking: state.session.isThinking,
+      currentCommand: state.session.currentCommand,
+      error: state.session.error,
+    }))
+  );
+
+/**
+ * 
+ */
+export const useAppState = () =>
+  useClawdStore(
+    useShallow((state) => ({
+      initializationStatus: state.app.initializationStatus,
+      initializationError: state.app.initializationError,
+      activeModal: state.app.activeModal,
+    }))
+  );

package/src/store/slices/appSlice.ts

@@ -0,0 +1,205 @@
+/**
+ * App Slice - 应用状态管理
+ */
+
+import type { StateCreator } from 'zustand';
+import type { ClawdStore, AppSlice, InitializationStatus, ActiveModal, TodoItem, WorkflowState } from '../types.js';
+import { initialWorkflowState } from '../types.js';
+
+const initialAppState = {
+  initializationStatus: 'pending' as InitializationStatus,
+  initializationError: null as string | null,
+  activeModal: 'none' as ActiveModal,
+  todos: [] as TodoItem[],
+  awaitingSecondCtrlC: false,
+  showAllThinking: false,
+  manualModelOverride: false,
+  autoRouterActiveModel: null as string | null,
+  workflow: { ...initialWorkflowState } as WorkflowState,
+};
+
+export const createAppSlice: StateCreator<
+  ClawdStore,
+  [],
+  [],
+  AppSlice
+> = (set, get) => ({
+  ...initialAppState,
+
+  actions: {
+    /**
+     * 
+     */
+    setInitializationStatus: (status: InitializationStatus) => {
+      set((state) => ({
+        app: { ...state.app, initializationStatus: status },
+      }));
+    },
+
+    /**
+     * 
+     */
+    setInitializationError: (error: string | null) => {
+      set((state) => ({
+        app: {
+          ...state.app,
+          initializationError: error,
+          initializationStatus: error ? 'error' : state.app.initializationStatus,
+        },
+      }));
+    },
+
+    /**
+     * 
+     */
+    setActiveModal: (modal: ActiveModal) => {
+      set((state) => ({
+        app: { ...state.app, activeModal: modal },
+      }));
+    },
+
+    /**
+     * 
+     */
+    setTodos: (todos: TodoItem[]) => {
+      set((state) => ({
+        app: { ...state.app, todos },
+      }));
+    },
+
+    /**
+     * 
+     */
+    addTodo: (todo: TodoItem) => {
+      set((state) => ({
+        app: {
+          ...state.app,
+          todos: [...state.app.todos, todo],
+        },
+      }));
+    },
+
+    /**
+     * 
+     */
+    updateTodo: (id: string, updates: Partial<TodoItem>) => {
+      set((state) => ({
+        app: {
+          ...state.app,
+          todos: state.app.todos.map((todo) =>
+            todo.id === id ? { ...todo, ...updates } : todo
+          ),
+        },
+      }));
+    },
+
+    /**
+     * 
+     */
+    removeTodo: (id: string) => {
+      set((state) => ({
+        app: {
+          ...state.app,
+          todos: state.app.todos.filter((todo) => todo.id !== id),
+        },
+      }));
+    },
+
+    /**
+     * 
+     */
+    setAwaitingSecondCtrlC: (awaiting: boolean) => {
+      set((state) => ({
+        app: { ...state.app, awaitingSecondCtrlC: awaiting },
+      }));
+    },
+
+    /**
+     * 
+     */
+    toggleShowAllThinking: () => {
+      set((state) => ({
+        app: { ...state.app, showAllThinking: !state.app.showAllThinking },
+      }));
+    },
+
+    /**
+     *
+     */
+    setManualModelOverride: (value: boolean) => {
+      set((state) => ({
+        app: { ...state.app, manualModelOverride: value },
+      }));
+    },
+
+    /**
+     *
+     */
+    setAutoRouterActiveModel: (label: string | null) => {
+      set((state) => ({
+        app: { ...state.app, autoRouterActiveModel: label },
+      }));
+    },
+
+    // ── Workflow ──────────────────────────────────────────
+    workflow: {
+      setWorkflow: (opts: { phase: string; target: string; steps: string[] }) => {
+        set((state) => ({
+          app: {
+            ...state.app,
+            workflow: {
+              visible: true,
+              phase: opts.phase,
+              target: opts.target,
+              steps: opts.steps.map((label, i) => ({
+                label,
+                status: i === 0 ? 'active' as const : 'pending' as const,
+              })),
+              currentStepIndex: 0,
+              totalSteps: opts.steps.length,
+            },
+          },
+        }));
+      },
+
+      advanceStep: () => {
+        set((state) => {
+          const wf = state.app.workflow;
+          if (!wf.visible) return state;
+          const nextIndex = wf.currentStepIndex + 1;
+          if (nextIndex >= wf.totalSteps) {
+            return {
+              app: {
+                ...state.app,
+                workflow: { ...initialWorkflowState },
+              },
+            };
+          }
+          const updatedSteps = wf.steps.map((s, i) => ({
+            ...s,
+            status: i < nextIndex ? 'done' as const : i === nextIndex ? 'active' as const : 'pending' as const,
+          }));
+          return {
+            app: {
+              ...state.app,
+              workflow: {
+                ...wf,
+                steps: updatedSteps,
+                currentStepIndex: nextIndex,
+              },
+            },
+          };
+        });
+      },
+
+      clearWorkflow: () => {
+        set((state) => ({
+          app: {
+            ...state.app,
+            workflow: { ...initialWorkflowState },
+          },
+        }));
+      },
+    },
+  },
+});