@quantiya/codevibe-core 1.0.0

package/dist/logger/logger.js

@@ -0,0 +1,142 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = void 0;
+exports.createLogger = createLogger;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+/**
+ * Simple logger for CodeVibe plugins
+ */
+class Logger {
+    constructor(options) {
+        this.name = options.name;
+        this.logFile = options.logFile;
+        this.level = options.level || 'info';
+        this.enableConsole = options.console ?? false;
+        if (this.logFile) {
+            this.ensureLogDir();
+        }
+    }
+    ensureLogDir() {
+        if (this.logFile) {
+            const dir = path.dirname(this.logFile);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+    }
+    shouldLog(level) {
+        return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+    }
+    formatMessage(level, message, data) {
+        const timestamp = new Date().toISOString();
+        const levelStr = level.toUpperCase().padEnd(5);
+        let msg = `[${timestamp}] [${levelStr}] [${this.name}] ${message}`;
+        if (data !== undefined) {
+            if (typeof data === 'object') {
+                msg += ` ${JSON.stringify(data)}`;
+            }
+            else {
+                msg += ` ${data}`;
+            }
+        }
+        return msg;
+    }
+    log(level, message, data) {
+        if (!this.shouldLog(level)) {
+            return;
+        }
+        const formatted = this.formatMessage(level, message, data);
+        if (this.logFile) {
+            try {
+                fs.appendFileSync(this.logFile, formatted + '\n');
+            }
+            catch (error) {
+                // Ignore log write errors
+            }
+        }
+        if (this.enableConsole) {
+            switch (level) {
+                case 'error':
+                    console.error(formatted);
+                    break;
+                case 'warn':
+                    console.warn(formatted);
+                    break;
+                default:
+                    console.log(formatted);
+            }
+        }
+    }
+    debug(message, data) {
+        this.log('debug', message, data);
+    }
+    info(message, data) {
+        this.log('info', message, data);
+    }
+    warn(message, data) {
+        this.log('warn', message, data);
+    }
+    error(message, data) {
+        this.log('error', message, data);
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+}
+exports.Logger = Logger;
+/**
+ * Create a logger with custom options
+ */
+function createLogger(options) {
+    return new Logger(options);
+}
+/**
+ * Default shared logger instance
+ */
+exports.logger = new Logger({
+    name: 'codevibe-core',
+    logFile: path.join(os.tmpdir(), 'codevibe-core.log'),
+    level: 'info',
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/logger/logger.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport * as os from 'os';\n\nexport type LogLevel = 'debug' | 'info' | 'warn' | 'error';\n\ninterface LoggerOptions {\n  name: string;\n  logFile?: string;\n  level?: LogLevel;\n  console?: boolean;\n}\n\nconst LOG_LEVELS: Record<LogLevel, number> = {\n  debug: 0,\n  info: 1,\n  warn: 2,\n  error: 3,\n};\n\n/**\n * Simple logger for CodeVibe plugins\n */\nexport class Logger {\n  private name: string;\n  private logFile?: string;\n  private level: LogLevel;\n  private enableConsole: boolean;\n\n  constructor(options: LoggerOptions) {\n    this.name = options.name;\n    this.logFile = options.logFile;\n    this.level = options.level || 'info';\n    this.enableConsole = options.console ?? false;\n\n    if (this.logFile) {\n      this.ensureLogDir();\n    }\n  }\n\n  private ensureLogDir(): void {\n    if (this.logFile) {\n      const dir = path.dirname(this.logFile);\n      if (!fs.existsSync(dir)) {\n        fs.mkdirSync(dir, { recursive: true });\n      }\n    }\n  }\n\n  private shouldLog(level: LogLevel): boolean {\n    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];\n  }\n\n  private formatMessage(level: LogLevel, message: string, data?: any): string {\n    const timestamp = new Date().toISOString();\n    const levelStr = level.toUpperCase().padEnd(5);\n    let msg = `[${timestamp}] [${levelStr}] [${this.name}] ${message}`;\n\n    if (data !== undefined) {\n      if (typeof data === 'object') {\n        msg += ` ${JSON.stringify(data)}`;\n      } else {\n        msg += ` ${data}`;\n      }\n    }\n\n    return msg;\n  }\n\n  private log(level: LogLevel, message: string, data?: any): void {\n    if (!this.shouldLog(level)) {\n      return;\n    }\n\n    const formatted = this.formatMessage(level, message, data);\n\n    if (this.logFile) {\n      try {\n        fs.appendFileSync(this.logFile, formatted + '\\n');\n      } catch (error) {\n        // Ignore log write errors\n      }\n    }\n\n    if (this.enableConsole) {\n      switch (level) {\n        case 'error':\n          console.error(formatted);\n          break;\n        case 'warn':\n          console.warn(formatted);\n          break;\n        default:\n          console.log(formatted);\n      }\n    }\n  }\n\n  debug(message: string, data?: any): void {\n    this.log('debug', message, data);\n  }\n\n  info(message: string, data?: any): void {\n    this.log('info', message, data);\n  }\n\n  warn(message: string, data?: any): void {\n    this.log('warn', message, data);\n  }\n\n  error(message: string, data?: any): void {\n    this.log('error', message, data);\n  }\n\n  setLevel(level: LogLevel): void {\n    this.level = level;\n  }\n}\n\n/**\n * Create a logger with custom options\n */\nexport function createLogger(options: LoggerOptions): Logger {\n  return new Logger(options);\n}\n\n/**\n * Default shared logger instance\n */\nexport const logger = new Logger({\n  name: 'codevibe-core',\n  logFile: path.join(os.tmpdir(), 'codevibe-core.log'),\n  level: 'info',\n});\n"]}

package/dist/prompt-parser.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared prompt parser for interactive terminal prompts.
+ *
+ * Parses terminal snapshots (from tmux capture-pane) to extract
+ * interactive prompt options displayed by CLI tools (Gemini, Codex, etc.).
+ *
+ * Used by multiple plugins to dynamically capture options instead of hardcoding.
+ */
+export type PromptKind = 'yes_no' | 'numbered' | 'text';
+export interface InteractivePromptOption {
+    number: string;
+    text: string;
+}
+export interface ParsedInteractivePrompt {
+    kind: PromptKind;
+    promptText: string;
+    options: InteractivePromptOption[];
+    submitMap: Record<string, string>;
+    requiresFollowUpText?: boolean;
+}
+/**
+ * Parse a terminal snapshot to extract interactive prompt options.
+ *
+ * Detects two prompt types:
+ * - Yes/No prompts: [y/n] patterns
+ * - Numbered prompts: "1. Allow once", "2. Allow for this session", etc.
+ *
+ * Returns null if no prompt is detected.
+ */
+export declare function parseInteractivePrompt(snapshot: string): ParsedInteractivePrompt | null;
+/**
+ * Strip ANSI escape codes, box-drawing characters, and normalize whitespace
+ * from terminal output.
+ *
+ * Box-drawing characters (│, ┌, ┐, └, ┘, ─, etc.) are used by TUI apps like
+ * Gemini CLI to render bordered panels. Stripping them exposes the text content
+ * so the parser can match option lines inside boxes.
+ */
+export declare function normalizeSnapshot(snapshot: string): string;

package/dist/prompt-parser.js

@@ -0,0 +1,236 @@
+"use strict";
+/**
+ * Shared prompt parser for interactive terminal prompts.
+ *
+ * Parses terminal snapshots (from tmux capture-pane) to extract
+ * interactive prompt options displayed by CLI tools (Gemini, Codex, etc.).
+ *
+ * Used by multiple plugins to dynamically capture options instead of hardcoding.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInteractivePrompt = parseInteractivePrompt;
+exports.normalizeSnapshot = normalizeSnapshot;
+const ANSI_PATTERN = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+/**
+ * Parse a terminal snapshot to extract interactive prompt options.
+ *
+ * Detects two prompt types:
+ * - Yes/No prompts: [y/n] patterns
+ * - Numbered prompts: "1. Allow once", "2. Allow for this session", etc.
+ *
+ * Returns null if no prompt is detected.
+ */
+function parseInteractivePrompt(snapshot) {
+    const normalized = normalizeSnapshot(snapshot);
+    if (!normalized) {
+        return null;
+    }
+    const yesNo = parseYesNoPrompt(normalized);
+    if (yesNo) {
+        return yesNo;
+    }
+    const numbered = parseNumberedPrompt(normalized);
+    if (numbered) {
+        return numbered;
+    }
+    return null;
+}
+/**
+ * Strip ANSI escape codes, box-drawing characters, and normalize whitespace
+ * from terminal output.
+ *
+ * Box-drawing characters (│, ┌, ┐, └, ┘, ─, etc.) are used by TUI apps like
+ * Gemini CLI to render bordered panels. Stripping them exposes the text content
+ * so the parser can match option lines inside boxes.
+ */
+function normalizeSnapshot(snapshot) {
+    return snapshot
+        .replace(/\r/g, '\n')
+        .replace(ANSI_PATTERN, '')
+        .replace(/[│┌┐└┘─├┤┬┴┼╌╎╭╮╯╰║═╔╗╚╝╠╣╦╩╬]/g, ' ')
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+function parseYesNoPrompt(snapshot) {
+    const lines = snapshot.split('\n').map(line => line.trim());
+    const promptLineIndex = findLastMatchingLineIndex(lines, line => /\[(?:y\/n|Y\/n|y\/N)\]/.test(line));
+    const promptLine = promptLineIndex >= 0 ? lines[promptLineIndex] : null;
+    if (!promptLine) {
+        return null;
+    }
+    const promptLines = extractPromptBlock(lines, promptLineIndex);
+    const promptText = promptLines.length > 0 ? promptLines.join('\n') : promptLine;
+    const lower = promptText.toLowerCase();
+    const requiresFollowUpText = lower.includes('what to change') ||
+        lower.includes('what should') ||
+        lower.includes('provide') ||
+        lower.includes('instructions');
+    const options = requiresFollowUpText
+        ? [
+            { number: '1', text: 'Yes' },
+            { number: '2', text: 'No, provide instructions' },
+        ]
+        : [
+            { number: '1', text: 'Yes' },
+            { number: '2', text: 'No' },
+        ];
+    const submitMap = {
+        '1': 'y',
+        '2': 'n',
+    };
+    return {
+        kind: 'yes_no',
+        promptText,
+        options,
+        submitMap,
+        requiresFollowUpText,
+    };
+}
+function parseNumberedPrompt(snapshot) {
+    const lines = snapshot.split('\n').map(line => line.trim());
+    const optionBlock = findTrailingOptionBlock(lines);
+    if (optionBlock.length < 2) {
+        return null;
+    }
+    const options = optionBlock
+        .map(({ line }) => parseOptionLine(line))
+        .filter((option) => !!option);
+    const submitMap = {};
+    for (const option of options) {
+        submitMap[option.number] = option.number;
+    }
+    const firstOptionIndex = optionBlock[0]?.index ?? -1;
+    const promptLines = extractPromptBlock(lines, firstOptionIndex - 1);
+    const promptText = promptLines.length > 0 ? promptLines.join('\n') : 'Select an option';
+    return {
+        kind: 'numbered',
+        promptText,
+        options,
+        submitMap,
+    };
+}
+function findLastMatchingLineIndex(lines, predicate) {
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        if (predicate(lines[index])) {
+            return index;
+        }
+    }
+    return -1;
+}
+function parseOptionLine(line) {
+    const match = line.match(/^(?:[>›❯▸▶➜➤*●]\s*)?(\d+)\.\s+(.*)$/);
+    if (!match) {
+        return null;
+    }
+    return {
+        number: match[1],
+        text: match[2],
+    };
+}
+function findTrailingOptionBlock(lines) {
+    const matches = lines
+        .map((line, index) => ({ index, line, parsed: parseOptionLine(line) }))
+        .filter((entry) => !!entry.parsed);
+    if (matches.length === 0) {
+        return [];
+    }
+    const block = [matches[matches.length - 1]];
+    for (let index = matches.length - 2; index >= 0; index -= 1) {
+        const current = matches[index];
+        const next = block[0];
+        if (current.index !== next.index - 1) {
+            break;
+        }
+        block.unshift(current);
+    }
+    return block.map(({ index, line }) => ({ index, line }));
+}
+function extractPromptBlock(lines, endIndex) {
+    if (endIndex < 0) {
+        return [];
+    }
+    let cursor = skipBlankLinesUp(lines, endIndex);
+    if (cursor < 0) {
+        return [];
+    }
+    const { start: mainBlockStart, end: blockEnd } = findNonEmptyBlockEndingAt(lines, cursor);
+    const mainBlock = lines.slice(mainBlockStart, blockEnd + 1).filter(Boolean);
+    if (isDiffPreviewBlock(mainBlock)) {
+        const recoveredPrompt = collectPromptBlocksAbove(lines, mainBlockStart - 1);
+        return recoveredPrompt.length > 0 ? recoveredPrompt : mainBlock;
+    }
+    if (mainBlockStart <= 1) {
+        return mainBlock;
+    }
+    let gapCursor = mainBlockStart - 1;
+    gapCursor = skipBlankLinesUp(lines, gapCursor);
+    if (gapCursor < 0 || gapCursor === mainBlockStart - 1) {
+        return mainBlock;
+    }
+    const { start: headingBlockStart, end: headingBlockEnd } = findNonEmptyBlockEndingAt(lines, gapCursor);
+    const headingBlock = lines.slice(headingBlockStart, headingBlockEnd + 1).filter(Boolean);
+    const headingMatched = headingBlock.some(isPromptHeadingLine);
+    if (!headingMatched) {
+        return mainBlock;
+    }
+    return [...headingBlock, ...mainBlock];
+}
+function isPromptHeadingLine(line) {
+    return /^(?:would you like to|do you want to|the model would like to|action required|confirm)\b/i.test(line);
+}
+function isLikelyFileSummaryLine(line) {
+    return /^.+\/[^/]+\s+\(\+\d+\s+-\d+\)$/.test(line);
+}
+function skipBlankLinesUp(lines, startIndex) {
+    let cursor = startIndex;
+    while (cursor >= 0 && !lines[cursor]) {
+        cursor -= 1;
+    }
+    return cursor;
+}
+function findNonEmptyBlockEndingAt(lines, endIndex) {
+    let cursor = endIndex;
+    while (cursor >= 0 && lines[cursor]) {
+        cursor -= 1;
+    }
+    return {
+        start: cursor + 1,
+        end: endIndex,
+    };
+}
+function collectPromptBlocksAbove(lines, startIndex) {
+    const blocks = [];
+    let cursor = startIndex;
+    while (cursor >= 0 && blocks.length < 2) {
+        cursor = skipBlankLinesUp(lines, cursor);
+        if (cursor < 0) {
+            break;
+        }
+        const { start, end } = findNonEmptyBlockEndingAt(lines, cursor);
+        const block = lines.slice(start, end + 1).filter(Boolean);
+        if (block.length > 0) {
+            blocks.unshift(block);
+        }
+        cursor = start - 1;
+    }
+    if (blocks.length === 0) {
+        return [];
+    }
+    const headingBlockIndex = blocks.findIndex(block => block.some(isPromptHeadingLine));
+    if (headingBlockIndex >= 0) {
+        return blocks.slice(headingBlockIndex).flat();
+    }
+    return blocks[blocks.length - 1];
+}
+function isDiffPreviewBlock(lines) {
+    if (lines.length === 0) {
+        return false;
+    }
+    const lineNumberedRows = lines.filter(isLineNumberedDiffLine).length;
+    return lineNumberedRows >= Math.max(2, Math.ceil(lines.length / 2));
+}
+function isLineNumberedDiffLine(line) {
+    return /^\d+\s/.test(line);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prompt-parser.js","sourceRoot":"","sources":["../src/prompt-parser.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Shared prompt parser for interactive terminal prompts.\n *\n * Parses terminal snapshots (from tmux capture-pane) to extract\n * interactive prompt options displayed by CLI tools (Gemini, Codex, etc.).\n *\n * Used by multiple plugins to dynamically capture options instead of hardcoding.\n */\n\nexport type PromptKind = 'yes_no' | 'numbered' | 'text';\n\nexport interface InteractivePromptOption {\n  number: string;\n  text: string;\n}\n\nexport interface ParsedInteractivePrompt {\n  kind: PromptKind;\n  promptText: string;\n  options: InteractivePromptOption[];\n  submitMap: Record<string, string>;\n  requiresFollowUpText?: boolean;\n}\n\nconst ANSI_PATTERN = /\\x1B(?:[@-Z\\\\-_]|\\[[0-?]*[ -/]*[@-~])/g;\n\n/**\n * Parse a terminal snapshot to extract interactive prompt options.\n *\n * Detects two prompt types:\n * - Yes/No prompts: [y/n] patterns\n * - Numbered prompts: \"1. Allow once\", \"2. Allow for this session\", etc.\n *\n * Returns null if no prompt is detected.\n */\nexport function parseInteractivePrompt(snapshot: string): ParsedInteractivePrompt | null {\n  const normalized = normalizeSnapshot(snapshot);\n  if (!normalized) {\n    return null;\n  }\n\n  const yesNo = parseYesNoPrompt(normalized);\n  if (yesNo) {\n    return yesNo;\n  }\n\n  const numbered = parseNumberedPrompt(normalized);\n  if (numbered) {\n    return numbered;\n  }\n\n  return null;\n}\n\n/**\n * Strip ANSI escape codes, box-drawing characters, and normalize whitespace\n * from terminal output.\n *\n * Box-drawing characters (│, ┌, ┐, └, ┘, ─, etc.) are used by TUI apps like\n * Gemini CLI to render bordered panels. Stripping them exposes the text content\n * so the parser can match option lines inside boxes.\n */\nexport function normalizeSnapshot(snapshot: string): string {\n  return snapshot\n    .replace(/\\r/g, '\\n')\n    .replace(ANSI_PATTERN, '')\n    .replace(/[│┌┐└┘─├┤┬┴┼╌╎╭╮╯╰║═╔╗╚╝╠╣╦╩╬]/g, ' ')\n    .replace(/[ \\t]+\\n/g, '\\n')\n    .replace(/\\n{3,}/g, '\\n\\n')\n    .trim();\n}\n\nfunction parseYesNoPrompt(snapshot: string): ParsedInteractivePrompt | null {\n  const lines = snapshot.split('\\n').map(line => line.trim());\n  const promptLineIndex = findLastMatchingLineIndex(lines, line => /\\[(?:y\\/n|Y\\/n|y\\/N)\\]/.test(line));\n  const promptLine = promptLineIndex >= 0 ? lines[promptLineIndex] : null;\n\n  if (!promptLine) {\n    return null;\n  }\n\n  const promptLines = extractPromptBlock(lines, promptLineIndex);\n  const promptText = promptLines.length > 0 ? promptLines.join('\\n') : promptLine;\n\n  const lower = promptText.toLowerCase();\n  const requiresFollowUpText =\n    lower.includes('what to change') ||\n    lower.includes('what should') ||\n    lower.includes('provide') ||\n    lower.includes('instructions');\n\n  const options: InteractivePromptOption[] = requiresFollowUpText\n    ? [\n        { number: '1', text: 'Yes' },\n        { number: '2', text: 'No, provide instructions' },\n      ]\n    : [\n        { number: '1', text: 'Yes' },\n        { number: '2', text: 'No' },\n      ];\n\n  const submitMap: Record<string, string> = {\n    '1': 'y',\n    '2': 'n',\n  };\n\n  return {\n    kind: 'yes_no',\n    promptText,\n    options,\n    submitMap,\n    requiresFollowUpText,\n  };\n}\n\nfunction parseNumberedPrompt(snapshot: string): ParsedInteractivePrompt | null {\n  const lines = snapshot.split('\\n').map(line => line.trim());\n\n  const optionBlock = findTrailingOptionBlock(lines);\n  if (optionBlock.length < 2) {\n    return null;\n  }\n\n  const options = optionBlock\n    .map(({ line }) => parseOptionLine(line))\n    .filter((option): option is InteractivePromptOption => !!option);\n\n  const submitMap: Record<string, string> = {};\n  for (const option of options) {\n    submitMap[option.number] = option.number;\n  }\n\n  const firstOptionIndex = optionBlock[0]?.index ?? -1;\n  const promptLines = extractPromptBlock(lines, firstOptionIndex - 1);\n  const promptText = promptLines.length > 0 ? promptLines.join('\\n') : 'Select an option';\n\n  return {\n    kind: 'numbered',\n    promptText,\n    options,\n    submitMap,\n  };\n}\n\nfunction findLastMatchingLineIndex(lines: string[], predicate: (line: string) => boolean): number {\n  for (let index = lines.length - 1; index >= 0; index -= 1) {\n    if (predicate(lines[index])) {\n      return index;\n    }\n  }\n  return -1;\n}\n\nfunction parseOptionLine(line: string): InteractivePromptOption | null {\n  const match = line.match(/^(?:[>›❯▸▶➜➤*●]\\s*)?(\\d+)\\.\\s+(.*)$/);\n  if (!match) {\n    return null;\n  }\n  return {\n    number: match[1],\n    text: match[2],\n  };\n}\n\nfunction findTrailingOptionBlock(lines: string[]): Array<{ index: number; line: string }> {\n  const matches = lines\n    .map((line, index) => ({ index, line, parsed: parseOptionLine(line) }))\n    .filter((entry) => !!entry.parsed);\n\n  if (matches.length === 0) {\n    return [];\n  }\n\n  const block: Array<{ index: number; line: string }> = [matches[matches.length - 1]];\n\n  for (let index = matches.length - 2; index >= 0; index -= 1) {\n    const current = matches[index];\n    const next = block[0];\n    if (current.index !== next.index - 1) {\n      break;\n    }\n    block.unshift(current);\n  }\n\n  return block.map(({ index, line }) => ({ index, line }));\n}\n\nfunction extractPromptBlock(lines: string[], endIndex: number): string[] {\n  if (endIndex < 0) {\n    return [];\n  }\n\n  let cursor = skipBlankLinesUp(lines, endIndex);\n  if (cursor < 0) {\n    return [];\n  }\n\n  const { start: mainBlockStart, end: blockEnd } = findNonEmptyBlockEndingAt(lines, cursor);\n  const mainBlock = lines.slice(mainBlockStart, blockEnd + 1).filter(Boolean);\n\n  if (isDiffPreviewBlock(mainBlock)) {\n    const recoveredPrompt = collectPromptBlocksAbove(lines, mainBlockStart - 1);\n    return recoveredPrompt.length > 0 ? recoveredPrompt : mainBlock;\n  }\n\n  if (mainBlockStart <= 1) {\n    return mainBlock;\n  }\n\n  let gapCursor = mainBlockStart - 1;\n  gapCursor = skipBlankLinesUp(lines, gapCursor);\n\n  if (gapCursor < 0 || gapCursor === mainBlockStart - 1) {\n    return mainBlock;\n  }\n\n  const { start: headingBlockStart, end: headingBlockEnd } = findNonEmptyBlockEndingAt(lines, gapCursor);\n  const headingBlock = lines.slice(headingBlockStart, headingBlockEnd + 1).filter(Boolean);\n  const headingMatched = headingBlock.some(isPromptHeadingLine);\n\n  if (!headingMatched) {\n    return mainBlock;\n  }\n\n  return [...headingBlock, ...mainBlock];\n}\n\nfunction isPromptHeadingLine(line: string): boolean {\n  return /^(?:would you like to|do you want to|the model would like to|action required|confirm)\\b/i.test(line);\n}\n\nfunction isLikelyFileSummaryLine(line: string): boolean {\n  return /^.+\\/[^/]+\\s+\\(\\+\\d+\\s+-\\d+\\)$/.test(line);\n}\n\nfunction skipBlankLinesUp(lines: string[], startIndex: number): number {\n  let cursor = startIndex;\n  while (cursor >= 0 && !lines[cursor]) {\n    cursor -= 1;\n  }\n  return cursor;\n}\n\nfunction findNonEmptyBlockEndingAt(lines: string[], endIndex: number): { start: number; end: number } {\n  let cursor = endIndex;\n  while (cursor >= 0 && lines[cursor]) {\n    cursor -= 1;\n  }\n  return {\n    start: cursor + 1,\n    end: endIndex,\n  };\n}\n\nfunction collectPromptBlocksAbove(lines: string[], startIndex: number): string[] {\n  const blocks: string[][] = [];\n  let cursor = startIndex;\n\n  while (cursor >= 0 && blocks.length < 2) {\n    cursor = skipBlankLinesUp(lines, cursor);\n    if (cursor < 0) {\n      break;\n    }\n\n    const { start, end } = findNonEmptyBlockEndingAt(lines, cursor);\n    const block = lines.slice(start, end + 1).filter(Boolean);\n    if (block.length > 0) {\n      blocks.unshift(block);\n    }\n\n    cursor = start - 1;\n  }\n\n  if (blocks.length === 0) {\n    return [];\n  }\n\n  const headingBlockIndex = blocks.findIndex(block => block.some(isPromptHeadingLine));\n  if (headingBlockIndex >= 0) {\n    return blocks.slice(headingBlockIndex).flat();\n  }\n\n  return blocks[blocks.length - 1];\n}\n\nfunction isDiffPreviewBlock(lines: string[]): boolean {\n  if (lines.length === 0) {\n    return false;\n  }\n  const lineNumberedRows = lines.filter(isLineNumberedDiffLine).length;\n  return lineNumberedRows >= Math.max(2, Math.ceil(lines.length / 2));\n}\n\nfunction isLineNumberedDiffLine(line: string): boolean {\n  return /^\\d+\\s/.test(line);\n}\n"]}

package/dist/session/index.d.ts

@@ -0,0 +1,2 @@
+export { resumeOrCreateSession, prepareSessionEncryption } from './session-resume';
+export type { ResumeOrCreateSessionInput, ResumeOrCreateSessionResult } from './session-resume';

package/dist/session/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareSessionEncryption = exports.resumeOrCreateSession = void 0;
+var session_resume_1 = require("./session-resume");
+Object.defineProperty(exports, "resumeOrCreateSession", { enumerable: true, get: function () { return session_resume_1.resumeOrCreateSession; } });
+Object.defineProperty(exports, "prepareSessionEncryption", { enumerable: true, get: function () { return session_resume_1.prepareSessionEncryption; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2Vzc2lvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxtREFBbUY7QUFBMUUsdUhBQUEscUJBQXFCLE9BQUE7QUFBRSwwSEFBQSx3QkFBd0IsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IHJlc3VtZU9yQ3JlYXRlU2Vzc2lvbiwgcHJlcGFyZVNlc3Npb25FbmNyeXB0aW9uIH0gZnJvbSAnLi9zZXNzaW9uLXJlc3VtZSc7XG5leHBvcnQgdHlwZSB7IFJlc3VtZU9yQ3JlYXRlU2Vzc2lvbklucHV0LCBSZXN1bWVPckNyZWF0ZVNlc3Npb25SZXN1bHQgfSBmcm9tICcuL3Nlc3Npb24tcmVzdW1lJztcbiJdfQ==

package/dist/session/session-resume.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Centralized session resume/create logic for all CodeVibe plugins.
+ *
+ * All three plugins (Claude, Codex, Gemini) need the same pattern:
+ * 1. Check if session exists in backend (getSession)
+ * 2. If exists: reactivate + restore E2E session key from encryptedKeys
+ * 3. If not exists: generate encryption keys + create session
+ *
+ * This module eliminates the duplication across plugins.
+ */
+import { AppSyncClient } from '../appsync';
+import { Logger } from '../logger';
+import { AgentType, EncryptedSessionKey } from '../types';
+export interface ResumeOrCreateSessionInput {
+    sessionId: string;
+    userId: string;
+    agentType: AgentType;
+    projectPath: string;
+    metadata?: Record<string, any>;
+}
+export interface ResumeOrCreateSessionResult {
+    /** Whether an existing session was found and reactivated */
+    resumed: boolean;
+    /** The E2E session key (for encrypting/decrypting events), or null if no encryption */
+    sessionKey: string | null;
+}
+/**
+ * Prepare E2E encryption for a new session.
+ *
+ * Generates a random session key and encrypts it for all registered devices.
+ * Does NOT cache the session key — callers should cache only after the session
+ * is successfully created in the backend.
+ *
+ * @returns Encryption data or null if no device keys found / error
+ */
+export declare function prepareSessionEncryption(sessionId: string, appSyncClient: AppSyncClient, logger: Logger): Promise<{
+    sessionKey: string;
+    encryptedKeys: EncryptedSessionKey[];
+} | null>;
+/**
+ * Resume an existing session or create a new one.
+ *
+ * Resume path (session exists in backend):
+ *   - Reactivates session (status → ACTIVE)
+ *   - Restores E2E session key from encryptedKeys
+ *
+ * Create path (session does not exist):
+ *   - Prepares E2E encryption (generates key, encrypts for all devices)
+ *   - Encrypts projectPath and metadata
+ *   - Creates session in backend
+ *   - Caches session key only after successful creation
+ *
+ * @throws Propagates createSession errors (e.g., SESSION_LIMIT_EXCEEDED)
+ */
+export declare function resumeOrCreateSession(input: ResumeOrCreateSessionInput, appSyncClient: AppSyncClient, logger: Logger): Promise<ResumeOrCreateSessionResult>;