@iaforged/context-code 1.0.62 → 1.0.65

package/dist/src/vim/textObjects.js

@@ -1,153 +0,0 @@
-/**
- * Vim Text Object Finding
- *
- * Functions for finding text object boundaries (iw, aw, i", a(, etc.)
- */
-import { isVimPunctuation, isVimWhitespace, isVimWordChar, } from '../utils/Cursor.js';
-import { getGraphemeSegmenter } from '../utils/intl.js';
-/**
- * Delimiter pairs for text objects.
- */
-const PAIRS = {
-    '(': ['(', ')'],
-    ')': ['(', ')'],
-    b: ['(', ')'],
-    '[': ['[', ']'],
-    ']': ['[', ']'],
-    '{': ['{', '}'],
-    '}': ['{', '}'],
-    B: ['{', '}'],
-    '<': ['<', '>'],
-    '>': ['<', '>'],
-    '"': ['"', '"'],
-    "'": ["'", "'"],
-    '`': ['`', '`'],
-};
-/**
- * Find a text object at the given position.
- */
-export function findTextObject(text, offset, objectType, isInner) {
-    if (objectType === 'w')
-        return findWordObject(text, offset, isInner, isVimWordChar);
-    if (objectType === 'W')
-        return findWordObject(text, offset, isInner, ch => !isVimWhitespace(ch));
-    const pair = PAIRS[objectType];
-    if (pair) {
-        const [open, close] = pair;
-        return open === close
-            ? findQuoteObject(text, offset, open, isInner)
-            : findBracketObject(text, offset, open, close, isInner);
-    }
-    return null;
-}
-function findWordObject(text, offset, isInner, isWordChar) {
-    // Pre-segment into graphemes for grapheme-safe iteration
-    const graphemes = [];
-    for (const { segment, index } of getGraphemeSegmenter().segment(text)) {
-        graphemes.push({ segment, index });
-    }
-    // Find which grapheme index the offset falls in
-    let graphemeIdx = graphemes.length - 1;
-    for (let i = 0; i < graphemes.length; i++) {
-        const g = graphemes[i];
-        const nextStart = i + 1 < graphemes.length ? graphemes[i + 1].index : text.length;
-        if (offset >= g.index && offset < nextStart) {
-            graphemeIdx = i;
-            break;
-        }
-    }
-    const graphemeAt = (idx) => graphemes[idx]?.segment ?? '';
-    const offsetAt = (idx) => idx < graphemes.length ? graphemes[idx].index : text.length;
-    const isWs = (idx) => isVimWhitespace(graphemeAt(idx));
-    const isWord = (idx) => isWordChar(graphemeAt(idx));
-    const isPunct = (idx) => isVimPunctuation(graphemeAt(idx));
-    let startIdx = graphemeIdx;
-    let endIdx = graphemeIdx;
-    if (isWord(graphemeIdx)) {
-        while (startIdx > 0 && isWord(startIdx - 1))
-            startIdx--;
-        while (endIdx < graphemes.length && isWord(endIdx))
-            endIdx++;
-    }
-    else if (isWs(graphemeIdx)) {
-        while (startIdx > 0 && isWs(startIdx - 1))
-            startIdx--;
-        while (endIdx < graphemes.length && isWs(endIdx))
-            endIdx++;
-        return { start: offsetAt(startIdx), end: offsetAt(endIdx) };
-    }
-    else if (isPunct(graphemeIdx)) {
-        while (startIdx > 0 && isPunct(startIdx - 1))
-            startIdx--;
-        while (endIdx < graphemes.length && isPunct(endIdx))
-            endIdx++;
-    }
-    if (!isInner) {
-        // Include surrounding whitespace
-        if (endIdx < graphemes.length && isWs(endIdx)) {
-            while (endIdx < graphemes.length && isWs(endIdx))
-                endIdx++;
-        }
-        else if (startIdx > 0 && isWs(startIdx - 1)) {
-            while (startIdx > 0 && isWs(startIdx - 1))
-                startIdx--;
-        }
-    }
-    return { start: offsetAt(startIdx), end: offsetAt(endIdx) };
-}
-function findQuoteObject(text, offset, quote, isInner) {
-    const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
-    const lineEnd = text.indexOf('\n', offset);
-    const effectiveEnd = lineEnd === -1 ? text.length : lineEnd;
-    const line = text.slice(lineStart, effectiveEnd);
-    const posInLine = offset - lineStart;
-    const positions = [];
-    for (let i = 0; i < line.length; i++) {
-        if (line[i] === quote)
-            positions.push(i);
-    }
-    // Pair quotes correctly: 0-1, 2-3, 4-5, etc.
-    for (let i = 0; i < positions.length - 1; i += 2) {
-        const qs = positions[i];
-        const qe = positions[i + 1];
-        if (qs <= posInLine && posInLine <= qe) {
-            return isInner
-                ? { start: lineStart + qs + 1, end: lineStart + qe }
-                : { start: lineStart + qs, end: lineStart + qe + 1 };
-        }
-    }
-    return null;
-}
-function findBracketObject(text, offset, open, close, isInner) {
-    let depth = 0;
-    let start = -1;
-    for (let i = offset; i >= 0; i--) {
-        if (text[i] === close && i !== offset)
-            depth++;
-        else if (text[i] === open) {
-            if (depth === 0) {
-                start = i;
-                break;
-            }
-            depth--;
-        }
-    }
-    if (start === -1)
-        return null;
-    depth = 0;
-    let end = -1;
-    for (let i = start + 1; i < text.length; i++) {
-        if (text[i] === open)
-            depth++;
-        else if (text[i] === close) {
-            if (depth === 0) {
-                end = i;
-                break;
-            }
-            depth--;
-        }
-    }
-    if (end === -1)
-        return null;
-    return isInner ? { start: start + 1, end } : { start, end: end + 1 };
-}

package/dist/src/vim/transitions.js

@@ -1,340 +0,0 @@
-/**
- * Vim State Transition Table
- *
- * This is the scannable source of truth for state transitions.
- * To understand what happens in any state, look up that state's transition function.
- */
-import { resolveMotion } from './motions.js';
-import { executeIndent, executeJoin, executeLineOp, executeOpenLine, executeOperatorFind, executeOperatorG, executeOperatorGg, executeOperatorMotion, executeOperatorTextObj, executePaste, executeReplace, executeToggleCase, executeX, } from './operators.js';
-import { FIND_KEYS, isOperatorKey, isTextObjScopeKey, MAX_VIM_COUNT, OPERATORS, SIMPLE_MOTIONS, TEXT_OBJ_SCOPES, TEXT_OBJ_TYPES, } from './types.js';
-/**
- * Main transition function. Dispatches based on current state type.
- */
-export function transition(state, input, ctx) {
-    switch (state.type) {
-        case 'idle':
-            return fromIdle(input, ctx);
-        case 'count':
-            return fromCount(state, input, ctx);
-        case 'operator':
-            return fromOperator(state, input, ctx);
-        case 'operatorCount':
-            return fromOperatorCount(state, input, ctx);
-        case 'operatorFind':
-            return fromOperatorFind(state, input, ctx);
-        case 'operatorTextObj':
-            return fromOperatorTextObj(state, input, ctx);
-        case 'find':
-            return fromFind(state, input, ctx);
-        case 'g':
-            return fromG(state, input, ctx);
-        case 'operatorG':
-            return fromOperatorG(state, input, ctx);
-        case 'replace':
-            return fromReplace(state, input, ctx);
-        case 'indent':
-            return fromIndent(state, input, ctx);
-    }
-}
-// ============================================================================
-// Shared Input Handling
-// ============================================================================
-/**
- * Handle input that's valid in both idle and count states.
- * Returns null if input is not recognized.
- */
-function handleNormalInput(input, count, ctx) {
-    if (isOperatorKey(input)) {
-        return { next: { type: 'operator', op: OPERATORS[input], count } };
-    }
-    if (SIMPLE_MOTIONS.has(input)) {
-        return {
-            execute: () => {
-                const target = resolveMotion(input, ctx.cursor, count);
-                ctx.setOffset(target.offset);
-            },
-        };
-    }
-    if (FIND_KEYS.has(input)) {
-        return { next: { type: 'find', find: input, count } };
-    }
-    if (input === 'g')
-        return { next: { type: 'g', count } };
-    if (input === 'r')
-        return { next: { type: 'replace', count } };
-    if (input === '>' || input === '<') {
-        return { next: { type: 'indent', dir: input, count } };
-    }
-    if (input === '~') {
-        return { execute: () => executeToggleCase(count, ctx) };
-    }
-    if (input === 'x') {
-        return { execute: () => executeX(count, ctx) };
-    }
-    if (input === 'J') {
-        return { execute: () => executeJoin(count, ctx) };
-    }
-    if (input === 'p' || input === 'P') {
-        return { execute: () => executePaste(input === 'p', count, ctx) };
-    }
-    if (input === 'D') {
-        return { execute: () => executeOperatorMotion('delete', '$', 1, ctx) };
-    }
-    if (input === 'C') {
-        return { execute: () => executeOperatorMotion('change', '$', 1, ctx) };
-    }
-    if (input === 'Y') {
-        return { execute: () => executeLineOp('yank', count, ctx) };
-    }
-    if (input === 'G') {
-        return {
-            execute: () => {
-                // count=1 means no count given, go to last line
-                // otherwise go to line N
-                if (count === 1) {
-                    ctx.setOffset(ctx.cursor.startOfLastLine().offset);
-                }
-                else {
-                    ctx.setOffset(ctx.cursor.goToLine(count).offset);
-                }
-            },
-        };
-    }
-    if (input === '.') {
-        return { execute: () => ctx.onDotRepeat?.() };
-    }
-    if (input === ';' || input === ',') {
-        return { execute: () => executeRepeatFind(input === ',', count, ctx) };
-    }
-    if (input === 'u') {
-        return { execute: () => ctx.onUndo?.() };
-    }
-    if (input === 'i') {
-        return { execute: () => ctx.enterInsert(ctx.cursor.offset) };
-    }
-    if (input === 'I') {
-        return {
-            execute: () => ctx.enterInsert(ctx.cursor.firstNonBlankInLogicalLine().offset),
-        };
-    }
-    if (input === 'a') {
-        return {
-            execute: () => {
-                const newOffset = ctx.cursor.isAtEnd()
-                    ? ctx.cursor.offset
-                    : ctx.cursor.right().offset;
-                ctx.enterInsert(newOffset);
-            },
-        };
-    }
-    if (input === 'A') {
-        return {
-            execute: () => ctx.enterInsert(ctx.cursor.endOfLogicalLine().offset),
-        };
-    }
-    if (input === 'o') {
-        return { execute: () => executeOpenLine('below', ctx) };
-    }
-    if (input === 'O') {
-        return { execute: () => executeOpenLine('above', ctx) };
-    }
-    return null;
-}
-/**
- * Handle operator input (motion, find, text object scope).
- * Returns null if input is not recognized.
- */
-function handleOperatorInput(op, count, input, ctx) {
-    if (isTextObjScopeKey(input)) {
-        return {
-            next: {
-                type: 'operatorTextObj',
-                op,
-                count,
-                scope: TEXT_OBJ_SCOPES[input],
-            },
-        };
-    }
-    if (FIND_KEYS.has(input)) {
-        return {
-            next: { type: 'operatorFind', op, count, find: input },
-        };
-    }
-    if (SIMPLE_MOTIONS.has(input)) {
-        return { execute: () => executeOperatorMotion(op, input, count, ctx) };
-    }
-    if (input === 'G') {
-        return { execute: () => executeOperatorG(op, count, ctx) };
-    }
-    if (input === 'g') {
-        return { next: { type: 'operatorG', op, count } };
-    }
-    return null;
-}
-// ============================================================================
-// Transition Functions - One per state type
-// ============================================================================
-function fromIdle(input, ctx) {
-    // 0 is line-start motion, not a count prefix
-    if (/[1-9]/.test(input)) {
-        return { next: { type: 'count', digits: input } };
-    }
-    if (input === '0') {
-        return {
-            execute: () => ctx.setOffset(ctx.cursor.startOfLogicalLine().offset),
-        };
-    }
-    const result = handleNormalInput(input, 1, ctx);
-    if (result)
-        return result;
-    return {};
-}
-function fromCount(state, input, ctx) {
-    if (/[0-9]/.test(input)) {
-        const newDigits = state.digits + input;
-        const count = Math.min(parseInt(newDigits, 10), MAX_VIM_COUNT);
-        return { next: { type: 'count', digits: String(count) } };
-    }
-    const count = parseInt(state.digits, 10);
-    const result = handleNormalInput(input, count, ctx);
-    if (result)
-        return result;
-    return { next: { type: 'idle' } };
-}
-function fromOperator(state, input, ctx) {
-    // dd, cc, yy = line operation
-    if (input === state.op[0]) {
-        return { execute: () => executeLineOp(state.op, state.count, ctx) };
-    }
-    if (/[0-9]/.test(input)) {
-        return {
-            next: {
-                type: 'operatorCount',
-                op: state.op,
-                count: state.count,
-                digits: input,
-            },
-        };
-    }
-    const result = handleOperatorInput(state.op, state.count, input, ctx);
-    if (result)
-        return result;
-    return { next: { type: 'idle' } };
-}
-function fromOperatorCount(state, input, ctx) {
-    if (/[0-9]/.test(input)) {
-        const newDigits = state.digits + input;
-        const parsedDigits = Math.min(parseInt(newDigits, 10), MAX_VIM_COUNT);
-        return { next: { ...state, digits: String(parsedDigits) } };
-    }
-    const motionCount = parseInt(state.digits, 10);
-    const effectiveCount = state.count * motionCount;
-    const result = handleOperatorInput(state.op, effectiveCount, input, ctx);
-    if (result)
-        return result;
-    return { next: { type: 'idle' } };
-}
-function fromOperatorFind(state, input, ctx) {
-    return {
-        execute: () => executeOperatorFind(state.op, state.find, input, state.count, ctx),
-    };
-}
-function fromOperatorTextObj(state, input, ctx) {
-    if (TEXT_OBJ_TYPES.has(input)) {
-        return {
-            execute: () => executeOperatorTextObj(state.op, state.scope, input, state.count, ctx),
-        };
-    }
-    return { next: { type: 'idle' } };
-}
-function fromFind(state, input, ctx) {
-    return {
-        execute: () => {
-            const result = ctx.cursor.findCharacter(input, state.find, state.count);
-            if (result !== null) {
-                ctx.setOffset(result);
-                ctx.setLastFind(state.find, input);
-            }
-        },
-    };
-}
-function fromG(state, input, ctx) {
-    if (input === 'j' || input === 'k') {
-        return {
-            execute: () => {
-                const target = resolveMotion(`g${input}`, ctx.cursor, state.count);
-                ctx.setOffset(target.offset);
-            },
-        };
-    }
-    if (input === 'g') {
-        // If count provided (e.g., 5gg), go to that line. Otherwise go to first line.
-        if (state.count > 1) {
-            return {
-                execute: () => {
-                    const lines = ctx.text.split('\n');
-                    const targetLine = Math.min(state.count - 1, lines.length - 1);
-                    let offset = 0;
-                    for (let i = 0; i < targetLine; i++) {
-                        offset += (lines[i]?.length ?? 0) + 1; // +1 for newline
-                    }
-                    ctx.setOffset(offset);
-                },
-            };
-        }
-        return {
-            execute: () => ctx.setOffset(ctx.cursor.startOfFirstLine().offset),
-        };
-    }
-    return { next: { type: 'idle' } };
-}
-function fromOperatorG(state, input, ctx) {
-    if (input === 'j' || input === 'k') {
-        return {
-            execute: () => executeOperatorMotion(state.op, `g${input}`, state.count, ctx),
-        };
-    }
-    if (input === 'g') {
-        return { execute: () => executeOperatorGg(state.op, state.count, ctx) };
-    }
-    // Any other input cancels the operator
-    return { next: { type: 'idle' } };
-}
-function fromReplace(state, input, ctx) {
-    // Backspace/Delete arrive as empty input in literal-char states. In vim,
-    // r<BS> cancels the replace; without this guard, executeReplace("") would
-    // delete the character under the cursor instead.
-    if (input === '')
-        return { next: { type: 'idle' } };
-    return { execute: () => executeReplace(input, state.count, ctx) };
-}
-function fromIndent(state, input, ctx) {
-    if (input === state.dir) {
-        return { execute: () => executeIndent(state.dir, state.count, ctx) };
-    }
-    return { next: { type: 'idle' } };
-}
-// ============================================================================
-// Helper functions for special commands
-// ============================================================================
-function executeRepeatFind(reverse, count, ctx) {
-    const lastFind = ctx.getLastFind();
-    if (!lastFind)
-        return;
-    // Determine the effective find type based on reverse
-    let findType = lastFind.type;
-    if (reverse) {
-        // Flip the direction
-        const flipMap = {
-            f: 'F',
-            F: 'f',
-            t: 'T',
-            T: 't',
-        };
-        findType = flipMap[findType];
-    }
-    const result = ctx.cursor.findCharacter(lastFind.char, findType, count);
-    if (result !== null) {
-        ctx.setOffset(result);
-    }
-}

package/dist/src/vim/types.js

@@ -1,93 +0,0 @@
-/**
- * Vim Mode State Machine Types
- *
- * This file defines the complete state machine for vim input handling.
- * The types ARE the documentation - reading them tells you how the system works.
- *
- * State Diagram:
- * ```
- *                              VimState
- *   ┌──────────────────────────────┬──────────────────────────────────────┐
- *   │  INSERT                      │  NORMAL                              │
- *   │  (tracks insertedText)       │  (CommandState machine)              │
- *   │                              │                                      │
- *   │                              │  idle ──┬─[d/c/y]──► operator        │
- *   │                              │         ├─[1-9]────► count           │
- *   │                              │         ├─[fFtT]───► find            │
- *   │                              │         ├─[g]──────► g               │
- *   │                              │         ├─[r]──────► replace         │
- *   │                              │         └─[><]─────► indent          │
- *   │                              │                                      │
- *   │                              │  operator ─┬─[motion]──► execute     │
- *   │                              │            ├─[0-9]────► operatorCount│
- *   │                              │            ├─[ia]─────► operatorTextObj
- *   │                              │            └─[fFtT]───► operatorFind │
- *   └──────────────────────────────┴──────────────────────────────────────┘
- * ```
- */
-// ============================================================================
-// Key Groups - Named constants, no magic strings
-// ============================================================================
-export const OPERATORS = {
-    d: 'delete',
-    c: 'change',
-    y: 'yank',
-};
-export function isOperatorKey(key) {
-    return key in OPERATORS;
-}
-export const SIMPLE_MOTIONS = new Set([
-    'h',
-    'l',
-    'j',
-    'k', // Basic movement
-    'w',
-    'b',
-    'e',
-    'W',
-    'B',
-    'E', // Word motions
-    '0',
-    '^',
-    '$', // Line positions
-]);
-export const FIND_KEYS = new Set(['f', 'F', 't', 'T']);
-export const TEXT_OBJ_SCOPES = {
-    i: 'inner',
-    a: 'around',
-};
-export function isTextObjScopeKey(key) {
-    return key in TEXT_OBJ_SCOPES;
-}
-export const TEXT_OBJ_TYPES = new Set([
-    'w',
-    'W', // Word/WORD
-    '"',
-    "'",
-    '`', // Quotes
-    '(',
-    ')',
-    'b', // Parens
-    '[',
-    ']', // Brackets
-    '{',
-    '}',
-    'B', // Braces
-    '<',
-    '>', // Angle brackets
-]);
-export const MAX_VIM_COUNT = 10000;
-// ============================================================================
-// State Factories
-// ============================================================================
-export function createInitialVimState() {
-    return { mode: 'INSERT', insertedText: '' };
-}
-export function createInitialPersistentState() {
-    return {
-        lastChange: null,
-        lastFind: null,
-        register: '',
-        registerIsLinewise: false,
-    };
-}

package/dist/src/voice/voiceModeEnabled.js

@@ -1,48 +0,0 @@
-import { feature } from '../recovery/bunBundleShim.js';
-import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js';
-import { getClaudeAIOAuthTokens, isAnthropicAuthEnabled, } from '../utils/auth.js';
-/**
- * Kill-switch check for voice mode. Returns true unless the
- * `tengu_amber_quartz_disabled` GrowthBook flag is flipped on (emergency
- * off). Default `false` means a missing/stale disk cache reads as "not
- * killed" — so fresh installs get voice working immediately without
- * waiting for GrowthBook init. Use this for deciding whether voice mode
- * should be *visible* (e.g., command registration, config UI).
- */
-export function isVoiceGrowthBookEnabled() {
-    // Positive ternary pattern — see docs/feature-gating.md.
-    // Negative pattern (if (!feature(...)) return) does not eliminate
-    // inline string literals from external builds.
-    return feature('VOICE_MODE')
-        ? !getFeatureValue_CACHED_MAY_BE_STALE('tengu_amber_quartz_disabled', false)
-        : false;
-}
-/**
- * Auth-only check for voice mode. Returns true when the user has a valid
- * Anthropic OAuth token. Backed by the memoized getClaudeAIOAuthTokens —
- * first call spawns `security` on macOS (~20-50ms), subsequent calls are
- * cache hits. The memoize clears on token refresh (~once/hour), so one
- * cold spawn per refresh is expected. Cheap enough for usage-time checks.
- */
-export function hasVoiceAuth() {
-    // Voice mode requires Anthropic OAuth — it uses the voice_stream
-    // endpoint on claude.ai which is not available with API keys,
-    // Bedrock, Vertex, or Foundry.
-    if (!isAnthropicAuthEnabled()) {
-        return false;
-    }
-    // isAnthropicAuthEnabled only checks the auth *provider*, not whether
-    // a token exists. Without this check, the voice UI renders but
-    // connectVoiceStream fails silently when the user isn't logged in.
-    const tokens = getClaudeAIOAuthTokens();
-    return Boolean(tokens?.accessToken);
-}
-/**
- * Full runtime check: auth + GrowthBook kill-switch. Callers: `/voice`
- * (voice.ts, voice/index.ts), ConfigTool, VoiceModeNotice — command-time
- * paths where a fresh keychain read is acceptable. For React render
- * paths use useVoiceEnabled() instead (memoizes the auth half).
- */
-export function isVoiceModeEnabled() {
-    return hasVoiceAuth() && isVoiceGrowthBookEnabled();
-}