ctxman 3.0.0

package/lib/rag/stores/LanceDBStore.js

@@ -0,0 +1,109 @@
+import * as lancedb from '@lancedb/lancedb';
+import fs from 'fs/promises';
+import { BaseVectorStore } from './BaseVectorStore.js';
+
+export class LanceDBStore extends BaseVectorStore {
+  /**
+   * @param {import('../EmbeddingProvider').EmbeddingProvider} embeddingProvider
+   * @param {string} storagePath - Path to store the LanceDB data
+   */
+  constructor(embeddingProvider, storagePath = '.ctxman/rag-store') {
+    super(embeddingProvider);
+    this.storagePath = storagePath;
+    this.db = null;
+    this.table = null;
+    this.tableName = 'documents';
+    this.initialized = false;
+  }
+
+  async init() {
+    if (this.initialized) return;
+
+    // Ensure directory exists
+    await fs.mkdir(this.storagePath, { recursive: true });
+
+    this.db = await lancedb.connect(this.storagePath);
+    
+    const tableNames = await this.db.tableNames();
+    if (tableNames.includes(this.tableName)) {
+      this.table = await this.db.openTable(this.tableName);
+    }
+
+    this.initialized = true;
+  }
+
+  /**
+   * Adds a single document to the store.
+   * @param {string} text 
+   * @param {Object} metadata 
+   */
+  async addDocument(text, metadata = {}) {
+    return this.addDocuments([{ text, metadata }]);
+  }
+
+  /**
+   * Adds multiple documents to the store.
+   * @param {Array<{text: string, metadata: Object}>} docs 
+   */
+  async addDocuments(docs) {
+    if (docs.length === 0) return;
+    if (!this.initialized) await this.init();
+
+    const data = [];
+    for (const doc of docs) {
+      const vector = await this.embeddingProvider.embed(doc.text);
+      data.push({
+        vector,
+        text: doc.text,
+        id: crypto.randomUUID(),
+        timestamp: Date.now(),
+        ...doc.metadata
+      });
+    }
+
+    if (!this.table) {
+      // Create table with the first batch
+      this.table = await this.db.createTable(this.tableName, data);
+    } else {
+      await this.table.add(data);
+    }
+  }
+
+  /**
+   * Semantic search for documents.
+   * @param {string} queryText 
+   * @param {number} limit 
+   * @returns {Promise<Array<{text: string, score: number, metadata: Object}>>}
+   */
+  async search(queryText, limit = 5) {
+    if (!this.initialized) await this.init();
+    if (!this.table) return [];
+
+    const queryVector = await this.embeddingProvider.embed(queryText);
+    
+    // LanceDB returns _distance by default (L2 distance usually).
+    // Lower is better.
+    const results = await this.table.search(queryVector)
+      .limit(limit)
+      .toArray();
+
+    return results.map(row => {
+      const { vector, text, _distance, ...metadata } = row;
+      return {
+        text,
+        score: _distance,
+        metadata
+      };
+    });
+  }
+
+  async deleteTable() {
+    if (!this.initialized) await this.init();
+    try {
+        await this.db.dropTable(this.tableName);
+        this.table = null;
+    } catch (e) {
+        // Ignore if not exists
+    }
+  }
+}

package/lib/rag/stores/PineconeStore.js

@@ -0,0 +1,74 @@
+import { BaseVectorStore } from './BaseVectorStore.js';
+
+export class PineconeStore extends BaseVectorStore {
+  /**
+   * @param {import('../EmbeddingProvider').EmbeddingProvider} embeddingProvider
+   * @param {Object} config
+   * @param {string} config.apiKey
+   * @param {string} config.indexName
+   */
+  constructor(embeddingProvider, config = {}) {
+    super(embeddingProvider);
+    this.apiKey = config.apiKey;
+    this.indexName = config.indexName;
+    this.client = null;
+    this.index = null;
+  }
+
+  async init() {
+    if (this.client) return;
+    if (!this.apiKey) throw new Error('Pinecone API key required');
+
+    try {
+      const { Pinecone } = await import('@pinecone-database/pinecone');
+      this.client = new Pinecone({ apiKey: this.apiKey });
+      this.index = this.client.index(this.indexName);
+    } catch (error) {
+       if (error.code === 'ERR_MODULE_NOT_FOUND') {
+        throw new Error('Please install @pinecone-database/pinecone to use PineconeStore: npm install @pinecone-database/pinecone');
+      }
+      throw error;
+    }
+  }
+
+  async addDocuments(docs) {
+    if (!this.index) await this.init();
+    if (docs.length === 0) return;
+
+    const vectors = [];
+    for (const doc of docs) {
+      const values = await this.embeddingProvider.embed(doc.text);
+      vectors.push({
+        id: doc.id || crypto.randomUUID(),
+        values,
+        metadata: {
+            ...doc.metadata,
+            text: doc.text // Pinecone metadata is limited, but storing text is useful
+        }
+      });
+    }
+
+    // Pinecone likes batches
+    const batchSize = 100;
+    for (let i = 0; i < vectors.length; i += batchSize) {
+        await this.index.upsert(vectors.slice(i, i + batchSize));
+    }
+  }
+
+  async search(queryText, limit = 5) {
+    if (!this.index) await this.init();
+
+    const vector = await this.embeddingProvider.embed(queryText);
+    const results = await this.index.query({
+      vector,
+      topK: limit,
+      includeMetadata: true
+    });
+
+    return results.matches.map(match => ({
+      text: match.metadata.text || '', // Assuming text is stored in metadata
+      score: match.score,
+      metadata: match.metadata
+    }));
+  }
+}

package/lib/ui/dashboard.js

@@ -0,0 +1,109 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput, useStdin } from 'ink';
+
+/**
+ * Live Analysis Dashboard
+ * Real-time statistics and progress display
+ */
+export default function Dashboard({ stats, topFiles = [], status = 'analyzing' }) {
+	const [shouldRefresh, setShouldRefresh] = useState(false);
+	const { isRawModeSupported } = useStdin();
+
+	// Keyboard controls
+	useInput((input, key) => {
+		if (input === 'r' || input === 'R') {
+			setShouldRefresh(!shouldRefresh);
+		}
+		if (input === 'q' || input === 'Q') {
+			process.exit(0);
+		}
+	}, { isActive: isRawModeSupported });
+
+	const {
+		totalFiles = 0,
+		totalTokens = 0,
+		totalBytes = 0,
+		totalLines = 0,
+		byExtension = {}
+	} = stats;
+
+	const avgTokensPerFile = totalFiles > 0 ? Math.round(totalTokens / totalFiles) : 0;
+	const sizeInMB = (totalBytes / (1024 * 1024)).toFixed(2);
+
+	// Get dominant language
+	const extensions = Object.entries(byExtension);
+	const dominant = extensions.length > 0
+		? extensions.sort((a, b) => b[1].count - a[1].count)[0]
+		: null;
+
+	return React.createElement(Box, {
+		flexDirection: 'column',
+		padding: 1,
+		borderStyle: 'round',
+		borderColor: 'green',
+		width: 76  // Max width to prevent scrollbar overlap (reduced from 80)
+	},
+		React.createElement(Box, { marginBottom: 1 },
+			React.createElement(Text, { bold: true, color: 'green' }, '📊 Live Analysis Dashboard'),
+			React.createElement(Text, { color: 'gray' }, ` (${status})`)
+		),
+
+		// Summary Stats
+		React.createElement(Box, { flexDirection: 'column', marginBottom: 1 },
+			React.createElement(Box, null,
+				React.createElement(Text, null, 'Files: '),
+				React.createElement(Text, { bold: true, color: 'cyan' }, totalFiles.toLocaleString()),
+				React.createElement(Text, null, '    Methods: '),
+				React.createElement(Text, { bold: true, color: 'cyan' }, '-'),
+				React.createElement(Text, null, '    Tokens: '),
+				React.createElement(Text, { bold: true, color: 'cyan' }, totalTokens.toLocaleString())
+			),
+
+			React.createElement(Box, null,
+				React.createElement(Text, null, 'Size: '),
+				React.createElement(Text, { bold: true, color: 'cyan' }, `${sizeInMB} MB`),
+				React.createElement(Text, null, '    Lines: '),
+				React.createElement(Text, { bold: true, color: 'cyan' }, totalLines.toLocaleString()),
+				React.createElement(Text, null, '    Avg: '),
+				React.createElement(Text, { bold: true, color: 'cyan' }, `${avgTokensPerFile.toLocaleString()} tok/file`)
+			)
+		),
+
+		// Top Languages
+		dominant && React.createElement(Box, { flexDirection: 'column', marginBottom: 1 },
+			React.createElement(Text, { bold: true }, 'Top Languages:'),
+			React.createElement(Box, { marginLeft: 2 },
+				React.createElement(Text, { color: 'green' }, '▓'.repeat(30)),
+				React.createElement(Text, null, ` ${dominant[0]} (${dominant[1].count} files)`)
+			)
+		),
+
+		// Largest Files
+		topFiles.length > 0 && React.createElement(Box, { flexDirection: 'column', marginBottom: 1 },
+			React.createElement(Text, { bold: true }, 'Largest Files:'),
+			...topFiles.slice(0, 3).map((file, index) => {
+				const barLength = Math.round((file.tokens / topFiles[0].tokens) * 20);
+				const percentage = ((file.tokens / totalTokens) * 100).toFixed(1);
+				const fileName = (file.name || file.relativePath || file.path || 'unknown').substring(0, 30);
+
+				return React.createElement(Box, { key: index, marginLeft: 2 },
+					React.createElement(Text, null, '• '),
+					React.createElement(Text, { color: 'cyan' }, fileName),
+					React.createElement(Text, null, ` ${file.tokens.toLocaleString()} tokens  `),
+					React.createElement(Text, { color: 'green' }, '▓'.repeat(barLength)),
+					React.createElement(Text, { color: 'gray' }, ` (${percentage}%)`)
+				);
+			})
+		),
+
+		// Controls
+		React.createElement(Box, {
+			marginTop: 1,
+			borderStyle: 'single',
+			borderColor: 'gray',
+			padding: 1
+		},
+			React.createElement(Text, { dimColor: true }, '[R] Refresh  [S] Save  [E] Export  [Q] Quit')
+		)
+	);
+}

package/lib/ui/index.js

@@ -0,0 +1,15 @@
+/**
+ * Ink-based Terminal UI Components
+ * v2.3.0 - Modern, interactive CLI experience
+ */
+
+import { ProgressBar, SpinnerWithText } from './progress-bar.js';
+import Wizard from './wizard.js';
+import Dashboard from './dashboard.js';
+
+export {
+    ProgressBar,
+    SpinnerWithText,
+    Wizard,
+    Dashboard
+};

package/lib/ui/progress-bar.js

@@ -0,0 +1,110 @@
+import React from 'react.js';
+
+/**
+ * Progress Bar Component for Ink Terminal UI
+ * Shows analysis progress with file count and token count
+ *
+ * Note: Components are passed via props to avoid ESM import issues
+ */
+const ProgressBar = ({ current, total, tokens, maxTokens, currentFile, components }) => {
+    const { Box, Text } = components || {};
+
+    if (!Box || !Text) {
+        throw new Error('Box and Text components required in props');
+    }
+
+    const percentage = total > 0 ? Math.round((current / total) * 100) : 0;
+    const barWidth = 40;
+    const filled = Math.round((percentage / 100) * barWidth);
+    const empty = barWidth - filled;
+
+    const bar = '━'.repeat(filled) + '─'.repeat(empty);
+    const tokenPercentage = maxTokens > 0 ? ((tokens / maxTokens) * 100).toFixed(1) : 0;
+
+    const children = [];
+
+    // Title
+    children.push(
+        React.createElement(Box, { key: 'title' },
+            React.createElement(Text, { bold: true, color: 'cyan' }, '📊 Project Analysis')
+        )
+    );
+
+    // Progress bar
+    children.push(
+        React.createElement(Box, { key: 'bar', marginTop: 1 },
+            React.createElement(Text, { color: 'green' }, bar),
+            React.createElement(Text, { color: 'yellow' }, ` ${percentage}%`),
+            React.createElement(Text, { color: 'gray' }, ` (${current}/${total} files)`)
+        )
+    );
+
+    // Current file
+    if (currentFile) {
+        children.push(
+            React.createElement(Box, { key: 'current', marginTop: 1 },
+                React.createElement(Text, { color: 'gray' }, 'Current: '),
+                React.createElement(Text, null, currentFile)
+            )
+        );
+    }
+
+    // Tokens
+    const tokenColor = tokenPercentage > 90 ? 'red' : 'green';
+    const tokenChildren = [
+        React.createElement(Text, { key: 't1', color: 'gray' }, 'Tokens: '),
+        React.createElement(Text, { key: 't2', color: tokenColor }, tokens.toLocaleString())
+    ];
+
+    if (maxTokens > 0) {
+        tokenChildren.push(
+            React.createElement(Text, { key: 't3', color: 'gray' },
+                ` / ${maxTokens.toLocaleString()} (${tokenPercentage}%)`)
+        );
+    }
+
+    children.push(
+        React.createElement(Box, { key: 'tokens', marginTop: 1 }, ...tokenChildren)
+    );
+
+    return React.createElement(Box, { flexDirection: 'column' }, ...children);
+};
+
+/**
+ * Spinner Component with message
+ */
+const SpinnerWithText = ({ text, status = 'pending', components }) => {
+    const { Box, Text, Spinner } = components || {};
+
+    if (!Box || !Text) {
+        throw new Error('Box and Text components required in props');
+    }
+
+    const statusIcons = {
+        pending: '○',
+        active: Spinner ? React.createElement(Spinner, { type: 'dots' }) : '⏳',
+        complete: '✓',
+        error: '✗'
+    };
+
+    const statusColors = {
+        pending: 'gray',
+        active: 'cyan',
+        complete: 'green',
+        error: 'red'
+    };
+
+    const icon = status === 'active' && Spinner
+        ? React.createElement(Spinner, { type: 'dots' })
+        : statusIcons[status];
+
+    return React.createElement(Box, null,
+        React.createElement(Text, { color: statusColors[status] },
+            icon,
+            ' ',
+            text
+        )
+    );
+};
+
+export { ProgressBar, SpinnerWithText };

package/lib/ui/select-input.js

@@ -0,0 +1,51 @@
+import React, { useState, useCallback } from 'react';
+import { Box, Text, useInput, useStdin } from 'ink';
+
+/**
+ * Custom SelectInput Component for Ink 6.x
+ * Replaces deprecated ink-select-input package
+ * Based on official Ink examples/select-input implementation
+ *
+ * @param {Array} items - Array of {label, value} objects
+ * @param {Function} onSelect - Callback when item is selected
+ */
+export default function SelectInput({ items = [], onSelect }) {
+	const [selectedIndex, setSelectedIndex] = useState(0);
+	const { isRawModeSupported } = useStdin();
+
+	useInput(useCallback((input, key) => {
+		if (key.upArrow) {
+			setSelectedIndex(prev =>
+				prev === 0 ? items.length - 1 : prev - 1
+			);
+		}
+
+		if (key.downArrow) {
+			setSelectedIndex(prev =>
+				prev === items.length - 1 ? 0 : prev + 1
+			);
+		}
+
+		if (key.return) {
+			if (items[selectedIndex] && onSelect) {
+				onSelect(items[selectedIndex]);
+			}
+		}
+
+		if (key.escape) {
+			process.exit(0);
+		}
+	}, [selectedIndex, items, onSelect]), { isActive: isRawModeSupported });
+
+	// Show ALL items (no scrolling/limit) - per Ink docs
+	return React.createElement(Box, { flexDirection: 'column' },
+		...items.map((item, index) => {
+			const isSelected = index === selectedIndex;
+
+			return React.createElement(Text, {
+				key: item.value || item.label || index,  // Use unique value as key
+				color: isSelected ? 'cyan' : undefined
+			}, `${isSelected ? '❯ ' : '  '}${item.label}`);
+		})
+	);
+}