@xortex/xcode 3.0.1 → 3.0.2

package/commands/upgrade/upgrade.tsx

@@ -0,0 +1,38 @@
+import * as React from 'react';
+import type { LocalJSXCommandContext } from '../../commands.js';
+import { getOauthProfileFromOauthToken } from '../../services/oauth/getOauthProfile.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { getClaudeAIOAuthTokens, isClaudeAISubscriber } from '../../utils/auth.js';
+import { openBrowser } from '../../utils/browser.js';
+import { logError } from '../../utils/log.js';
+import { Login } from '../login/login.js';
+export async function call(onDone: LocalJSXCommandOnDone, context: LocalJSXCommandContext): Promise<React.ReactNode | null> {
+  try {
+    // Check if user is already on the highest Max plan (20x)
+    if (isClaudeAISubscriber()) {
+      const tokens = getClaudeAIOAuthTokens();
+      let isMax20x = false;
+      if (tokens?.subscriptionType && tokens?.rateLimitTier) {
+        isMax20x = tokens.subscriptionType === 'max' && tokens.rateLimitTier === 'default_claude_max_20x';
+      } else if (tokens?.accessToken) {
+        const profile = await getOauthProfileFromOauthToken(tokens.accessToken);
+        isMax20x = profile?.organization?.organization_type === 'claude_max' && profile?.organization?.rate_limit_tier === 'default_claude_max_20x';
+      }
+      if (isMax20x) {
+        setTimeout(onDone, 0, 'You are already on the highest Max subscription plan. For additional usage, run /login to switch to an API usage-billed account.');
+        return null;
+      }
+    }
+    const url = 'https://claude.ai/upgrade/max';
+    await openBrowser(url);
+    return <Login startingMessage={'Starting new login following /upgrade. Exit with Ctrl-C to use existing account.'} onDone={success => {
+      context.onChangeAPIKey();
+      onDone(success ? 'Login successful' : 'Login interrupted');
+    }} />;
+  } catch (error) {
+    logError(error as Error);
+    setTimeout(onDone, 0, 'Failed to open browser. Please visit https://claude.ai/upgrade/max to upgrade.');
+  }
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/commands/usage/index.ts

@@ -0,0 +1,9 @@
+import type { Command } from '../../commands.js'
+
+export default {
+  type: 'local-jsx',
+  name: 'usage',
+  description: 'Show plan usage limits',
+  availability: ['claude-ai'],
+  load: () => import('./usage.js'),
+} satisfies Command

package/commands/usage/usage.tsx

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { Settings } from '../../components/Settings/Settings.js';
+import type { LocalJSXCommandCall } from '../../types/command.js';
+export const call: LocalJSXCommandCall = async (onDone, context) => {
+  return <Settings onClose={onDone} context={context} defaultTab="Usage" />;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIlNldHRpbmdzIiwiTG9jYWxKU1hDb21tYW5kQ2FsbCIsImNhbGwiLCJvbkRvbmUiLCJjb250ZXh0Il0sInNvdXJjZXMiOlsidXNhZ2UudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgU2V0dGluZ3MgfSBmcm9tICcuLi8uLi9jb21wb25lbnRzL1NldHRpbmdzL1NldHRpbmdzLmpzJ1xuaW1wb3J0IHR5cGUgeyBMb2NhbEpTWENvbW1hbmRDYWxsIH0gZnJvbSAnLi4vLi4vdHlwZXMvY29tbWFuZC5qcydcblxuZXhwb3J0IGNvbnN0IGNhbGw6IExvY2FsSlNYQ29tbWFuZENhbGwgPSBhc3luYyAob25Eb25lLCBjb250ZXh0KSA9PiB7XG4gIHJldHVybiA8U2V0dGluZ3Mgb25DbG9zZT17b25Eb25lfSBjb250ZXh0PXtjb250ZXh0fSBkZWZhdWx0VGFiPVwiVXNhZ2VcIiAvPlxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUtBLEtBQUssTUFBTSxPQUFPO0FBQzlCLFNBQVNDLFFBQVEsUUFBUSx1Q0FBdUM7QUFDaEUsY0FBY0MsbUJBQW1CLFFBQVEsd0JBQXdCO0FBRWpFLE9BQU8sTUFBTUMsSUFBSSxFQUFFRCxtQkFBbUIsR0FBRyxNQUFBQyxDQUFPQyxNQUFNLEVBQUVDLE9BQU8sS0FBSztFQUNsRSxPQUFPLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDRCxNQUFNLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQ0MsT0FBTyxDQUFDLENBQUMsVUFBVSxDQUFDLE9BQU8sR0FBRztBQUMzRSxDQUFDIiwiaWdub3JlTGlzdCI6W119

package/commands/version.ts

@@ -0,0 +1,22 @@
+import type { Command, LocalCommandCall } from '../types/command.js'
+
+const call: LocalCommandCall = async () => {
+  return {
+    type: 'text',
+    value: MACRO.BUILD_TIME
+      ? `${MACRO.VERSION} (built ${MACRO.BUILD_TIME})`
+      : MACRO.VERSION,
+  }
+}
+
+const version = {
+  type: 'local',
+  name: 'version',
+  description:
+    'Print the version this session is running (not what autoupdate downloaded)',
+  isEnabled: () => process.env.USER_TYPE === 'ant',
+  supportsNonInteractive: true,
+  load: () => Promise.resolve({ call }),
+} satisfies Command
+
+export default version

package/commands/vim/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const command = {
+  name: 'vim',
+  description: 'Toggle between Vim and Normal editing modes',
+  supportsNonInteractive: false,
+  type: 'local',
+  load: () => import('./vim.js'),
+} satisfies Command
+
+export default command

package/commands/vim/vim.ts

@@ -0,0 +1,38 @@
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../../services/analytics/index.js'
+import type { LocalCommandCall } from '../../types/command.js'
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'
+
+export const call: LocalCommandCall = async () => {
+  const config = getGlobalConfig()
+  let currentMode = config.editorMode || 'normal'
+
+  // Handle backward compatibility - treat 'emacs' as 'normal'
+  if (currentMode === 'emacs') {
+    currentMode = 'normal'
+  }
+
+  const newMode = currentMode === 'normal' ? 'vim' : 'normal'
+
+  saveGlobalConfig(current => ({
+    ...current,
+    editorMode: newMode,
+  }))
+
+  logEvent('tengu_editor_mode_changed', {
+    mode: newMode as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+    source:
+      'command' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  })
+
+  return {
+    type: 'text',
+    value: `Editor mode set to ${newMode}. ${
+      newMode === 'vim'
+        ? 'Use Escape key to toggle between INSERT and NORMAL modes.'
+        : 'Using standard (readline) keyboard bindings.'
+    }`,
+  }
+}

package/commands/voice/index.ts

@@ -0,0 +1,20 @@
+import type { Command } from '../../commands.js'
+import {
+  isVoiceGrowthBookEnabled,
+  isVoiceModeEnabled,
+} from '../../voice/voiceModeEnabled.js'
+
+const voice = {
+  type: 'local',
+  name: 'voice',
+  description: 'Toggle voice mode',
+  availability: ['claude-ai'],
+  isEnabled: () => isVoiceGrowthBookEnabled(),
+  get isHidden() {
+    return !isVoiceModeEnabled()
+  },
+  supportsNonInteractive: false,
+  load: () => import('./voice.js'),
+} satisfies Command
+
+export default voice

package/commands/voice/voice.ts

@@ -0,0 +1,150 @@
+import { normalizeLanguageForSTT } from '../../hooks/useVoice.js'
+import { getShortcutDisplay } from '../../keybindings/shortcutFormat.js'
+import { logEvent } from '../../services/analytics/index.js'
+import type { LocalCommandCall } from '../../types/command.js'
+import { isAnthropicAuthEnabled } from '../../utils/auth.js'
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'
+import { settingsChangeDetector } from '../../utils/settings/changeDetector.js'
+import {
+  getInitialSettings,
+  updateSettingsForSource,
+} from '../../utils/settings/settings.js'
+import { isVoiceModeEnabled } from '../../voice/voiceModeEnabled.js'
+
+const LANG_HINT_MAX_SHOWS = 2
+
+export const call: LocalCommandCall = async () => {
+  // Check auth and kill-switch before allowing voice mode
+  if (!isVoiceModeEnabled()) {
+    // Differentiate: OAuth-less users get an auth hint, everyone else
+    // gets nothing (command shouldn't be reachable when the kill-switch is on).
+    if (!isAnthropicAuthEnabled()) {
+      return {
+        type: 'text' as const,
+        value:
+          'Voice mode requires a Claude.ai account. Please run /login to sign in.',
+      }
+    }
+    return {
+      type: 'text' as const,
+      value: 'Voice mode is not available.',
+    }
+  }
+
+  const currentSettings = getInitialSettings()
+  const isCurrentlyEnabled = currentSettings.voiceEnabled === true
+
+  // Toggle OFF — no checks needed
+  if (isCurrentlyEnabled) {
+    const result = updateSettingsForSource('userSettings', {
+      voiceEnabled: false,
+    })
+    if (result.error) {
+      return {
+        type: 'text' as const,
+        value:
+          'Failed to update settings. Check your settings file for syntax errors.',
+      }
+    }
+    settingsChangeDetector.notifyChange('userSettings')
+    logEvent('tengu_voice_toggled', { enabled: false })
+    return {
+      type: 'text' as const,
+      value: 'Voice mode disabled.',
+    }
+  }
+
+  // Toggle ON — run pre-flight checks first
+  const { isVoiceStreamAvailable } = await import(
+    '../../services/voiceStreamSTT.js'
+  )
+  const { checkRecordingAvailability } = await import('../../services/voice.js')
+
+  // Check recording availability (microphone access)
+  const recording = await checkRecordingAvailability()
+  if (!recording.available) {
+    return {
+      type: 'text' as const,
+      value:
+        recording.reason ?? 'Voice mode is not available in this environment.',
+    }
+  }
+
+  // Check for API key
+  if (!isVoiceStreamAvailable()) {
+    return {
+      type: 'text' as const,
+      value:
+        'Voice mode requires a Claude.ai account. Please run /login to sign in.',
+    }
+  }
+
+  // Check for recording tools
+  const { checkVoiceDependencies, requestMicrophonePermission } = await import(
+    '../../services/voice.js'
+  )
+  const deps = await checkVoiceDependencies()
+  if (!deps.available) {
+    const hint = deps.installCommand
+      ? `\nInstall audio recording tools? Run: ${deps.installCommand}`
+      : '\nInstall SoX manually for audio recording.'
+    return {
+      type: 'text' as const,
+      value: `No audio recording tool found.${hint}`,
+    }
+  }
+
+  // Probe mic access so the OS permission dialog fires now rather than
+  // on the user's first hold-to-talk activation.
+  if (!(await requestMicrophonePermission())) {
+    let guidance: string
+    if (process.platform === 'win32') {
+      guidance = 'Settings \u2192 Privacy \u2192 Microphone'
+    } else if (process.platform === 'linux') {
+      guidance = "your system's audio settings"
+    } else {
+      guidance = 'System Settings \u2192 Privacy & Security \u2192 Microphone'
+    }
+    return {
+      type: 'text' as const,
+      value: `Microphone access is denied. To enable it, go to ${guidance}, then run /voice again.`,
+    }
+  }
+
+  // All checks passed — enable voice
+  const result = updateSettingsForSource('userSettings', { voiceEnabled: true })
+  if (result.error) {
+    return {
+      type: 'text' as const,
+      value:
+        'Failed to update settings. Check your settings file for syntax errors.',
+    }
+  }
+  settingsChangeDetector.notifyChange('userSettings')
+  logEvent('tengu_voice_toggled', { enabled: true })
+  const key = getShortcutDisplay('voice:pushToTalk', 'Chat', 'Space')
+  const stt = normalizeLanguageForSTT(currentSettings.language)
+  const cfg = getGlobalConfig()
+  // Reset the hint counter whenever the resolved STT language changes
+  // (including first-ever enable, where lastLanguage is undefined).
+  const langChanged = cfg.voiceLangHintLastLanguage !== stt.code
+  const priorCount = langChanged ? 0 : (cfg.voiceLangHintShownCount ?? 0)
+  const showHint = !stt.fellBackFrom && priorCount < LANG_HINT_MAX_SHOWS
+  let langNote = ''
+  if (stt.fellBackFrom) {
+    langNote = ` Note: "${stt.fellBackFrom}" is not a supported dictation language; using English. Change it via /config.`
+  } else if (showHint) {
+    langNote = ` Dictation language: ${stt.code} (/config to change).`
+  }
+  if (langChanged || showHint) {
+    saveGlobalConfig(prev => ({
+      ...prev,
+      voiceLangHintShownCount: priorCount + (showHint ? 1 : 0),
+      voiceLangHintLastLanguage: stt.code,
+    }))
+  }
+  return {
+    type: 'text' as const,
+    value: `Voice mode enabled. Hold ${key} to record.${langNote}`,
+  }
+}

package/commands/xingest/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../types/command.js'
+
+const xingest: Command = {
+  type: 'local',
+  name: 'xingest',
+  description: 'Ingest current conversation into XMem memory',
+  supportsNonInteractive: true,
+  load: () => import('./xingest.js'),
+}
+
+export default xingest

package/commands/xingest/xingest.ts

@@ -0,0 +1,90 @@
+import type { LocalCommandResult, LocalCommand } from '../../types/command.js'
+import { xmemClient } from '../../utils/xmem.js'
+import { getInitialSettings } from '../../utils/settings/settings.js'
+import type { Message } from '../../types/message.js'
+
+function isModelVisibleMessage(message: Message): boolean {
+  return message.type === 'user' || message.type === 'assistant'
+}
+
+export const call: LocalCommand<never>['call'] = async (
+  args: string,
+  context
+): Promise<LocalCommandResult> => {
+  console.error('[XMem] /xingest command triggered')
+
+  // XMem is now always enabled by default
+
+  // Get messages from context
+  const messages = context.messages
+
+  if (!messages || messages.length === 0) {
+    console.error('[XMem] No messages to ingest')
+    return {
+      type: 'text',
+      value: '❌ No conversation messages found to ingest.',
+    }
+  }
+
+  // Filter to only model-visible messages
+  const visibleMessages = messages.filter(isModelVisibleMessage)
+  
+  console.error(`[XMem] Processing ${visibleMessages.length} visible messages`)
+
+  if (visibleMessages.length === 0) {
+    return {
+      type: 'text',
+      value: '❌ No visible conversation messages found to ingest.',
+    }
+  }
+
+  // Build user query and agent response from the conversation
+  let userQuery = ''
+  let agentResponse = ''
+
+  for (const msg of visibleMessages) {
+    if (msg.type === 'user') {
+      const content = msg.message.content
+      const text = typeof content === 'string' 
+        ? content 
+        : (Array.isArray(content) 
+            ? content.map(c => c.type === 'text' ? c.text : '').join('\n') 
+            : '')
+      userQuery += text + '\n'
+    } else if (msg.type === 'assistant') {
+      const content = msg.message.content
+      const text = typeof content === 'string' 
+        ? content 
+        : (Array.isArray(content) 
+            ? content.map(c => c.type === 'text' ? c.text : '').join('\n') 
+            : '')
+      agentResponse += text + '\n'
+    }
+  }
+
+  console.error(`[XMem] Ingesting - User query length: ${userQuery.length}, Agent response length: ${agentResponse.length}`)
+
+  try {
+    // Call XMem ingest API
+    await xmemClient.ingest({
+      user_query: userQuery.trim() || 'No user query',
+      agent_response: agentResponse.trim() || 'No agent response',
+      user_id: 'default_user'
+    })
+
+    console.error('[XMem] ✅ Successfully ingested to XMem')
+
+    return {
+      type: 'text',
+      value: `✅ Successfully ingested ${visibleMessages.length} messages to XMem memory.\n\nUser query preview: ${userQuery.substring(0, 100)}${userQuery.length > 100 ? '...' : ''}`,
+    }
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error)
+    console.error(`[XMem] ❌ Ingest failed: ${errorMsg}`)
+    
+    return {
+      type: 'text',
+      value: `❌ Failed to ingest to XMem: ${errorMsg}`,
+    }
+  }
+}

package/commands/xsearch/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../types/command.js'
+
+const xsearch: Command = {
+  type: 'local',
+  name: 'xsearch',
+  description: 'Search XMem memory and retrieve relevant context',
+  supportsNonInteractive: true,
+  load: () => import('./xsearch.js'),
+}
+
+export default xsearch

package/commands/xsearch/xsearch.ts

@@ -0,0 +1,56 @@
+import type { LocalCommandResult, LocalCommand } from '../../types/command.js'
+import { xmemClient } from '../../utils/xmem.js'
+import { getInitialSettings } from '../../utils/settings/settings.js'
+
+export const call: LocalCommand<never>['call'] = async (
+  args: string,
+  context
+): Promise<LocalCommandResult> => {
+  console.error('[XMem] /xsearch command triggered')
+
+  // XMem is now always enabled by default
+
+  // Get the query from args
+  const query = args.trim()
+
+  if (!query) {
+    return {
+      type: 'text',
+      value: 'Usage: /xsearch <your search query>\nExample: /xsearch what was the user name?',
+    }
+  }
+
+  console.error(`[XMem] Searching with query: "${query.substring(0, 50)}${query.length > 50 ? '...' : ''}"`)
+
+  try {
+    // Call XMem retrieve API
+    const result = await xmemClient.retrieve({
+      query: query,
+      user_id: 'default_user'
+    })
+
+    console.error(`[XMem] ✅ Successfully retrieved memory`)
+    console.error(`[XMem] Retrieved answer: ${result.answer.substring(0, 100)}${result.answer.length > 100 ? '...' : ''}`)
+
+    // Append to system message if appendSystemMessage is available
+    if (context.appendSystemMessage) {
+      context.appendSystemMessage({
+        role: 'system',
+        content: `## XMem Context (Retrieved Memory)\n\nQuery: "${query}"\n\nRetrieved Information:\n${result.answer}`,
+      })
+    }
+
+    return {
+      type: 'text',
+      value: `✅ Successfully retrieved from XMem memory.\n\nQuery: "${query}"\n\nRetrieved Context:\n${result.answer}`,
+    }
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error)
+    console.error(`[XMem] ❌ Search failed: ${errorMsg}`)
+    
+    return {
+      type: 'text',
+      value: `❌ Failed to search XMem: ${errorMsg}`,
+    }
+  }
+}