jupyterlab_ai_code_assistants_extension 0.6.15

package/src/__tests__/colour.spec.ts

@@ -0,0 +1,153 @@
+/**
+ * The colour ladder.
+ *
+ * Highest wins: a user-set colour, then the conversation's own colour for a
+ * `native` assistant, then the derived hash, then nothing. Each step is a pure
+ * function precisely so this can be asserted without a panel - the tint is the
+ * part that regressed twice behind a green suite that never ran the logic.
+ */
+
+import {
+  TAB_COLOUR_IDS,
+  effectiveColour,
+  fnv1aColour,
+  readUserSetTabColour,
+  sessionForCwds
+} from '../core/colour';
+import { ISession } from '../core/types';
+
+const SESSION_A = '11111111-1111-4111-8111-111111111111';
+const SESSION_B = '22222222-2222-4222-8222-222222222222';
+
+function session(projectPath: string, id: string): ISession {
+  return {
+    project_path: projectPath,
+    encoded_path: projectPath,
+    session_id: id,
+    name: projectPath,
+    name_source: 'basename',
+    message_count: 0,
+    file_mtime: 0,
+    git_branch: null,
+    favourite: false,
+    extra_sessions: 0
+  };
+}
+
+describe('fnv1aColour', () => {
+  it('answers one of the six tab colours', () => {
+    expect(TAB_COLOUR_IDS).toHaveLength(6);
+    expect(TAB_COLOUR_IDS).toContain(fnv1aColour(SESSION_A));
+  });
+
+  it('is stable for the same conversation', () => {
+    expect(fnv1aColour(SESSION_A)).toEqual(fnv1aColour(SESSION_A));
+  });
+
+  it('spreads across the vocabulary rather than answering one colour', () => {
+    const seen = new Set<string>();
+    for (let i = 0; i < 200; i++) {
+      seen.add(fnv1aColour(`session_${i}-abc`));
+    }
+    expect(seen.size).toBeGreaterThan(3);
+  });
+
+  it('agrees with the server hash, id for id', () => {
+    // Hard-coded from the Python `derived_colour` of the same ids: both sides
+    // hash the same string over the same six-colour order, so a conversation
+    // tints identically whichever one resolved it. A drift in either
+    // implementation - or in the order below - fails here.
+    expect(TAB_COLOUR_IDS).toEqual([
+      'rose',
+      'peach',
+      'lemon',
+      'mint',
+      'sky',
+      'lavender'
+    ]);
+    expect(fnv1aColour(SESSION_A)).toEqual('peach');
+    expect(fnv1aColour(SESSION_B)).toEqual('lavender');
+    expect(fnv1aColour('session_demo')).toEqual('peach');
+  });
+});
+
+describe('effectiveColour', () => {
+  it('lets a user-set colour beat every default', () => {
+    expect(effectiveColour(SESSION_A, 'native', 'sky', 'peach')).toEqual('sky');
+    expect(effectiveColour(SESSION_A, 'derived', 'sky', null)).toEqual('sky');
+    expect(effectiveColour(SESSION_A, 'none', 'sky', null)).toEqual('sky');
+  });
+
+  it('takes the assistant own colour for a native source', () => {
+    expect(effectiveColour(SESSION_A, 'native', null, 'peach')).toEqual(
+      'peach'
+    );
+    // A native provider with no colour recorded stays untinted - it must never
+    // fall through to the hash, which is another assistant's default.
+    expect(effectiveColour(SESSION_A, 'native', null, null)).toBeNull();
+  });
+
+  it('derives from the conversation id for a derived source', () => {
+    expect(effectiveColour(SESSION_A, 'derived', null, null)).toEqual(
+      fnv1aColour(SESSION_A)
+    );
+  });
+
+  it('answers nothing for a colourless source', () => {
+    expect(effectiveColour(SESSION_A, 'none', null, null)).toBeNull();
+  });
+
+  it('answers nothing without a conversation', () => {
+    expect(effectiveColour(null, 'derived', null, null)).toBeNull();
+    expect(effectiveColour(null, 'none', null, null)).toBeNull();
+  });
+});
+
+describe('readUserSetTabColour', () => {
+  afterEach(() => window.localStorage.clear());
+
+  it('reads the colourful-tab extension menu choice', () => {
+    window.localStorage.setItem(
+      'jupyterlab-colourful-tab-colours',
+      JSON.stringify({ 'terminal:1': 3 })
+    );
+    expect(readUserSetTabColour('1')).toEqual('mint');
+  });
+
+  it('answers null for a terminal with no choice, and never throws', () => {
+    expect(readUserSetTabColour('1')).toBeNull();
+    window.localStorage.setItem('jupyterlab-colourful-tab-colours', 'not json');
+    expect(readUserSetTabColour('1')).toBeNull();
+    window.localStorage.setItem(
+      'jupyterlab-colourful-tab-colours',
+      JSON.stringify({ 'terminal:1': 99 })
+    );
+    expect(readUserSetTabColour('1')).toBeNull();
+  });
+});
+
+describe('sessionForCwds', () => {
+  const parent = session('/home/lab/projects', SESSION_A);
+  const nested = session('/home/lab/projects/demo', SESSION_B);
+
+  it('lets the nested project win over its parent', () => {
+    expect(
+      sessionForCwds(['/home/lab/projects/demo'], [parent, nested])
+    ).toEqual(nested);
+  });
+
+  it('matches a subdirectory of a project', () => {
+    expect(
+      sessionForCwds(['/home/lab/projects/demo/src'], [parent, nested])
+    ).toEqual(nested);
+  });
+
+  it('does not match a sibling that merely shares a prefix', () => {
+    expect(sessionForCwds(['/home/lab/projects-old'], [parent])).toBeNull();
+  });
+
+  it('answers null when no project contains the cwd', () => {
+    expect(sessionForCwds(['/tmp'], [parent, nested])).toBeNull();
+    expect(sessionForCwds([], [parent])).toBeNull();
+  });
+});

package/src/__tests__/core-neutrality.spec.ts

@@ -0,0 +1,86 @@
+/**
+ * No assistant is named in `src/core/`.
+ *
+ * The architecture rests on it: adding or removing an assistant must touch one
+ * provider module and one barrel line, never a core file. A single `if (id ===
+ * 'claude')` is enough to break that promise, and it would never show up as a
+ * failing behaviour test - so the source itself is the assertion.
+ *
+ * Comments are stripped before the scan: the core is allowed to EXPLAIN why an
+ * assistant needed a capability flag, it is just not allowed to branch on one.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Every id the registry ships, plus the names of the retired extensions they
+// were ported from.
+const ASSISTANT_NAMES = /claude|codex|kimi|gemini|moonshot|anthropic/i;
+
+const CORE_DIR = path.resolve(__dirname, '..', 'core');
+
+/** Drop block and line comments, leaving code and string literals. */
+function stripComments(source: string): string {
+  return source
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/^[^\n]*?\/\/.*$/gm, line =>
+      // Keep the part before a trailing `//`, so code on a commented line is
+      // still scanned - but drop a whole-line comment entirely.
+      line.slice(0, line.indexOf('//'))
+    );
+}
+
+function coreFiles(): string[] {
+  return fs
+    .readdirSync(CORE_DIR)
+    .filter(name => name.endsWith('.ts'))
+    .map(name => path.join(CORE_DIR, name));
+}
+
+describe('the core names no assistant', () => {
+  it('has core files to scan at all', () => {
+    // Guards against the scan passing because it found nothing to read.
+    expect(coreFiles().length).toBeGreaterThan(3);
+  });
+
+  it.each(coreFiles().map(file => [path.basename(file), file]))(
+    '%s carries no assistant name outside comments',
+    (_name: string, file: string) => {
+      const code = stripComments(fs.readFileSync(file, 'utf8'));
+      const offenders = code
+        .split('\n')
+        .map((line, index) => [index + 1, line] as [number, string])
+        .filter(([, line]) => ASSISTANT_NAMES.test(line));
+      expect(offenders).toEqual([]);
+    }
+  );
+
+  it('reaches every assistant through the registry, not by name', () => {
+    // A core file importing a provider module directly is the same failure in
+    // a different shape, and the regex above would not catch a relative path.
+    for (const file of coreFiles()) {
+      const code = fs.readFileSync(file, 'utf8');
+      expect(code).not.toMatch(/from\s+'(\.\.\/)+providers/);
+    }
+  });
+});
+
+describe('the comment-stripping the scan relies on', () => {
+  it('drops a whole-line comment', () => {
+    expect(stripComments('// claude is the base\nconst x = 1;')).not.toMatch(
+      ASSISTANT_NAMES
+    );
+  });
+
+  it('drops a block comment', () => {
+    expect(
+      stripComments('/** ported from claude */\nconst x = 1;')
+    ).not.toMatch(ASSISTANT_NAMES);
+  });
+
+  it('keeps code that a trailing comment sits beside', () => {
+    expect(stripComments("const id = 'claude'; // the base")).toMatch(
+      ASSISTANT_NAMES
+    );
+  });
+});

package/src/__tests__/labels.spec.ts

@@ -0,0 +1,89 @@
+/**
+ * Menu-label truncation.
+ *
+ * Lumino sets no `max-width` on a menu item label, so an uncapped
+ * auto-generated title stretches a submenu across the window. The budget is in
+ * display COLUMNS, not characters: 60 Han glyphs measure at or above the width
+ * that filed the defect, while 60 Latin ones are half that.
+ */
+
+import {
+  MENU_TITLE_COLUMNS,
+  branchMenuLabel,
+  shortSessionId,
+  truncateToColumns
+} from '../providers/kimi';
+
+describe('truncateToColumns', () => {
+  it('leaves a short label alone, with no ellipsis', () => {
+    expect(truncateToColumns('Refactor the panel', 60)).toEqual(
+      'Refactor the panel'
+    );
+  });
+
+  it('counts a wide glyph as two columns', () => {
+    const han = '会'.repeat(40);
+    const cut = truncateToColumns(han, 10);
+    // Five glyphs fit in ten columns; the sixth would overflow.
+    expect(cut).toEqual('会'.repeat(5) + '…');
+  });
+
+  it('counts a Latin character as one column', () => {
+    expect(truncateToColumns('abcdefghij', 5)).toEqual('abcde…');
+  });
+
+  it('never splits an astral character into a lone surrogate', () => {
+    // An emoji is two code units and two columns: cutting by code unit would
+    // leave half a surrogate pair, which paints as the replacement glyph.
+    const cut = truncateToColumns('😀😀😀', 5);
+    expect(cut).toEqual('😀😀…');
+    expect(cut).not.toContain('�');
+    // Two emoji plus the ellipsis, counted by code point.
+    expect([...cut]).toHaveLength(3);
+  });
+
+  it('drops a trailing space so the ellipsis hugs the last word', () => {
+    expect(truncateToColumns('one two three', 8)).toEqual('one two…');
+  });
+
+  it('bounds a label at exactly the budget', () => {
+    const cut = truncateToColumns('x'.repeat(200), MENU_TITLE_COLUMNS);
+    expect(cut).toHaveLength(MENU_TITLE_COLUMNS + 1);
+  });
+
+  it('handles an empty label', () => {
+    expect(truncateToColumns('', 60)).toEqual('');
+  });
+});
+
+describe('shortSessionId', () => {
+  it('slices past the prefix every conversation shares', () => {
+    // The core front-slice would render the constant `session_` for every
+    // conversation of a project - the exact thing the short id exists to tell
+    // apart.
+    expect(
+      shortSessionId('session_9f8e7d6c-1111-2222-3333-444455556666')
+    ).toEqual('9f8e7d6c');
+  });
+
+  it('front-slices an id that carries no prefix', () => {
+    expect(shortSessionId('9f8e7d6c-1111-2222-3333-444455556666')).toEqual(
+      '9f8e7d6c'
+    );
+  });
+});
+
+describe('branchMenuLabel', () => {
+  it('keeps the id beside a truncated title', () => {
+    const title = '会'.repeat(100);
+    const label = branchMenuLabel(title, '9f8e7d6c');
+    expect(label.endsWith(' (9f8e7d6c)')).toBe(true);
+    // Branches of one project share a path, so the id is what tells them
+    // apart - only the title may be trimmed.
+    expect(label).toContain('…');
+  });
+
+  it('drops the bracketed id when the title already is the id', () => {
+    expect(branchMenuLabel('9f8e7d6c', '9f8e7d6c')).toEqual('9f8e7d6c');
+  });
+});

package/src/__tests__/launch-mode.spec.ts

@@ -0,0 +1,53 @@
+/**
+ * Launch-mode precedence.
+ *
+ * A provider can expose both a boolean switch and an enum ladder over the same
+ * approval surface, and the payload carries only one token. An enum moved off
+ * its default is the user's explicit statement, so it has to beat a boolean
+ * left on - otherwise a read-only ladder setting launches wide open.
+ */
+
+import { resolveLaunchMode } from '../core/modes';
+import { ILaunchMode } from '../core/types';
+
+const MODES: ILaunchMode[] = [
+  {
+    id: 'yoloMode',
+    title: 'YOLO',
+    description: 'Boolean switch.',
+    kind: 'boolean',
+    default: false
+  },
+  {
+    id: 'approvalMode',
+    title: 'Approval',
+    description: 'Enum ladder.',
+    kind: 'enum',
+    values: ['default', 'plan', 'yolo'],
+    default: 'default'
+  }
+];
+
+describe('resolveLaunchMode', () => {
+  it('lets a non-default enum beat a boolean that is on', () => {
+    expect(
+      resolveLaunchMode(MODES, { yoloMode: true, approvalMode: 'plan' })
+    ).toEqual('approvalMode=plan');
+  });
+
+  it('sends the boolean while every enum sits at its default', () => {
+    expect(
+      resolveLaunchMode(MODES, { yoloMode: true, approvalMode: 'default' })
+    ).toEqual('yoloMode');
+  });
+
+  it('sends nothing when no mode is set', () => {
+    expect(resolveLaunchMode(MODES, {})).toBeUndefined();
+  });
+
+  it('forces the requested mode whatever the settings say', () => {
+    expect(
+      resolveLaunchMode(MODES, { approvalMode: 'plan' }, 'yoloMode')
+    ).toEqual('yoloMode');
+  });
+});

package/src/__tests__/registry.spec.ts

@@ -0,0 +1,178 @@
+/**
+ * The frontend provider registry and the descriptor contract.
+ *
+ * Registration is the only place an id is asserted, and the core reads
+ * capability flags rather than ids - so a descriptor that claims a capability
+ * it cannot back, or two descriptors sharing an id, has to fail here rather
+ * than at render time.
+ */
+
+import { ProviderRegistry } from '../core/registry';
+import { IProviderDescriptor, IProviderModule } from '../core/types';
+import { PROVIDERS } from '../providers';
+
+// Every assistant shipped today. A provider added without reaching the barrel
+// fails here rather than silently costing the user a panel.
+const EXPECTED_IDS = ['claude', 'codex', 'kimi', 'gemini'];
+
+const FORK_STRATEGIES = ['native-flag', 'native-command', 'server-copy'];
+const COLOUR_SOURCES = ['native', 'derived', 'none'];
+const NAMING_STRATEGIES = ['launch-flag', 'server-side', 'none'];
+
+function stub(id: string): IProviderModule {
+  return {
+    descriptor: {
+      id,
+      label: id,
+      panelTitle: id,
+      iconName: `jupyterlab_ai_code_assistants_extension:${id}`,
+      iconSvg: '<svg/>',
+      cliBinary: id,
+      forkStrategy: 'server-copy',
+      colourSource: 'none',
+      namingStrategy: 'none',
+      mintsNewSessionId: false,
+      launchModes: [],
+      hasRemoteControl: false,
+      hasBgAgents: false,
+      hasLiveProcess: false
+    }
+  };
+}
+
+describe('the providers barrel', () => {
+  it('exports every registered assistant', () => {
+    expect(PROVIDERS.map(m => m.descriptor.id).sort()).toEqual(
+      [...EXPECTED_IDS].sort()
+    );
+  });
+
+  it('gives each assistant a unique id', () => {
+    const ids = PROVIDERS.map(m => m.descriptor.id);
+    expect(new Set(ids).size).toEqual(ids.length);
+  });
+
+  it.each(PROVIDERS.map(m => [m.descriptor.id, m.descriptor]))(
+    '%s satisfies the descriptor contract',
+    (_id: string, descriptor: IProviderDescriptor) => {
+      expect(descriptor.label.trim()).toBeTruthy();
+      expect(descriptor.panelTitle.trim()).toBeTruthy();
+      expect(descriptor.cliBinary.trim()).toBeTruthy();
+      // The icon name is namespaced so two providers' LabIcons never collide.
+      expect(descriptor.iconName).toEqual(
+        `jupyterlab_ai_code_assistants_extension:${descriptor.id}`
+      );
+      expect(descriptor.iconSvg).toContain('<svg');
+      expect(FORK_STRATEGIES).toContain(descriptor.forkStrategy);
+      expect(COLOUR_SOURCES).toContain(descriptor.colourSource);
+      expect(NAMING_STRATEGIES).toContain(descriptor.namingStrategy);
+      expect(typeof descriptor.mintsNewSessionId).toBe('boolean');
+      expect(typeof descriptor.hasRemoteControl).toBe('boolean');
+      expect(typeof descriptor.hasBgAgents).toBe('boolean');
+      expect(typeof descriptor.hasLiveProcess).toBe('boolean');
+    }
+  );
+
+  it.each(PROVIDERS.map(m => [m.descriptor.id, m.descriptor]))(
+    '%s declares its launch modes in its own terminology',
+    (_id: string, descriptor: IProviderDescriptor) => {
+      for (const mode of descriptor.launchModes) {
+        expect(mode.id.trim()).toBeTruthy();
+        expect(mode.title.trim()).toBeTruthy();
+        expect(mode.description.trim()).toBeTruthy();
+        if (mode.kind === 'boolean') {
+          // Every unsafe switch is off by default, without exception.
+          expect(mode.default).toBe(false);
+        } else {
+          expect(mode.values).toBeDefined();
+          expect(mode.values).toContain(mode.default as string);
+        }
+      }
+      const ids = descriptor.launchModes.map(m => m.id);
+      expect(new Set(ids).size).toEqual(ids.length);
+    }
+  );
+});
+
+describe('ProviderRegistry', () => {
+  it('keeps the barrel order', () => {
+    const registry = new ProviderRegistry(PROVIDERS);
+    expect(registry.ids).toEqual(PROVIDERS.map(m => m.descriptor.id));
+    expect(registry.descriptors.map(d => d.id)).toEqual(registry.ids);
+  });
+
+  it('throws on a duplicate id rather than shadowing one', () => {
+    expect(() => new ProviderRegistry([stub('twin'), stub('twin')])).toThrow(
+      /Duplicate/
+    );
+  });
+
+  it('ignores a module with no descriptor id, and warns once', () => {
+    const warn = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => undefined);
+    const registry = new ProviderRegistry([
+      { descriptor: undefined } as unknown as IProviderModule,
+      stub('alpha')
+    ]);
+    expect(registry.ids).toEqual(['alpha']);
+    expect(warn).toHaveBeenCalledTimes(1);
+    warn.mockRestore();
+  });
+
+  it('answers null for an id it does not know', () => {
+    const registry = new ProviderRegistry([stub('alpha')]);
+    expect(registry.has('alpha')).toBe(true);
+    expect(registry.has('stale')).toBe(false);
+    // A stale id in saved settings is a null, never a hard failure.
+    expect(registry.get('stale')).toBeNull();
+  });
+});
+
+describe('descriptor filtering', () => {
+  // Both halves of availability - the user's setting and the binary on PATH -
+  // must hold for a panel to be present. This is the predicate the activation
+  // path reconciles against.
+  const enabledAndAvailable = (
+    descriptors: IProviderDescriptor[],
+    settings: Record<string, boolean>,
+    available: Record<string, boolean>
+  ): string[] =>
+    descriptors
+      .filter(d => settings[d.id] !== false && available[d.id] === true)
+      .map(d => d.id);
+
+  const registry = new ProviderRegistry(PROVIDERS);
+
+  // `Object.fromEntries` is ES2019 and this project targets ES2018.
+  const allPresent = (): Record<string, boolean> => {
+    const out: Record<string, boolean> = {};
+    registry.ids.forEach(id => (out[id] = true));
+    return out;
+  };
+
+  it('docks a provider only when the setting and the binary agree', () => {
+    const all = allPresent();
+    expect(enabledAndAvailable(registry.descriptors, {}, all)).toEqual(
+      registry.ids
+    );
+    expect(
+      enabledAndAvailable(registry.descriptors, { claude: false }, all)
+    ).not.toContain('claude');
+    expect(
+      enabledAndAvailable(registry.descriptors, {}, { ...all, codex: false })
+    ).not.toContain('codex');
+  });
+
+  it('treats a missing enable key as enabled', () => {
+    const all = allPresent();
+    // Only an explicit `false` disables, so a fresh install runs everything.
+    expect(enabledAndAvailable(registry.descriptors, {}, all).length).toEqual(
+      registry.ids.length
+    );
+  });
+
+  it('leaves zero panels when nothing is available, without throwing', () => {
+    expect(enabledAndAvailable(registry.descriptors, {}, {})).toEqual([]);
+  });
+});