fss-link 1.0.40 → 1.0.45

package/dist/ui/keyMatchers.test.ts

@@ -0,0 +1,337 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { keyMatchers, Command, createKeyMatchers } from './keyMatchers.js';
+import { KeyBindingConfig, defaultKeyBindings } from '../config/keyBindings.js';
+import type { Key } from './hooks/useKeypress.js';
+
+describe('keyMatchers', () => {
+  const createKey = (name: string, mods: Partial<Key> = {}): Key => ({
+    name,
+    ctrl: false,
+    meta: false,
+    shift: false,
+    paste: false,
+    sequence: name,
+    ...mods,
+  });
+
+  // Original hard-coded logic (for comparison)
+  const originalMatchers: Record<Command, (key: Key) => boolean> = {
+    [Command.RETURN]: (key: Key) => key.name === 'return',
+    [Command.HOME]: (key: Key) => key.ctrl && key.name === 'a',
+    [Command.END]: (key: Key) => key.ctrl && key.name === 'e',
+    [Command.KILL_LINE_RIGHT]: (key: Key) => key.ctrl && key.name === 'k',
+    [Command.KILL_LINE_LEFT]: (key: Key) => key.ctrl && key.name === 'u',
+    [Command.CLEAR_INPUT]: (key: Key) => key.ctrl && key.name === 'c',
+    [Command.CLEAR_SCREEN]: (key: Key) => key.ctrl && key.name === 'l',
+    [Command.HISTORY_UP]: (key: Key) => key.ctrl && key.name === 'p',
+    [Command.HISTORY_DOWN]: (key: Key) => key.ctrl && key.name === 'n',
+    [Command.NAVIGATION_UP]: (key: Key) => key.name === 'up',
+    [Command.NAVIGATION_DOWN]: (key: Key) => key.name === 'down',
+    [Command.ACCEPT_SUGGESTION]: (key: Key) =>
+      key.name === 'tab' || (key.name === 'return' && !key.ctrl),
+    [Command.COMPLETION_UP]: (key: Key) =>
+      key.name === 'up' || (key.ctrl && key.name === 'p'),
+    [Command.COMPLETION_DOWN]: (key: Key) =>
+      key.name === 'down' || (key.ctrl && key.name === 'n'),
+    [Command.ESCAPE]: (key: Key) => key.name === 'escape',
+    [Command.SUBMIT]: (key: Key) =>
+      key.name === 'return' && !key.ctrl && !key.meta && !key.paste,
+    [Command.NEWLINE]: (key: Key) =>
+      key.name === 'return' && (key.ctrl || key.meta || key.paste),
+    [Command.OPEN_EXTERNAL_EDITOR]: (key: Key) =>
+      key.ctrl && (key.name === 'x' || key.sequence === '\x18'),
+    [Command.PASTE_CLIPBOARD_IMAGE]: (key: Key) => key.ctrl && key.name === 'v',
+    [Command.SHOW_ERROR_DETAILS]: (key: Key) => key.ctrl && key.name === 'o',
+    [Command.TOGGLE_TOOL_DESCRIPTIONS]: (key: Key) =>
+      key.ctrl && key.name === 't',
+    [Command.TOGGLE_IDE_CONTEXT_DETAIL]: (key: Key) =>
+      key.ctrl && key.name === 'g',
+    [Command.QUIT]: (key: Key) => key.ctrl && key.name === 'c',
+    [Command.EXIT]: (key: Key) => key.ctrl && key.name === 'd',
+    [Command.SHOW_MORE_LINES]: (key: Key) => key.ctrl && key.name === 's',
+    [Command.REVERSE_SEARCH]: (key: Key) => key.ctrl && key.name === 'r',
+    [Command.SUBMIT_REVERSE_SEARCH]: (key: Key) =>
+      key.name === 'return' && !key.ctrl,
+    [Command.ACCEPT_SUGGESTION_REVERSE_SEARCH]: (key: Key) =>
+      key.name === 'tab',
+  };
+
+  // Test data for each command with positive and negative test cases
+  const testCases = [
+    // Basic bindings
+    {
+      command: Command.RETURN,
+      positive: [createKey('return')],
+      negative: [createKey('r')],
+    },
+    {
+      command: Command.ESCAPE,
+      positive: [createKey('escape'), createKey('escape', { ctrl: true })],
+      negative: [createKey('e'), createKey('esc')],
+    },
+
+    // Cursor movement
+    {
+      command: Command.HOME,
+      positive: [createKey('a', { ctrl: true })],
+      negative: [
+        createKey('a'),
+        createKey('a', { shift: true }),
+        createKey('b', { ctrl: true }),
+      ],
+    },
+    {
+      command: Command.END,
+      positive: [createKey('e', { ctrl: true })],
+      negative: [
+        createKey('e'),
+        createKey('e', { shift: true }),
+        createKey('a', { ctrl: true }),
+      ],
+    },
+
+    // Text deletion
+    {
+      command: Command.KILL_LINE_RIGHT,
+      positive: [createKey('k', { ctrl: true })],
+      negative: [createKey('k'), createKey('l', { ctrl: true })],
+    },
+    {
+      command: Command.KILL_LINE_LEFT,
+      positive: [createKey('u', { ctrl: true })],
+      negative: [createKey('u'), createKey('k', { ctrl: true })],
+    },
+    {
+      command: Command.CLEAR_INPUT,
+      positive: [createKey('c', { ctrl: true })],
+      negative: [createKey('c'), createKey('k', { ctrl: true })],
+    },
+
+    // Screen control
+    {
+      command: Command.CLEAR_SCREEN,
+      positive: [createKey('l', { ctrl: true })],
+      negative: [createKey('l'), createKey('k', { ctrl: true })],
+    },
+
+    // History navigation
+    {
+      command: Command.HISTORY_UP,
+      positive: [createKey('p', { ctrl: true })],
+      negative: [createKey('p'), createKey('up')],
+    },
+    {
+      command: Command.HISTORY_DOWN,
+      positive: [createKey('n', { ctrl: true })],
+      negative: [createKey('n'), createKey('down')],
+    },
+    {
+      command: Command.NAVIGATION_UP,
+      positive: [createKey('up'), createKey('up', { ctrl: true })],
+      negative: [createKey('p'), createKey('u')],
+    },
+    {
+      command: Command.NAVIGATION_DOWN,
+      positive: [createKey('down'), createKey('down', { ctrl: true })],
+      negative: [createKey('n'), createKey('d')],
+    },
+
+    // Auto-completion
+    {
+      command: Command.ACCEPT_SUGGESTION,
+      positive: [createKey('tab'), createKey('return')],
+      negative: [createKey('return', { ctrl: true }), createKey('space')],
+    },
+    {
+      command: Command.COMPLETION_UP,
+      positive: [createKey('up'), createKey('p', { ctrl: true })],
+      negative: [createKey('p'), createKey('down')],
+    },
+    {
+      command: Command.COMPLETION_DOWN,
+      positive: [createKey('down'), createKey('n', { ctrl: true })],
+      negative: [createKey('n'), createKey('up')],
+    },
+
+    // Text input
+    {
+      command: Command.SUBMIT,
+      positive: [createKey('return')],
+      negative: [
+        createKey('return', { ctrl: true }),
+        createKey('return', { meta: true }),
+        createKey('return', { paste: true }),
+      ],
+    },
+    {
+      command: Command.NEWLINE,
+      positive: [
+        createKey('return', { ctrl: true }),
+        createKey('return', { meta: true }),
+        createKey('return', { paste: true }),
+      ],
+      negative: [createKey('return'), createKey('n')],
+    },
+
+    // External tools
+    {
+      command: Command.OPEN_EXTERNAL_EDITOR,
+      positive: [
+        createKey('x', { ctrl: true }),
+        { ...createKey('\x18'), sequence: '\x18', ctrl: true },
+      ],
+      negative: [createKey('x'), createKey('c', { ctrl: true })],
+    },
+    {
+      command: Command.PASTE_CLIPBOARD_IMAGE,
+      positive: [createKey('v', { ctrl: true })],
+      negative: [createKey('v'), createKey('c', { ctrl: true })],
+    },
+
+    // App level bindings
+    {
+      command: Command.SHOW_ERROR_DETAILS,
+      positive: [createKey('o', { ctrl: true })],
+      negative: [createKey('o'), createKey('e', { ctrl: true })],
+    },
+    {
+      command: Command.TOGGLE_TOOL_DESCRIPTIONS,
+      positive: [createKey('t', { ctrl: true })],
+      negative: [createKey('t'), createKey('s', { ctrl: true })],
+    },
+    {
+      command: Command.TOGGLE_IDE_CONTEXT_DETAIL,
+      positive: [createKey('g', { ctrl: true })],
+      negative: [createKey('g'), createKey('t', { ctrl: true })],
+    },
+    {
+      command: Command.QUIT,
+      positive: [createKey('c', { ctrl: true })],
+      negative: [createKey('c'), createKey('d', { ctrl: true })],
+    },
+    {
+      command: Command.EXIT,
+      positive: [createKey('d', { ctrl: true })],
+      negative: [createKey('d'), createKey('c', { ctrl: true })],
+    },
+    {
+      command: Command.SHOW_MORE_LINES,
+      positive: [createKey('s', { ctrl: true })],
+      negative: [createKey('s'), createKey('l', { ctrl: true })],
+    },
+
+    // Shell commands
+    {
+      command: Command.REVERSE_SEARCH,
+      positive: [createKey('r', { ctrl: true })],
+      negative: [createKey('r'), createKey('s', { ctrl: true })],
+    },
+    {
+      command: Command.SUBMIT_REVERSE_SEARCH,
+      positive: [createKey('return')],
+      negative: [createKey('return', { ctrl: true }), createKey('tab')],
+    },
+    {
+      command: Command.ACCEPT_SUGGESTION_REVERSE_SEARCH,
+      positive: [createKey('tab'), createKey('tab', { ctrl: true })],
+      negative: [createKey('return'), createKey('space')],
+    },
+  ];
+
+  describe('Data-driven key binding matches original logic', () => {
+    testCases.forEach(({ command, positive, negative }) => {
+      it(`should match ${command} correctly`, () => {
+        positive.forEach((key) => {
+          expect(
+            keyMatchers[command](key),
+            `Expected ${command} to match ${JSON.stringify(key)}`,
+          ).toBe(true);
+          expect(
+            originalMatchers[command](key),
+            `Original matcher should also match ${JSON.stringify(key)}`,
+          ).toBe(true);
+        });
+
+        negative.forEach((key) => {
+          expect(
+            keyMatchers[command](key),
+            `Expected ${command} to NOT match ${JSON.stringify(key)}`,
+          ).toBe(false);
+          expect(
+            originalMatchers[command](key),
+            `Original matcher should also NOT match ${JSON.stringify(key)}`,
+          ).toBe(false);
+        });
+      });
+    });
+
+    it('should properly handle ACCEPT_SUGGESTION_REVERSE_SEARCH cases', () => {
+      expect(
+        keyMatchers[Command.ACCEPT_SUGGESTION_REVERSE_SEARCH](
+          createKey('return', { ctrl: true }),
+        ),
+      ).toBe(false); // ctrl must be false
+      expect(
+        keyMatchers[Command.ACCEPT_SUGGESTION_REVERSE_SEARCH](createKey('tab')),
+      ).toBe(true);
+      expect(
+        keyMatchers[Command.ACCEPT_SUGGESTION_REVERSE_SEARCH](
+          createKey('tab', { ctrl: true }),
+        ),
+      ).toBe(true); // modifiers ignored
+    });
+  });
+
+  describe('Custom key bindings', () => {
+    it('should work with custom configuration', () => {
+      const customConfig: KeyBindingConfig = {
+        ...defaultKeyBindings,
+        [Command.HOME]: [{ key: 'h', ctrl: true }, { key: '0' }],
+      };
+
+      const customMatchers = createKeyMatchers(customConfig);
+
+      expect(customMatchers[Command.HOME](createKey('h', { ctrl: true }))).toBe(
+        true,
+      );
+      expect(customMatchers[Command.HOME](createKey('0'))).toBe(true);
+      expect(customMatchers[Command.HOME](createKey('a', { ctrl: true }))).toBe(
+        false,
+      );
+    });
+
+    it('should support multiple key bindings for same command', () => {
+      const config: KeyBindingConfig = {
+        ...defaultKeyBindings,
+        [Command.QUIT]: [
+          { key: 'q', ctrl: true },
+          { key: 'q', command: true },
+        ],
+      };
+
+      const matchers = createKeyMatchers(config);
+      expect(matchers[Command.QUIT](createKey('q', { ctrl: true }))).toBe(true);
+      expect(matchers[Command.QUIT](createKey('q', { meta: true }))).toBe(true);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle empty binding arrays', () => {
+      const config: KeyBindingConfig = {
+        ...defaultKeyBindings,
+        [Command.HOME]: [],
+      };
+
+      const matchers = createKeyMatchers(config);
+      expect(matchers[Command.HOME](createKey('a', { ctrl: true }))).toBe(
+        false,
+      );
+    });
+  });
+});

package/dist/ui/keyMatchers.ts

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Key } from './hooks/useKeypress.js';
+import {
+  Command,
+  KeyBinding,
+  KeyBindingConfig,
+  defaultKeyBindings,
+} from '../config/keyBindings.js';
+
+/**
+ * Matches a KeyBinding against an actual Key press
+ * Pure data-driven matching logic
+ */
+function matchKeyBinding(keyBinding: KeyBinding, key: Key): boolean {
+  // Either key name or sequence must match (but not both should be defined)
+  let keyMatches = false;
+
+  if (keyBinding.key !== undefined) {
+    keyMatches = keyBinding.key === key.name;
+  } else if (keyBinding.sequence !== undefined) {
+    keyMatches = keyBinding.sequence === key.sequence;
+  } else {
+    // Neither key nor sequence defined - invalid binding
+    return false;
+  }
+
+  if (!keyMatches) {
+    return false;
+  }
+
+  // Check modifiers - follow original logic:
+  // undefined = ignore this modifier (original behavior)
+  // true = modifier must be pressed
+  // false = modifier must NOT be pressed
+
+  if (keyBinding.ctrl !== undefined && key.ctrl !== keyBinding.ctrl) {
+    return false;
+  }
+
+  if (keyBinding.shift !== undefined && key.shift !== keyBinding.shift) {
+    return false;
+  }
+
+  if (keyBinding.command !== undefined && key.meta !== keyBinding.command) {
+    return false;
+  }
+
+  if (keyBinding.paste !== undefined && key.paste !== keyBinding.paste) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Checks if a key matches any of the bindings for a command
+ */
+function matchCommand(
+  command: Command,
+  key: Key,
+  config: KeyBindingConfig = defaultKeyBindings,
+): boolean {
+  const bindings = config[command];
+  return bindings.some((binding) => matchKeyBinding(binding, key));
+}
+
+/**
+ * Key matcher function type
+ */
+type KeyMatcher = (key: Key) => boolean;
+
+/**
+ * Type for key matchers mapped to Command enum
+ */
+export type KeyMatchers = {
+  readonly [C in Command]: KeyMatcher;
+};
+
+/**
+ * Creates key matchers from a key binding configuration
+ */
+export function createKeyMatchers(
+  config: KeyBindingConfig = defaultKeyBindings,
+): KeyMatchers {
+  const matchers = {} as { [C in Command]: KeyMatcher };
+
+  for (const command of Object.values(Command)) {
+    matchers[command] = (key: Key) => matchCommand(command, key, config);
+  }
+
+  return matchers as KeyMatchers;
+}
+
+/**
+ * Default key binding matchers using the default configuration
+ */
+export const keyMatchers: KeyMatchers = createKeyMatchers(defaultKeyBindings);
+
+// Re-export Command for convenience
+export { Command };

package/dist/ui/privacy/CloudFreePrivacyNotice.tsx

@@ -0,0 +1,117 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box, Newline, Text } from 'ink';
+import { RadioButtonSelect } from '../components/shared/RadioButtonSelect.js';
+import { usePrivacySettings } from '../hooks/usePrivacySettings.js';
+import { CloudPaidPrivacyNotice } from './CloudPaidPrivacyNotice.js';
+import { Config } from 'fss-link-core';
+import { Colors } from '../colors.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+
+interface CloudFreePrivacyNoticeProps {
+  config: Config;
+  onExit: () => void;
+}
+
+export const CloudFreePrivacyNotice = ({
+  config,
+  onExit,
+}: CloudFreePrivacyNoticeProps) => {
+  const { privacyState, updateDataCollectionOptIn } =
+    usePrivacySettings(config);
+
+  useKeypress(
+    (key) => {
+      if (privacyState.error && key.name === 'escape') {
+        onExit();
+      }
+    },
+    { isActive: true },
+  );
+
+  if (privacyState.isLoading) {
+    return <Text color={Colors.Gray}>Loading...</Text>;
+  }
+
+  if (privacyState.error) {
+    return (
+      <Box flexDirection="column" marginY={1}>
+        <Text color={Colors.AccentRed}>
+          Error loading Opt-in settings: {privacyState.error}
+        </Text>
+        <Text color={Colors.Gray}>Press Esc to exit.</Text>
+      </Box>
+    );
+  }
+
+  if (privacyState.isFreeTier === false) {
+    return <CloudPaidPrivacyNotice onExit={onExit} />;
+  }
+
+  const items = [
+    { label: 'Yes', value: true },
+    { label: 'No', value: false },
+  ];
+
+  return (
+    <Box flexDirection="column" marginY={1}>
+      <Text bold color={Colors.AccentPurple}>
+        Gemini Code Assist for Individuals Privacy Notice
+      </Text>
+      <Newline />
+      <Text>
+        This notice and our Privacy Policy
+        <Text color={Colors.AccentBlue}>[1]</Text> describe how Gemini Code
+        Assist handles your data. Please read them carefully.
+      </Text>
+      <Newline />
+      <Text>
+        When you use Gemini Code Assist for individuals with Gemini CLI, Google
+        collects your prompts, related code, generated output, code edits,
+        related feature usage information, and your feedback to provide,
+        improve, and develop Google products and services and machine learning
+        technologies.
+      </Text>
+      <Newline />
+      <Text>
+        To help with quality and improve our products (such as generative
+        machine-learning models), human reviewers may read, annotate, and
+        process the data collected above. We take steps to protect your privacy
+        as part of this process. This includes disconnecting the data from your
+        Google Account before reviewers see or annotate it, and storing those
+        disconnected copies for up to 18 months. Please don&apos;t submit
+        confidential information or any data you wouldn&apos;t want a reviewer
+        to see or Google to use to improve our products, services and
+        machine-learning technologies.
+      </Text>
+      <Newline />
+      <Box flexDirection="column">
+        <Text>
+          Allow Google to use this data to develop and improve our products?
+        </Text>
+        <RadioButtonSelect
+          items={items}
+          initialIndex={privacyState.dataCollectionOptIn ? 0 : 1}
+          onSelect={(value) => {
+            updateDataCollectionOptIn(value);
+            // Only exit if there was no error.
+            if (!privacyState.error) {
+              onExit();
+            }
+          }}
+        />
+      </Box>
+      <Newline />
+      <Text>
+        <Text color={Colors.AccentBlue}>[1]</Text>{' '}
+        https://policies.google.com/privacy
+      </Text>
+      <Newline />
+      <Text color={Colors.Gray}>Press Enter to choose an option and exit.</Text>
+    </Box>
+  );
+};

package/dist/ui/privacy/CloudPaidPrivacyNotice.tsx

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box, Newline, Text } from 'ink';
+import { Colors } from '../colors.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+
+interface CloudPaidPrivacyNoticeProps {
+  onExit: () => void;
+}
+
+export const CloudPaidPrivacyNotice = ({
+  onExit,
+}: CloudPaidPrivacyNoticeProps) => {
+  useKeypress(
+    (key) => {
+      if (key.name === 'escape') {
+        onExit();
+      }
+    },
+    { isActive: true },
+  );
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Text bold color={Colors.AccentPurple}>
+        Vertex AI Notice
+      </Text>
+      <Newline />
+      <Text>
+        Service Specific Terms<Text color={Colors.AccentBlue}>[1]</Text> are
+        incorporated into the agreement under which Google has agreed to provide
+        Google Cloud Platform<Text color={Colors.AccentGreen}>[2]</Text> to
+        Customer (the “Agreement”). If the Agreement authorizes the resale or
+        supply of Google Cloud Platform under a Google Cloud partner or reseller
+        program, then except for in the section entitled “Partner-Specific
+        Terms”, all references to Customer in the Service Specific Terms mean
+        Partner or Reseller (as applicable), and all references to Customer Data
+        in the Service Specific Terms mean Partner Data. Capitalized terms used
+        but not defined in the Service Specific Terms have the meaning given to
+        them in the Agreement.
+      </Text>
+      <Newline />
+      <Text>
+        <Text color={Colors.AccentBlue}>[1]</Text>{' '}
+        https://cloud.google.com/terms/service-terms
+      </Text>
+      <Text>
+        <Text color={Colors.AccentGreen}>[2]</Text>{' '}
+        https://cloud.google.com/terms/services
+      </Text>
+      <Newline />
+      <Text color={Colors.Gray}>Press Esc to exit.</Text>
+    </Box>
+  );
+};

package/dist/ui/privacy/GeminiPrivacyNotice.tsx

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Box, Newline, Text } from 'ink';
+import { Colors } from '../colors.js';
+import { useKeypress } from '../hooks/useKeypress.js';
+
+interface GeminiPrivacyNoticeProps {
+  onExit: () => void;
+}
+
+export const GeminiPrivacyNotice = ({ onExit }: GeminiPrivacyNoticeProps) => {
+  useKeypress(
+    (key) => {
+      if (key.name === 'escape') {
+        onExit();
+      }
+    },
+    { isActive: true },
+  );
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Text bold color={Colors.AccentPurple}>
+        Gemini API Key Notice
+      </Text>
+      <Newline />
+      <Text>
+        By using the Gemini API<Text color={Colors.AccentBlue}>[1]</Text>,
+        Google AI Studio
+        <Text color={Colors.AccentRed}>[2]</Text>, and the other Google
+        developer services that reference these terms (collectively, the
+        &quot;APIs&quot; or &quot;Services&quot;), you are agreeing to Google
+        APIs Terms of Service (the &quot;API Terms&quot;)
+        <Text color={Colors.AccentGreen}>[3]</Text>, and the Gemini API
+        Additional Terms of Service (the &quot;Additional Terms&quot;)
+        <Text color={Colors.AccentPurple}>[4]</Text>.
+      </Text>
+      <Newline />
+      <Text>
+        <Text color={Colors.AccentBlue}>[1]</Text>{' '}
+        https://ai.google.dev/docs/gemini_api_overview
+      </Text>
+      <Text>
+        <Text color={Colors.AccentRed}>[2]</Text> https://aistudio.google.com/
+      </Text>
+      <Text>
+        <Text color={Colors.AccentGreen}>[3]</Text>{' '}
+        https://developers.google.com/terms
+      </Text>
+      <Text>
+        <Text color={Colors.AccentPurple}>[4]</Text>{' '}
+        https://ai.google.dev/gemini-api/terms
+      </Text>
+      <Newline />
+      <Text color={Colors.Gray}>Press Esc to exit.</Text>
+    </Box>
+  );
+};