@vybestack/llxprt-ui 0.7.0-nightly.251211.5750c518a

package/src/features/completion/slash.ts

@@ -0,0 +1,248 @@
+interface SlashNode {
+  name: string;
+  description: string;
+  children?: SlashNode[];
+}
+
+let themeNodes: SlashNode[] = [];
+let profileNodes: SlashNode[] = [];
+
+export function setThemeSuggestions(
+  themes: { slug: string; name: string }[],
+): void {
+  themeNodes = themes.map((theme) => ({
+    name: theme.slug,
+    description: theme.name,
+  }));
+}
+
+export function setProfileSuggestions(profileNames: string[]): void {
+  profileNodes = profileNames.map((name) => ({
+    name,
+    description: `Profile: ${name}`,
+  }));
+}
+
+const SLASH_COMMANDS: SlashNode[] = [
+  { name: 'about', description: 'show version info' },
+  {
+    name: 'auth',
+    description:
+      'Open auth dialog or toggle OAuth enablement for providers (gemini, qwen, anthropic)',
+  },
+  { name: 'bug', description: 'submit a bug report' },
+  { name: 'chat', description: 'Manage conversation checkpoints' },
+  { name: 'clear', description: 'clear the screen and conversation history' },
+  {
+    name: 'compress',
+    description: 'Compresses the context by replacing it with a summary.',
+  },
+  {
+    name: 'copy',
+    description: 'Copy the last result or code snippet to clipboard',
+  },
+  {
+    name: 'docs',
+    description: 'open full LLxprt Code documentation in your browser',
+  },
+  { name: 'directory', description: 'Manage workspace directories' },
+  { name: 'editor', description: 'set external editor preference' },
+  { name: 'extensions', description: 'Manage extensions' },
+  { name: 'help', description: 'for help on LLxprt Code' },
+  { name: 'ide', description: 'manage IDE integration' },
+  {
+    name: 'init',
+    description: 'Analyzes the project and creates a tailored LLXPRT.md file.',
+  },
+  { name: 'model', description: 'Set the model id for the current provider' },
+  {
+    name: 'mcp',
+    description:
+      'list configured MCP servers and tools, or authenticate with OAuth-enabled servers',
+  },
+  { name: 'memory', description: 'Commands for interacting with memory.' },
+  {
+    name: 'privacy',
+    description: 'view Gemini API privacy disclosure and terms',
+  },
+  { name: 'logging', description: 'manage conversation logging settings' },
+  {
+    name: 'provider',
+    description: 'Set the provider (openai | gemini | anthropic)',
+  },
+  { name: 'baseurl', description: 'Set the provider base URL' },
+  { name: 'key', description: 'Set the API key' },
+  { name: 'keyfile', description: 'Set the API keyfile path' },
+  {
+    name: 'profile',
+    description: 'Load a profile',
+    children: [
+      {
+        name: 'load',
+        description: 'Load a profile by name',
+        children: profileNodes,
+      },
+    ],
+  },
+  { name: 'quit', description: 'exit the cli' },
+  {
+    name: 'stats',
+    description: 'check session stats. Usage: /stats [model|tools|cache]',
+    children: [
+      { name: 'model', description: 'Show model-specific usage statistics.' },
+      { name: 'tools', description: 'Show tool-specific usage statistics.' },
+      {
+        name: 'cache',
+        description: 'Show cache usage statistics (Anthropic only).',
+      },
+    ],
+  },
+  { name: 'theme', description: 'change the theme' },
+  { name: 'tools', description: 'List, enable, or disable Gemini CLI tools' },
+  { name: 'settings', description: 'View and edit LLxprt Code settings' },
+  { name: 'vim', description: 'toggle vim mode on/off' },
+  {
+    name: 'set',
+    description: 'Set an option',
+    children: [
+      { name: 'unset', description: 'Unset option' },
+      { name: 'modelparam', description: 'Model parameter option' },
+      {
+        name: 'emojifilter',
+        description: 'Emoji filter option',
+        children: [
+          { name: 'allowed', description: 'Allow all emojis' },
+          {
+            name: 'auto',
+            description: 'Automatically filter inappropriate emojis',
+          },
+          { name: 'warn', description: 'Warn about filtered emojis' },
+          { name: 'error', description: 'Error on filtered emojis' },
+        ],
+      },
+      { name: 'context-limit', description: 'Context Limit option' },
+      {
+        name: 'compression-threshold',
+        description: 'Compression Threshold option',
+      },
+      { name: 'base-url', description: 'Base Url option' },
+      { name: 'api-version', description: 'Api Version option' },
+      { name: 'streaming', description: 'Streaming option' },
+    ],
+  },
+];
+
+export interface SlashSuggestion {
+  value: string;
+  description: string;
+  fullPath: string;
+  hasChildren: boolean;
+}
+
+export function getSlashSuggestions(
+  parts: string[],
+  limit: number,
+): SlashSuggestion[] {
+  const prefixParts = parts.slice(0, Math.max(parts.length - 1, 0));
+  const query = parts[parts.length - 1] ?? '';
+  const nodeList = resolvePath(prefixParts);
+
+  if (nodeList.length === 0) {
+    return [];
+  }
+
+  const normalized = query.toLowerCase();
+
+  const suggestions = nodeList
+    .filter((node) => node.name.toLowerCase().startsWith(normalized))
+    .sort((a, b) => {
+      const aStarts = a.name.toLowerCase().startsWith(normalized);
+      const bStarts = b.name.toLowerCase().startsWith(normalized);
+      if (aStarts !== bStarts) {
+        return aStarts ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    })
+    .slice(0, limit)
+    .map((node) => ({
+      value: node.name,
+      description: node.description,
+      fullPath: buildFullPath(parts, node.name),
+      hasChildren: Boolean(node.children?.length),
+    }));
+
+  return suggestions;
+}
+
+export function extractSlashContext(
+  input: string,
+  cursorOffset: number,
+): { parts: string[]; start: number; end: number } | null {
+  const safeOffset = Math.min(Math.max(cursorOffset, 0), input.length);
+  const upToCursor = input.slice(0, safeOffset);
+  const slashIndex = upToCursor.lastIndexOf('/');
+
+  if (slashIndex === -1) {
+    return null;
+  }
+
+  if (slashIndex > 0 && /\S/.test(upToCursor[slashIndex - 1] ?? '')) {
+    return null;
+  }
+
+  let end = safeOffset;
+  while (end < input.length) {
+    const char = input[end] ?? '';
+    if (char === '\n') {
+      break;
+    }
+    if (char.trim() === '') {
+      break;
+    }
+    end += 1;
+  }
+
+  const token = input.slice(slashIndex + 1, end);
+  const parts = token.length === 0 ? [] : token.split(/\s+/);
+
+  return { parts, start: slashIndex, end };
+}
+
+function resolvePath(parts: string[]): SlashNode[] {
+  if (parts.length === 0) {
+    return SLASH_COMMANDS;
+  }
+  if (parts.length >= 1 && parts[0] === 'theme') {
+    return parts.length === 1 ? themeNodes : [];
+  }
+  if (parts.length === 1 && parts[0] === 'profile') {
+    return [
+      {
+        name: 'load',
+        description: 'Load a profile by name',
+        children: profileNodes,
+      },
+    ];
+  }
+  if (parts.length === 2 && parts[0] === 'profile' && parts[1] === 'load') {
+    return profileNodes;
+  }
+  let current: SlashNode[] = SLASH_COMMANDS;
+  for (const part of parts) {
+    const node = current.find((n) => n.name === part);
+    if (!node?.children) {
+      return [];
+    }
+    current = node.children;
+  }
+  return current;
+}
+
+function buildFullPath(parts: string[], next: string): string {
+  const existing = [...parts];
+  if (existing.length === 0) {
+    return `/${next}`;
+  }
+  const pathParts = [...existing.slice(0, -1), next];
+  return `/${pathParts.join(' ')}`;
+}

package/src/features/completion/suggestions.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+import {
+  extractMentionQuery,
+  findMentionRange,
+  getSuggestions,
+} from './suggestions';
+
+describe('getSuggestions', () => {
+  it('returns matches starting with query first', () => {
+    const results = getSuggestions('A');
+    expect(results[0]).toBe('Abacadbras.tsx');
+  });
+
+  it('prioritizes files over directories for shared prefix', () => {
+    const results = getSuggestions('p');
+    expect(results[0]).toBe('package.json');
+    expect(results[1]).toBe('packages/');
+  });
+
+  it('returns exact subpath matches', () => {
+    const results = getSuggestions('src');
+    expect(results[0]).toBe('packages/src');
+  });
+
+  it('returns empty when no matches', () => {
+    expect(getSuggestions('b')).toHaveLength(0);
+  });
+});
+
+describe('extractMentionQuery', () => {
+  it('extracts query after @ before cursor', () => {
+    expect(extractMentionQuery('hello @pac', 10)).toBe('pac');
+  });
+
+  it('returns null when no @', () => {
+    expect(extractMentionQuery('hello world', 5)).toBeNull();
+  });
+
+  it('ignores @ inside words', () => {
+    expect(extractMentionQuery('hello@pac', 9)).toBeNull();
+  });
+
+  it('finds mention range for replacement', () => {
+    const range = findMentionRange('test @pa th', 8);
+    expect(range).toStrictEqual({ start: 5, end: 8 });
+  });
+
+  it('returns null range when none', () => {
+    expect(findMentionRange('test', 2)).toBeNull();
+  });
+});

package/src/features/completion/suggestions.ts

@@ -0,0 +1,112 @@
+const FILE_ENTRIES = [
+  'Abacadbras.tsx',
+  'README.md',
+  'Zapper.ts',
+  'packages/',
+  'packages/src',
+  'packages/src/Main.ts',
+  'packages/src/Other.ts',
+  'package.json',
+] as const;
+
+const MAX_SUGGESTIONS = 5;
+
+export function getSuggestions(
+  query: string,
+  limit: number = MAX_SUGGESTIONS,
+): string[] {
+  const normalized = query.trim().toLowerCase();
+
+  const matches = FILE_ENTRIES.filter((entry) => {
+    const segments = entry.split('/').filter(Boolean);
+    if (normalized.length === 0) {
+      return true;
+    }
+    return segments.some((segment) =>
+      segment.toLowerCase().startsWith(normalized),
+    );
+  });
+
+  const sorted = [...matches].sort((a, b) => {
+    const aSegments = a.split('/').filter(Boolean);
+    const bSegments = b.split('/').filter(Boolean);
+
+    const aIsFile = isFile(a);
+    const bIsFile = isFile(b);
+
+    if (aSegments.length !== bSegments.length) {
+      return aSegments.length - bSegments.length;
+    }
+
+    if (aIsFile !== bIsFile) {
+      return aIsFile ? -1 : 1;
+    }
+
+    if (a.length !== b.length) {
+      return a.length - b.length;
+    }
+
+    return a.toLowerCase().localeCompare(b.toLowerCase());
+  });
+
+  return sorted.slice(0, limit);
+}
+
+export function extractMentionQuery(
+  input: string,
+  cursorOffset: number,
+): string | null {
+  const safeOffset = Math.min(Math.max(cursorOffset, 0), input.length);
+  const upToCursor = input.slice(0, safeOffset);
+  const atIndex = upToCursor.lastIndexOf('@');
+
+  if (atIndex === -1) {
+    return null;
+  }
+
+  if (atIndex > 0 && /\S/.test(upToCursor[atIndex - 1] ?? '')) {
+    return null;
+  }
+
+  const tail = upToCursor.slice(atIndex + 1);
+  const query = tail.split(/\s|\n/)[0] ?? '';
+  return query;
+}
+
+export function findMentionRange(
+  input: string,
+  cursorOffset: number,
+): { start: number; end: number } | null {
+  const safeOffset = Math.min(Math.max(cursorOffset, 0), input.length);
+  const upToCursor = input.slice(0, safeOffset);
+  const atIndex = upToCursor.lastIndexOf('@');
+
+  if (atIndex === -1) {
+    return null;
+  }
+
+  if (atIndex > 0 && /\S/.test(upToCursor[atIndex - 1] ?? '')) {
+    return null;
+  }
+
+  let end = safeOffset;
+  while (end < input.length) {
+    const char = input[end] ?? '';
+    if (char === '\n' || char.trim() === '') {
+      break;
+    }
+    end += 1;
+  }
+
+  return { start: atIndex, end };
+}
+
+export const SUGGESTION_SOURCE = FILE_ENTRIES;
+export const MAX_SUGGESTION_COUNT = MAX_SUGGESTIONS;
+
+function isFile(entry: string): boolean {
+  if (entry.endsWith('/')) {
+    return false;
+  }
+  return entry.includes('.');
+}

package/src/features/config/configSession.test.ts

@@ -0,0 +1,189 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createConfigSession } from './configSession';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+describe('ConfigSession', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nui-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('createConfigSession', () => {
+    it('should create Config with minimal required parameters', () => {
+      const session = createConfigSession({
+        model: 'gemini-2.5-flash',
+        workingDir: tempDir,
+      });
+
+      expect(session.config).toBeDefined();
+      expect(session.config.getModel()).toBe('gemini-2.5-flash');
+    });
+
+    it('should apply provider setting', () => {
+      const session = createConfigSession({
+        model: 'gpt-4',
+        provider: 'openai',
+        workingDir: tempDir,
+      });
+
+      expect(session.config.getProvider()).toBe('openai');
+    });
+
+    it('should disable telemetry by default', () => {
+      const session = createConfigSession({
+        model: 'gemini-2.5-flash',
+        workingDir: tempDir,
+      });
+
+      expect(session.config.getTelemetryEnabled()).toBe(false);
+    });
+  });
+
+  describe('initialize', () => {
+    it('should make GeminiClient available after initialization', async () => {
+      const session = createConfigSession({
+        model: 'gemini-2.5-flash',
+        workingDir: tempDir,
+      });
+
+      await session.initialize();
+
+      expect(session.getClient()).toBeDefined();
+    });
+
+    it('should register tools in ToolRegistry', async () => {
+      const session = createConfigSession({
+        model: 'gemini-2.5-flash',
+        workingDir: tempDir,
+      });
+
+      await session.initialize();
+
+      const registry = session.config.getToolRegistry();
+      const tools = registry.getFunctionDeclarations();
+
+      expect(tools.length).toBeGreaterThan(0);
+    });
+
+    it('should be idempotent', async () => {
+      const session = createConfigSession({
+        model: 'gemini-2.5-flash',
+        workingDir: tempDir,
+      });
+
+      await session.initialize();
+      await session.initialize();
+
+      expect(session.getClient()).toBeDefined();
+    });
+  });
+
+  describe('getClient', () => {
+    it('should throw if called before initialize', () => {
+      const session = createConfigSession({
+        model: 'gemini-2.5-flash',
+        workingDir: tempDir,
+      });
+
+      expect(() => session.getClient()).toThrow(
+        'ConfigSession not initialized. Call initialize() first.',
+      );
+    });
+  });
+
+  describe('provider initialization', () => {
+    // Provider initialization is slow on Windows CI due to ProviderManager setup
+    it(
+      'should initialize with OpenAI provider without error',
+      { timeout: 15000 },
+      async () => {
+        const session = createConfigSession({
+          model: 'gpt-4',
+          provider: 'openai',
+          baseUrl: 'https://api.openai.com/v1',
+          apiKey: 'test-key',
+          workingDir: tempDir,
+        });
+
+        // This should NOT throw - the test ensures the auth flow works
+        await session.initialize();
+
+        expect(session.getClient()).toBeDefined();
+      },
+    );
+
+    it(
+      'should initialize with Anthropic provider without error',
+      { timeout: 15000 },
+      async () => {
+        const session = createConfigSession({
+          model: 'claude-3-sonnet',
+          provider: 'anthropic',
+          baseUrl: 'https://api.anthropic.com',
+          apiKey: 'test-key',
+          workingDir: tempDir,
+        });
+
+        // This should NOT throw - the test ensures the auth flow works
+        await session.initialize();
+
+        expect(session.getClient()).toBeDefined();
+      },
+    );
+
+    it('should initialize with Gemini provider without error', async () => {
+      const session = createConfigSession({
+        model: 'gemini-2.5-flash',
+        provider: 'gemini',
+        apiKey: 'test-key',
+        workingDir: tempDir,
+      });
+
+      await session.initialize();
+
+      expect(session.getClient()).toBeDefined();
+    });
+
+    it(
+      'should set up ProviderManager for OpenAI provider',
+      { timeout: 15000 },
+      async () => {
+        const session = createConfigSession({
+          model: 'gpt-4',
+          provider: 'openai',
+          baseUrl: 'https://api.openai.com/v1',
+          apiKey: 'test-key',
+          workingDir: tempDir,
+        });
+
+        await session.initialize();
+
+        // ProviderManager should be set for non-gemini providers
+        const providerManager = session.config.getProviderManager();
+        expect(providerManager).toBeDefined();
+      },
+    );
+
+    it('should NOT set up ProviderManager for Gemini provider', async () => {
+      const session = createConfigSession({
+        model: 'gemini-2.5-flash',
+        provider: 'gemini',
+        apiKey: 'test-key',
+        workingDir: tempDir,
+      });
+
+      await session.initialize();
+
+      // ProviderManager should NOT be set for Gemini
+      const providerManager = session.config.getProviderManager();
+      expect(providerManager).toBeUndefined();
+    });
+  });
+});