@xortex/xcode 3.0.1 → 3.0.2

package/skills/mcpSkillBuilders.ts

@@ -0,0 +1,44 @@
+import type {
+  createSkillCommand,
+  parseSkillFrontmatterFields,
+} from './loadSkillsDir.js'
+
+/**
+ * Write-once registry for the two loadSkillsDir functions that MCP skill
+ * discovery needs. This module is a dependency-graph leaf: it imports nothing
+ * but types, so both mcpSkills.ts and loadSkillsDir.ts can depend on it
+ * without forming a cycle (client.ts → mcpSkills.ts → loadSkillsDir.ts → …
+ * → client.ts).
+ *
+ * The non-literal dynamic-import approach ("await import(variable)") fails at
+ * runtime in Bun-bundled binaries — the specifier is resolved against the
+ * chunk's /$bunfs/root/… path, not the original source tree, yielding "Cannot
+ * find module './loadSkillsDir.js'". A literal dynamic import works in bunfs
+ * but dependency-cruiser tracks it, and because loadSkillsDir transitively
+ * reaches almost everything, the single new edge fans out into many new cycle
+ * violations in the diff check.
+ *
+ * Registration happens at loadSkillsDir.ts module init, which is eagerly
+ * evaluated at startup via the static import from commands.ts — long before
+ * any MCP server connects.
+ */
+
+export type MCPSkillBuilders = {
+  createSkillCommand: typeof createSkillCommand
+  parseSkillFrontmatterFields: typeof parseSkillFrontmatterFields
+}
+
+let builders: MCPSkillBuilders | null = null
+
+export function registerMCPSkillBuilders(b: MCPSkillBuilders): void {
+  builders = b
+}
+
+export function getMCPSkillBuilders(): MCPSkillBuilders {
+  if (!builders) {
+    throw new Error(
+      'MCP skill builders not registered — loadSkillsDir.ts has not been evaluated yet',
+    )
+  }
+  return builders
+}

package/state/AppState.tsx

@@ -0,0 +1,200 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import React, { useContext, useEffect, useEffectEvent, useState, useSyncExternalStore } from 'react';
+import { MailboxProvider } from '../context/mailbox.js';
+import { useSettingsChange } from '../hooks/useSettingsChange.js';
+import { logForDebugging } from '../utils/debug.js';
+import { createDisabledBypassPermissionsContext, isBypassPermissionsModeDisabled } from '../utils/permissions/permissionSetup.js';
+import { applySettingsChange } from '../utils/settings/applySettingsChange.js';
+import type { SettingSource } from '../utils/settings/constants.js';
+import { createStore } from './store.js';
+
+// DCE: voice context is ant-only. External builds get a passthrough.
+/* eslint-disable @typescript-eslint/no-require-imports */
+const VoiceProvider: (props: {
+  children: React.ReactNode;
+}) => React.ReactNode = feature('VOICE_MODE') ? require('../context/voice.js').VoiceProvider : ({
+  children
+}) => children;
+
+/* eslint-enable @typescript-eslint/no-require-imports */
+import { type AppState, type AppStateStore, getDefaultAppState } from './AppStateStore.js';
+
+// TODO: Remove these re-exports once all callers import directly from
+// ./AppStateStore.js. Kept for back-compat during migration so .ts callers
+// can incrementally move off the .tsx import and stop pulling React.
+export { type AppState, type AppStateStore, type CompletionBoundary, getDefaultAppState, IDLE_SPECULATION_STATE, type SpeculationResult, type SpeculationState } from './AppStateStore.js';
+export const AppStoreContext = React.createContext<AppStateStore | null>(null);
+type Props = {
+  children: React.ReactNode;
+  initialState?: AppState;
+  onChangeAppState?: (args: {
+    newState: AppState;
+    oldState: AppState;
+  }) => void;
+};
+const HasAppStateContext = React.createContext<boolean>(false);
+export function AppStateProvider(t0) {
+  const $ = _c(13);
+  const {
+    children,
+    initialState,
+    onChangeAppState
+  } = t0;
+  const hasAppStateContext = useContext(HasAppStateContext);
+  if (hasAppStateContext) {
+    throw new Error("AppStateProvider can not be nested within another AppStateProvider");
+  }
+  let t1;
+  if ($[0] !== initialState || $[1] !== onChangeAppState) {
+    t1 = () => createStore(initialState ?? getDefaultAppState(), onChangeAppState);
+    $[0] = initialState;
+    $[1] = onChangeAppState;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const [store] = useState(t1);
+  let t2;
+  if ($[3] !== store) {
+    t2 = () => {
+      const {
+        toolPermissionContext
+      } = store.getState();
+      if (toolPermissionContext.isBypassPermissionsModeAvailable && isBypassPermissionsModeDisabled()) {
+        logForDebugging("Disabling bypass permissions mode on mount (remote settings loaded before mount)");
+        store.setState(_temp);
+      }
+    };
+    $[3] = store;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = [];
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  useEffect(t2, t3);
+  let t4;
+  if ($[6] !== store.setState) {
+    t4 = source => applySettingsChange(source, store.setState);
+    $[6] = store.setState;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  const onSettingsChange = useEffectEvent(t4);
+  useSettingsChange(onSettingsChange);
+  let t5;
+  if ($[8] !== children) {
+    t5 = <MailboxProvider><VoiceProvider>{children}</VoiceProvider></MailboxProvider>;
+    $[8] = children;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  let t6;
+  if ($[10] !== store || $[11] !== t5) {
+    t6 = <HasAppStateContext.Provider value={true}><AppStoreContext.Provider value={store}>{t5}</AppStoreContext.Provider></HasAppStateContext.Provider>;
+    $[10] = store;
+    $[11] = t5;
+    $[12] = t6;
+  } else {
+    t6 = $[12];
+  }
+  return t6;
+}
+function _temp(prev) {
+  return {
+    ...prev,
+    toolPermissionContext: createDisabledBypassPermissionsContext(prev.toolPermissionContext)
+  };
+}
+function useAppStore(): AppStateStore {
+  // eslint-disable-next-line react-hooks/rules-of-hooks
+  const store = useContext(AppStoreContext);
+  if (!store) {
+    throw new ReferenceError('useAppState/useSetAppState cannot be called outside of an <AppStateProvider />');
+  }
+  return store;
+}
+
+/**
+ * Subscribe to a slice of AppState. Only re-renders when the selected value
+ * changes (compared via Object.is).
+ *
+ * For multiple independent fields, call the hook multiple times:
+ * ```
+ * const verbose = useAppState(s => s.verbose)
+ * const model = useAppState(s => s.mainLoopModel)
+ * ```
+ *
+ * Do NOT return new objects from the selector -- Object.is will always see
+ * them as changed. Instead, select an existing sub-object reference:
+ * ```
+ * const { text, promptId } = useAppState(s => s.promptSuggestion) // good
+ * ```
+ */
+export function useAppState(selector) {
+  const $ = _c(3);
+  const store = useAppStore();
+  let t0;
+  if ($[0] !== selector || $[1] !== store) {
+    t0 = () => {
+      const state = store.getState();
+      const selected = selector(state);
+      if (false && state === selected) {
+        throw new Error(`Your selector in \`useAppState(${selector.toString()})\` returned the original state, which is not allowed. You must instead return a property for optimised rendering.`);
+      }
+      return selected;
+    };
+    $[0] = selector;
+    $[1] = store;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const get = t0;
+  return useSyncExternalStore(store.subscribe, get, get);
+}
+
+/**
+ * Get the setAppState updater without subscribing to any state.
+ * Returns a stable reference that never changes -- components using only
+ * this hook will never re-render from state changes.
+ */
+export function useSetAppState() {
+  return useAppStore().setState;
+}
+
+/**
+ * Get the store directly (for passing getState/setState to non-React code).
+ */
+export function useAppStateStore() {
+  return useAppStore();
+}
+const NOOP_SUBSCRIBE = () => () => {};
+
+/**
+ * Safe version of useAppState that returns undefined if called outside of AppStateProvider.
+ * Useful for components that may be rendered in contexts where AppStateProvider isn't available.
+ */
+export function useAppStateMaybeOutsideOfProvider(selector) {
+  const $ = _c(3);
+  const store = useContext(AppStoreContext);
+  let t0;
+  if ($[0] !== selector || $[1] !== store) {
+    t0 = () => store ? selector(store.getState()) : undefined;
+    $[0] = selector;
+    $[1] = store;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return useSyncExternalStore(store ? store.subscribe : NOOP_SUBSCRIBE, t0);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","React","useContext","useEffect","useEffectEvent","useState","useSyncExternalStore","MailboxProvider","useSettingsChange","logForDebugging","createDisabledBypassPermissionsContext","isBypassPermissionsModeDisabled","applySettingsChange","SettingSource","createStore","VoiceProvider","props","children","ReactNode","require","AppState","AppStateStore","getDefaultAppState","CompletionBoundary","IDLE_SPECULATION_STATE","SpeculationResult","SpeculationState","AppStoreContext","createContext","Props","initialState","onChangeAppState","args","newState","oldState","HasAppStateContext","AppStateProvider","t0","$","_c","hasAppStateContext","Error","t1","store","t2","toolPermissionContext","getState","isBypassPermissionsModeAvailable","setState","_temp","t3","Symbol","for","t4","source","onSettingsChange","t5","t6","prev","useAppStore","ReferenceError","useAppState","selector","state","selected","toString","get","subscribe","useSetAppState","useAppStateStore","NOOP_SUBSCRIBE","useAppStateMaybeOutsideOfProvider","undefined"],"sources":["AppState.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport React, {\n  useContext,\n  useEffect,\n  useEffectEvent,\n  useState,\n  useSyncExternalStore,\n} from 'react'\nimport { MailboxProvider } from '../context/mailbox.js'\nimport { useSettingsChange } from '../hooks/useSettingsChange.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport {\n  createDisabledBypassPermissionsContext,\n  isBypassPermissionsModeDisabled,\n} from '../utils/permissions/permissionSetup.js'\nimport { applySettingsChange } from '../utils/settings/applySettingsChange.js'\nimport type { SettingSource } from '../utils/settings/constants.js'\nimport { createStore } from './store.js'\n\n// DCE: voice context is ant-only. External builds get a passthrough.\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst VoiceProvider: (props: { children: React.ReactNode }) => React.ReactNode =\n  feature('VOICE_MODE')\n    ? require('../context/voice.js').VoiceProvider\n    : ({ children }) => children\n\n/* eslint-enable @typescript-eslint/no-require-imports */\nimport {\n  type AppState,\n  type AppStateStore,\n  getDefaultAppState,\n} from './AppStateStore.js'\n\n// TODO: Remove these re-exports once all callers import directly from\n// ./AppStateStore.js. Kept for back-compat during migration so .ts callers\n// can incrementally move off the .tsx import and stop pulling React.\nexport {\n  type AppState,\n  type AppStateStore,\n  type CompletionBoundary,\n  getDefaultAppState,\n  IDLE_SPECULATION_STATE,\n  type SpeculationResult,\n  type SpeculationState,\n} from './AppStateStore.js'\n\nexport const AppStoreContext = React.createContext<AppStateStore | null>(null)\n\ntype Props = {\n  children: React.ReactNode\n  initialState?: AppState\n  onChangeAppState?: (args: { newState: AppState; oldState: AppState }) => void\n}\n\nconst HasAppStateContext = React.createContext<boolean>(false)\n\nexport function AppStateProvider({\n  children,\n  initialState,\n  onChangeAppState,\n}: Props): React.ReactNode {\n  // Don't allow nested AppStateProviders.\n  const hasAppStateContext = useContext(HasAppStateContext)\n  if (hasAppStateContext) {\n    throw new Error(\n      'AppStateProvider can not be nested within another AppStateProvider',\n    )\n  }\n\n  // Store is created once and never changes -- stable context value means\n  // the provider never triggers re-renders. Consumers subscribe to slices\n  // via useSyncExternalStore in useAppState(selector).\n  const [store] = useState(() =>\n    createStore<AppState>(\n      initialState ?? getDefaultAppState(),\n      onChangeAppState,\n    ),\n  )\n\n  // Check on mount if bypass mode should be disabled\n  // This handles the race condition where remote settings load BEFORE this component mounts,\n  // meaning the settings change notification was sent when no listeners were subscribed.\n  // On subsequent sessions, the cached remote-settings.json is read during initial setup,\n  // but on the first session the remote fetch may complete before React mounts.\n  useEffect(() => {\n    const { toolPermissionContext } = store.getState()\n    if (\n      toolPermissionContext.isBypassPermissionsModeAvailable &&\n      isBypassPermissionsModeDisabled()\n    ) {\n      logForDebugging(\n        'Disabling bypass permissions mode on mount (remote settings loaded before mount)',\n      )\n      store.setState(prev => ({\n        ...prev,\n        toolPermissionContext: createDisabledBypassPermissionsContext(\n          prev.toolPermissionContext,\n        ),\n      }))\n    }\n    // biome-ignore lint/correctness/useExhaustiveDependencies: intentional mount-only effect\n  }, [])\n\n  // Listen for external settings changes and sync to AppState.\n  // This ensures file watcher changes propagate through the app --\n  // shared with the headless/SDK path via applySettingsChange.\n  const onSettingsChange = useEffectEvent((source: SettingSource) =>\n    applySettingsChange(source, store.setState),\n  )\n  useSettingsChange(onSettingsChange)\n\n  return (\n    <HasAppStateContext.Provider value={true}>\n      <AppStoreContext.Provider value={store}>\n        <MailboxProvider>\n          <VoiceProvider>{children}</VoiceProvider>\n        </MailboxProvider>\n      </AppStoreContext.Provider>\n    </HasAppStateContext.Provider>\n  )\n}\n\nfunction useAppStore(): AppStateStore {\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  const store = useContext(AppStoreContext)\n  if (!store) {\n    throw new ReferenceError(\n      'useAppState/useSetAppState cannot be called outside of an <AppStateProvider />',\n    )\n  }\n  return store\n}\n\n/**\n * Subscribe to a slice of AppState. Only re-renders when the selected value\n * changes (compared via Object.is).\n *\n * For multiple independent fields, call the hook multiple times:\n * ```\n * const verbose = useAppState(s => s.verbose)\n * const model = useAppState(s => s.mainLoopModel)\n * ```\n *\n * Do NOT return new objects from the selector -- Object.is will always see\n * them as changed. Instead, select an existing sub-object reference:\n * ```\n * const { text, promptId } = useAppState(s => s.promptSuggestion) // good\n * ```\n */\nexport function useAppState<T>(selector: (state: AppState) => T): T {\n  const store = useAppStore()\n\n  const get = () => {\n    const state = store.getState()\n    const selected = selector(state)\n\n    if (\"external\" === 'ant' && state === selected) {\n      throw new Error(\n        `Your selector in \\`useAppState(${selector.toString()})\\` returned the original state, which is not allowed. You must instead return a property for optimised rendering.`,\n      )\n    }\n\n    return selected\n  }\n\n  return useSyncExternalStore(store.subscribe, get, get)\n}\n\n/**\n * Get the setAppState updater without subscribing to any state.\n * Returns a stable reference that never changes -- components using only\n * this hook will never re-render from state changes.\n */\nexport function useSetAppState(): (\n  updater: (prev: AppState) => AppState,\n) => void {\n  return useAppStore().setState\n}\n\n/**\n * Get the store directly (for passing getState/setState to non-React code).\n */\nexport function useAppStateStore(): AppStateStore {\n  return useAppStore()\n}\n\nconst NOOP_SUBSCRIBE = () => () => {}\n\n/**\n * Safe version of useAppState that returns undefined if called outside of AppStateProvider.\n * Useful for components that may be rendered in contexts where AppStateProvider isn't available.\n */\nexport function useAppStateMaybeOutsideOfProvider<T>(\n  selector: (state: AppState) => T,\n): T | undefined {\n  const store = useContext(AppStoreContext)\n  return useSyncExternalStore(store ? store.subscribe : NOOP_SUBSCRIBE, () =>\n    store ? selector(store.getState()) : undefined,\n  )\n}\n"],"mappings":"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","ignoreList":[]}