@optiqcode/cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Optiq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,89 @@
+# Optiq CLI
+
+Official CLI tool for [Optiq](https://optiqcode.com) - automatic code indexing and intelligent context engine for your codebase.
+
+## Installation
+
+```bash
+npm install -g @optiqcode/cli
+```
+
+## Quick Start
+
+1. **Login to Optiq**
+```bash
+optiq login
+```
+
+2. **Index your codebase**
+```bash
+optiq index
+# Or specify a directory
+optiq index --path ./my-project
+```
+
+3. **Watch for changes** (optional)
+```bash
+optiq watch
+# Or specify a directory
+optiq watch --path ./my-project
+```
+
+## Commands
+
+### `optiq login`
+Authenticate with your Optiq account. You'll need to provide your email and password.
+
+### `optiq logout`
+Sign out from your Optiq account.
+
+### `optiq whoami`
+Display your current logged-in account.
+
+### `optiq index [options]`
+Index your codebase for intelligent search and context retrieval.
+
+**Options:**
+- `--path <directory>` - Directory to index (defaults to current directory)
+
+**Features:**
+- Incremental indexing (only re-indexes changed files)
+- Respects `.gitignore` patterns
+- Supports multiple languages (TypeScript, JavaScript, Python, Rust, Go, Java, C/C++, and more)
+
+### `optiq watch [options]`
+Watch your codebase for changes and automatically re-index modified files.
+
+**Options:**
+- `--path <directory>` - Directory to watch (defaults to current directory)
+
+**Features:**
+- Real-time file monitoring
+- Debounced indexing (waits 5 seconds after last change)
+- Automatic incremental updates
+
+## Use Cases
+
+- **AI-Powered Code Search**: Use with the Optiq MCP server for intelligent codebase queries
+- **Context Engine**: Provide relevant code context to AI assistants
+- **Documentation**: Keep your code index up-to-date for documentation tools
+- **Code Analysis**: Enable advanced code analysis and insights
+
+## Configuration
+
+The CLI stores your authentication token in `~/.optiq/config.json`.
+
+## Requirements
+
+- Node.js >= 18.0.0
+- An Optiq account (sign up at [optiqcode.com](https://optiqcode.com))
+
+## Support
+
+- Documentation: [docs.optiqcode.com](https://docs.optiqcode.com)
+- Issues: [github.com/optiqcode/optiq/issues](https://github.com/optiqcode/optiq/issues)
+- Email: support@optiqcode.com
+
+## License
+
+MIT

package/dist/commands/auth.d.ts

@@ -0,0 +1,3 @@
+export declare function login(): Promise<void>;
+export declare function logout(): Promise<void>;
+export declare function whoami(): Promise<void>;

package/dist/commands/auth.js

@@ -0,0 +1,73 @@
+import prompts from 'prompts';
+import axios from 'axios';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getConfig, saveConfig, clearConfig } from '../utils/config.js';
+const API_URL = 'https://optiqcode.com/api';
+export async function login() {
+    // Test comment: verifying incremental indexing works correctly
+    console.log(chalk.blue('🔐 Login to Optiq\n'));
+    const response = await prompts([
+        {
+            type: 'text',
+            name: 'email',
+            message: 'Email:',
+            validate: (value) => value.includes('@') || 'Please enter a valid email',
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Password:',
+        },
+    ]);
+    if (!response.email || !response.password) {
+        console.log(chalk.yellow('\n⚠️  Login cancelled'));
+        return;
+    }
+    const spinner = ora('Logging in...').start();
+    try {
+        const result = await axios.post(`${API_URL}/auth/login`, {
+            email: response.email,
+            password: response.password,
+        });
+        if (result.data.success) {
+            await saveConfig({
+                email: response.email,
+                token: result.data.token,
+                apiKey: result.data.context_engine_api_key,
+            });
+            spinner.succeed(chalk.green(`✓ Logged in as ${response.email}`));
+        }
+        else {
+            spinner.fail(chalk.red('✗ Login failed'));
+            console.log(chalk.red(result.data.error || 'Unknown error'));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('✗ Login failed'));
+        if (error.response?.data?.error) {
+            console.log(chalk.red(error.response.data.error));
+        }
+        else {
+            console.log(chalk.red(error.message));
+        }
+    }
+}
+export async function logout() {
+    const config = await getConfig();
+    if (!config) {
+        console.log(chalk.yellow('⚠️  Not logged in'));
+        return;
+    }
+    await clearConfig();
+    console.log(chalk.green('✓ Logged out successfully'));
+}
+export async function whoami() {
+    const config = await getConfig();
+    if (!config) {
+        console.log(chalk.yellow('⚠️  Not logged in'));
+        console.log(chalk.dim('Run `optiq login` to get started'));
+        return;
+    }
+    console.log(chalk.blue('📧 Logged in as:'), chalk.bold(config.email));
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,5 @@
+interface IndexOptions {
+    path?: string;
+}
+export declare function index(options: IndexOptions): Promise<void>;
+export {};

package/dist/commands/index.js

@@ -0,0 +1,121 @@
+import prompts from 'prompts';
+import axios from 'axios';
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'path';
+import fs from 'fs/promises';
+import { getConfig } from '../utils/config.js';
+import { isValidDirectory, getGitIgnorePatterns, shouldIgnoreFile } from '../utils/files.js';
+const API_URL = 'https://optiqcode.com/api';
+export async function index(options) {
+    const config = await getConfig();
+    if (!config) {
+        console.log(chalk.red('✗ Not logged in'));
+        console.log(chalk.dim('Run `optiq login` first'));
+        return;
+    }
+    const targetPath = path.resolve(options.path || process.cwd());
+    // Safety check: prevent indexing home directory
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    if (homeDir && path.resolve(targetPath) === path.resolve(homeDir)) {
+        console.log(chalk.red('✗ Cannot index home directory'));
+        console.log(chalk.dim('Please specify a project directory'));
+        return;
+    }
+    // Validate directory
+    const validation = await isValidDirectory(targetPath);
+    if (!validation.valid) {
+        console.log(chalk.red(`✗ ${validation.error}`));
+        return;
+    }
+    console.log(chalk.blue('📁 Directory:'), chalk.bold(targetPath));
+    console.log(chalk.dim(`   ${validation.fileCount} files found\n`));
+    // Ask for confirmation
+    const { confirm } = await prompts({
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Index this directory?',
+        initial: true,
+    });
+    if (!confirm) {
+        console.log(chalk.yellow('\n⚠️  Indexing cancelled'));
+        return;
+    }
+    const spinner = ora('Collecting files...').start();
+    try {
+        // Collect all files
+        const files = await collectFiles(targetPath);
+        spinner.text = `Reading ${files.length} files...`;
+        // Read file contents
+        const fileContents = [];
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                const relativePath = path.relative(targetPath, file);
+                // CRITICAL FIX: Normalize path separators to forward slashes for cross-platform consistency
+                const normalizedPath = relativePath.replace(/\\/g, '/');
+                fileContents.push({
+                    path: normalizedPath,
+                    content: content,
+                });
+            }
+            catch (error) {
+                // Skip files that can't be read
+            }
+        }
+        spinner.text = 'Uploading to Optiq...';
+        // Send to API
+        const response = await axios.post(`${API_URL}/nexus/index/content`, {
+            repository_path: targetPath,
+            files: fileContents,
+        }, {
+            headers: {
+                Authorization: `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 120000,
+        });
+        if (response.data.success) {
+            spinner.succeed(chalk.green('✓ Indexing complete'));
+            console.log(chalk.blue('📊 Repository ID:'), chalk.bold(response.data.repo_id));
+            console.log(chalk.blue('📁 Files indexed:'), chalk.bold(response.data.files_processed));
+            console.log(chalk.blue('📝 Entities indexed:'), chalk.bold(response.data.entities_indexed));
+            console.log(chalk.dim('\nUse this repo_id with the MCP server or API'));
+        }
+        else {
+            spinner.fail(chalk.red('✗ Indexing failed'));
+            console.log(chalk.red(response.data.error || 'Unknown error'));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('✗ Indexing failed'));
+        if (error.response?.data?.error) {
+            console.log(chalk.red(error.response.data.error));
+        }
+        else {
+            console.log(chalk.red(error.message));
+        }
+    }
+}
+async function collectFiles(dir) {
+    const files = [];
+    const ignorePatterns = await getGitIgnorePatterns(dir);
+    async function walk(currentPath) {
+        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            const relativePath = path.relative(dir, fullPath);
+            if (shouldIgnoreFile(relativePath, ignorePatterns)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                files.push(fullPath);
+            }
+        }
+    }
+    await walk(dir);
+    return files;
+}

package/dist/commands/watch.d.ts

@@ -0,0 +1,5 @@
+interface WatchOptions {
+    path?: string;
+}
+export declare function watch(options: WatchOptions): Promise<void>;
+export {};

package/dist/commands/watch.js

@@ -0,0 +1,156 @@
+import prompts from 'prompts';
+import axios from 'axios';
+import chalk from 'chalk';
+import chokidar from 'chokidar';
+import path from 'path';
+import fs from 'fs/promises';
+import { getConfig } from '../utils/config.js';
+import { isValidDirectory, getGitIgnorePatterns, shouldIgnoreFile } from '../utils/files.js';
+const API_URL = 'https://optiqcode.com/api';
+export async function watch(options) {
+    const config = await getConfig();
+    if (!config) {
+        console.log(chalk.red('✗ Not logged in'));
+        console.log(chalk.dim('Run `optiq login` first'));
+        return;
+    }
+    const targetPath = path.resolve(options.path || process.cwd());
+    // Safety check: prevent watching home directory
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    if (homeDir && path.resolve(targetPath) === path.resolve(homeDir)) {
+        console.log(chalk.red('✗ Cannot watch home directory'));
+        console.log(chalk.dim('Please specify a project directory'));
+        return;
+    }
+    // Validate directory
+    const validation = await isValidDirectory(targetPath);
+    if (!validation.valid) {
+        console.log(chalk.red(`✗ ${validation.error}`));
+        return;
+    }
+    console.log(chalk.blue('📁 Directory:'), chalk.bold(targetPath));
+    console.log(chalk.dim(`   ${validation.fileCount} files found\n`));
+    // Ask for confirmation
+    const { confirm } = await prompts({
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Start watching this directory?',
+        initial: true,
+    });
+    if (!confirm) {
+        console.log(chalk.yellow('\n⚠️  Watch cancelled'));
+        return;
+    }
+    console.log(chalk.green('✓ Starting file watcher...\n'));
+    const ignorePatterns = await getGitIgnorePatterns(targetPath);
+    // Create watcher
+    const watcher = chokidar.watch(targetPath, {
+        ignored: (filePath) => {
+            const relativePath = path.relative(targetPath, filePath);
+            return shouldIgnoreFile(relativePath, ignorePatterns);
+        },
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 2000,
+            pollInterval: 100,
+        },
+    });
+    let repoId = null;
+    const pendingChanges = new Map();
+    let debounceTimer = null;
+    const processChanges = async () => {
+        if (pendingChanges.size === 0)
+            return;
+        const changes = Array.from(pendingChanges.entries());
+        pendingChanges.clear();
+        console.log(chalk.blue(`\n📝 Processing ${changes.length} changes...`));
+        try {
+            const fileContents = [];
+            for (const [filePath, changeType] of changes) {
+                const relativePath = path.relative(targetPath, filePath);
+                // CRITICAL FIX: Normalize path separators to forward slashes for cross-platform consistency
+                const normalizedPath = relativePath.replace(/\\/g, '/');
+                if (changeType === 'unlink') {
+                    fileContents.push({
+                        path: normalizedPath,
+                        content: null,
+                    });
+                }
+                else {
+                    try {
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        fileContents.push({
+                            path: normalizedPath,
+                            content: content,
+                        });
+                    }
+                    catch (error) {
+                        // Skip files that can't be read
+                    }
+                }
+            }
+            const response = await axios.post(`${API_URL}/nexus/index/incremental`, {
+                repository_id: repoId,
+                repository_path: targetPath,
+                files: fileContents,
+            }, {
+                headers: {
+                    Authorization: `Bearer ${config.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                timeout: 60000,
+            });
+            if (response.data.success) {
+                if (!repoId) {
+                    repoId = response.data.repo_id || response.data.repository_id;
+                    console.log(chalk.blue('📊 Repository ID:'), chalk.bold(repoId));
+                }
+                console.log(chalk.green(`✓ Indexed ${response.data.files_processed || changes.length} files, ${response.data.entities_indexed || 0} entities`));
+            }
+            else {
+                console.log(chalk.red('✗ Indexing failed:'), response.data.error);
+            }
+        }
+        catch (error) {
+            console.log(chalk.red('✗ Indexing failed:'), error.message);
+        }
+    };
+    const scheduleProcess = () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        // Wait 5 seconds after last change before indexing to avoid spam
+        debounceTimer = setTimeout(processChanges, 5000);
+    };
+    watcher
+        .on('add', (filePath) => {
+        const relativePath = path.relative(targetPath, filePath);
+        console.log(chalk.dim(`  + ${relativePath}`));
+        pendingChanges.set(filePath, 'add');
+        scheduleProcess();
+    })
+        .on('change', (filePath) => {
+        const relativePath = path.relative(targetPath, filePath);
+        console.log(chalk.dim(`  ~ ${relativePath}`));
+        pendingChanges.set(filePath, 'change');
+        scheduleProcess();
+    })
+        .on('unlink', (filePath) => {
+        const relativePath = path.relative(targetPath, filePath);
+        console.log(chalk.dim(`  - ${relativePath}`));
+        pendingChanges.set(filePath, 'unlink');
+        scheduleProcess();
+    })
+        .on('error', (error) => {
+        console.log(chalk.red('✗ Watcher error:'), error.message);
+    });
+    console.log(chalk.green('👀 Watching for changes...'));
+    console.log(chalk.dim('Press Ctrl+C to stop\n'));
+    // Keep process alive
+    process.on('SIGINT', () => {
+        console.log(chalk.yellow('\n\n⚠️  Stopping watcher...'));
+        watcher.close();
+        process.exit(0);
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,498 @@
+#!/usr/bin/env node
+import prompts from 'prompts';
+import axios from 'axios';
+import chalk from 'chalk';
+import ora from 'ora';
+import chokidar from 'chokidar';
+import path from 'path';
+import fs from 'fs/promises';
+import logUpdate from 'log-update';
+import { getConfig, saveConfig } from './utils/config.js';
+import { isValidDirectory, getGitIgnorePatterns, shouldIgnoreFile } from './utils/files.js';
+const BACKEND_URL = process.env.OPTIQ_BACKEND_URL || 'http://localhost:3002';
+async function showBanner() {
+    console.clear();
+    console.log(chalk.white.bold(`
+   ___        _   _       
+  / _ \\ _ __ | |_(_) __ _ 
+ | | | | '_ \\| __| |/ _\` |
+ | |_| | |_) | |_| | (_| |
+  \\___/| .__/ \\__|_|\\__, |
+       |_|             |_|
+  `));
+    console.log(chalk.gray('  Automatic code indexing\n'));
+}
+async function login() {
+    console.log(chalk.white('🔐 Passwordless login\n'));
+    const { email } = await prompts({
+        type: 'text',
+        name: 'email',
+        message: 'Email:',
+        validate: (value) => value.includes('@') || 'Please enter a valid email',
+    });
+    if (!email) {
+        console.log(chalk.gray('\n⚠️  Login cancelled'));
+        process.exit(0);
+    }
+    const spinner = ora({ text: 'Sending code...', color: 'white' }).start();
+    try {
+        // Send OTP
+        const otpResponse = await axios.post(`${BACKEND_URL}/api/auth/send-otp`, { email }, { timeout: 10000 });
+        if (!otpResponse.data.success) {
+            throw new Error('Failed to send code');
+        }
+        spinner.succeed(chalk.white('✓ Code sent to your email\n'));
+        const { code } = await prompts({
+            type: 'text',
+            name: 'code',
+            message: 'Enter code:',
+            validate: (value) => {
+                const cleaned = value.replace(/\s/g, '');
+                return cleaned.length >= 5 || 'Invalid code';
+            },
+        });
+        if (!code) {
+            console.log(chalk.gray('\n⚠️  Login cancelled'));
+            return false;
+        }
+        const verifySpinner = ora({ text: 'Verifying...', color: 'white' }).start();
+        // Verify OTP
+        const verifyResponse = await axios.post(`${BACKEND_URL}/api/auth/verify-otp`, { email, code }, { timeout: 10000 });
+        if (verifyResponse.data.success) {
+            // Get token from response body or cookie
+            let token = verifyResponse.data.auth_token;
+            // If no token in body, extract from cookie
+            if (!token || token === '') {
+                const cookies = verifyResponse.headers['set-cookie'];
+                if (cookies) {
+                    const authCookie = cookies.find((c) => c.startsWith('auth_token='));
+                    if (authCookie) {
+                        token = authCookie.split(';')[0].split('=')[1];
+                    }
+                }
+            }
+            if (!token) {
+                verifySpinner.fail(chalk.gray('✗ No token received'));
+                return false;
+            }
+            // Get API key by validating the token
+            const validateResponse = await axios.post(`${BACKEND_URL}/api/auth/validate`, { token }, { timeout: 5000 });
+            await saveConfig({
+                email: email,
+                token: token,
+                apiKey: validateResponse.data.context_engine_api_key || '',
+            });
+            verifySpinner.succeed(chalk.white(`✓ Logged in as ${email}\n`));
+            return true;
+        }
+        else {
+            verifySpinner.fail(chalk.gray('✗ Invalid code'));
+            return false;
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.gray('✗ Login failed'));
+        if (error.response?.data?.error) {
+            console.log(chalk.gray(error.response.data.error));
+        }
+        else {
+            console.log(chalk.gray(error.message));
+        }
+        return false;
+    }
+}
+async function main() {
+    await showBanner();
+    // Check if logged in
+    let config = await getConfig();
+    if (!config) {
+        const success = await login();
+        if (!success) {
+            process.exit(1);
+        }
+        config = await getConfig();
+        if (!config) {
+            process.exit(1);
+        }
+    }
+    else {
+        console.log(chalk.white('✓ Logged in as'), chalk.white.bold(config.email));
+        console.log();
+    }
+    const targetPath = path.resolve(process.cwd());
+    // Safety check: prevent indexing home directory
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    if (homeDir && path.resolve(targetPath) === path.resolve(homeDir)) {
+        console.log(chalk.gray('✗ Cannot index home directory'));
+        console.log(chalk.gray('Please run this from a project directory'));
+        process.exit(1);
+    }
+    // Validate directory
+    const validation = await isValidDirectory(targetPath);
+    if (!validation.valid) {
+        console.log(chalk.gray(`✗ ${validation.error}`));
+        process.exit(1);
+    }
+    console.log(chalk.white('📁 Directory:'), chalk.white.bold(path.basename(targetPath)));
+    console.log(chalk.gray(`   ${validation.fileCount} files found`));
+    console.log(chalk.gray(`   ${targetPath}\n`));
+    // Ask what to do
+    const { action } = await prompts({
+        type: 'select',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+            { title: '👀 Watch and auto-index changes', value: 'watch' },
+            { title: '📦 Index once', value: 'index' },
+            { title: '🚪 Logout', value: 'logout' },
+            { title: '❌ Exit', value: 'exit' },
+        ],
+    });
+    if (action === 'exit') {
+        console.log(chalk.gray('\nGoodbye!'));
+        process.exit(0);
+    }
+    if (action === 'logout') {
+        const { clearConfig } = await import('./utils/config.js');
+        await clearConfig();
+        console.log(chalk.white('\n✓ Logged out successfully'));
+        process.exit(0);
+    }
+    if (action === 'index') {
+        await indexOnce(targetPath, config);
+    }
+    else if (action === 'watch') {
+        await watchDirectory(targetPath, config);
+    }
+}
+async function indexOnce(targetPath, config) {
+    const spinner = ora({ text: 'Collecting files...', color: 'white' }).start();
+    try {
+        const files = await collectFiles(targetPath);
+        spinner.text = `Reading ${files.length} files...`;
+        const fileContents = {};
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                const relativePath = path.relative(targetPath, file);
+                fileContents[relativePath] = content;
+            }
+            catch (error) {
+                // Skip files that can't be read
+            }
+        }
+        spinner.text = 'Uploading to Optiq...';
+        const filesArray = Object.entries(fileContents).map(([path, content]) => ({
+            path,
+            content,
+        }));
+        const response = await axios.post(`${BACKEND_URL}/api/nexus/index/content`, {
+            repository_path: targetPath,
+            files: filesArray,
+        }, {
+            headers: {
+                'X-API-Key': config.apiKey,
+                'Content-Type': 'application/json',
+            },
+            timeout: 120000,
+        });
+        if (response.data.success) {
+            spinner.succeed(chalk.white('✓ Indexing complete'));
+            console.log(chalk.white('\n📊 Repository ID:'), chalk.white.bold(response.data.repo_id));
+            console.log(chalk.gray('   Use this with the MCP server or API\n'));
+        }
+        else {
+            spinner.fail(chalk.gray('✗ Indexing failed'));
+            console.log(chalk.gray(response.data.error || 'Unknown error'));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.gray('✗ Indexing failed'));
+        if (error.response?.data?.error) {
+            console.log(chalk.gray(error.response.data.error));
+        }
+        else {
+            console.log(chalk.gray(error.message));
+        }
+    }
+}
+async function watchDirectory(targetPath, config) {
+    // Check if repo is already indexed
+    let repoId = null;
+    try {
+        const repoListResponse = await axios.get(`${BACKEND_URL}/api/repositories`, {
+            headers: {
+                'X-API-Key': config.apiKey,
+            },
+            timeout: 10000,
+        });
+        if (repoListResponse.data.success && repoListResponse.data.repositories) {
+            const existingRepo = repoListResponse.data.repositories.find((r) => r.path === targetPath);
+            if (existingRepo) {
+                repoId = existingRepo.id;
+                console.log(chalk.white('✓ Repository already indexed'));
+                console.log(chalk.white('📊 Repository ID:'), chalk.white.bold(repoId));
+                console.log();
+            }
+        }
+    }
+    catch (error) {
+        // Ignore errors, will do full index
+    }
+    // Only do full index if repo doesn't exist
+    if (!repoId) {
+        const spinner = ora({ text: 'Collecting files...', color: 'white' }).start();
+        try {
+            const files = await collectFiles(targetPath);
+            spinner.text = `Indexing ${files.length} files...`;
+            const fileContents = {};
+            let processed = 0;
+            for (const file of files) {
+                try {
+                    const content = await fs.readFile(file, 'utf-8');
+                    const relativePath = path.relative(targetPath, file);
+                    fileContents[relativePath] = content;
+                    processed++;
+                    // Update progress
+                    const percent = Math.round((processed / files.length) * 100);
+                    spinner.text = `Indexing ${processed}/${files.length} files (${percent}%)`;
+                }
+                catch (error) {
+                    // Skip files that can't be read
+                }
+            }
+            spinner.text = 'Uploading to Optiq...';
+            const filesArray = Object.entries(fileContents).map(([path, content]) => ({
+                path,
+                content,
+            }));
+            const response = await axios.post(`${BACKEND_URL}/api/nexus/index/content`, {
+                repository_path: targetPath,
+                files: filesArray,
+            }, {
+                headers: {
+                    'X-API-Key': config.apiKey,
+                    'Content-Type': 'application/json',
+                },
+                timeout: 120000,
+            });
+            if (response.data.success) {
+                repoId = response.data.repo_id;
+                spinner.succeed(chalk.white(`Indexed ${files.length} files`));
+                console.log(chalk.gray('Repository ID:'), chalk.white.bold(repoId));
+                console.log();
+            }
+            else {
+                spinner.fail(chalk.gray('Initial indexing failed'));
+                console.log(chalk.gray(response.data.error || 'Unknown error'));
+                return;
+            }
+        }
+        catch (error) {
+            spinner.fail(chalk.gray('✗ Initial indexing failed'));
+            if (error.response?.data?.error) {
+                console.log(chalk.gray(error.response.data.error));
+            }
+            else {
+                console.log(chalk.gray(error.message));
+            }
+            return;
+        }
+    }
+    console.log(chalk.white('👀 Watching for changes...\n'));
+    const ignorePatterns = await getGitIgnorePatterns(targetPath);
+    const watcher = chokidar.watch(targetPath, {
+        ignored: (filePath) => {
+            const relativePath = path.relative(targetPath, filePath);
+            return shouldIgnoreFile(relativePath, ignorePatterns);
+        },
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 300,
+            pollInterval: 50,
+        },
+    });
+    const pendingChanges = new Map();
+    let debounceTimer = null;
+    const allIndexedFiles = new Set();
+    const fileContentCache = new Map();
+    let isProcessing = false;
+    let totalIndexed = 0;
+    let sessionStartTime = Date.now();
+    let lastIndexedFile = '';
+    let lastIndexedTime = Date.now();
+    const formatUptime = (ms) => {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        if (hours > 0)
+            return `${hours}h ${minutes % 60}m`;
+        if (minutes > 0)
+            return `${minutes}m ${seconds % 60}s`;
+        return `${seconds}s`;
+    };
+    const updateDashboard = () => {
+        const uptime = formatUptime(Date.now() - sessionStartTime);
+        const timeSinceLastIndex = Math.floor((Date.now() - lastIndexedTime) / 1000);
+        const lines = [];
+        lines.push(chalk.white.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        lines.push(`${chalk.cyan('📊 Session Stats')}`);
+        lines.push(`   ${chalk.gray('Uptime:')} ${chalk.white(uptime)}`);
+        lines.push(`   ${chalk.gray('Total Indexed:')} ${chalk.white(totalIndexed)} ${chalk.gray('changes')}`);
+        lines.push(`   ${chalk.gray('Unique Files:')} ${chalk.white(allIndexedFiles.size)}`);
+        lines.push('');
+        lines.push(`${chalk.green('●')} ${chalk.gray('Last Activity:')} ${chalk.white(lastIndexedFile || 'None')}`);
+        if (lastIndexedFile) {
+            lines.push(`   ${chalk.gray(`${timeSinceLastIndex}s ago`)}`);
+        }
+        lines.push(chalk.white.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        lines.push('');
+        logUpdate(lines.join('\n'));
+    };
+    // Update dashboard every 5 seconds to show uptime
+    const dashboardInterval = setInterval(updateDashboard, 5000);
+    const processChanges = async () => {
+        if (pendingChanges.size === 0 || isProcessing)
+            return;
+        isProcessing = true;
+        const changes = Array.from(pendingChanges.entries());
+        pendingChanges.clear();
+        // Collect unique files first
+        const uniqueFiles = new Set();
+        for (const [filePath] of changes) {
+            const relativePath = path.relative(targetPath, filePath);
+            uniqueFiles.add(relativePath);
+            allIndexedFiles.add(relativePath);
+        }
+        const fileList = Array.from(uniqueFiles);
+        try {
+            const filesArray = [];
+            let hasChanges = false;
+            for (const [filePath, changeType] of changes) {
+                const relativePath = path.relative(targetPath, filePath);
+                if (changeType === 'unlink') {
+                    filesArray.push({ path: relativePath, content: null });
+                    fileContentCache.delete(relativePath);
+                    hasChanges = true;
+                }
+                else {
+                    try {
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        // Skip if content hasn't changed
+                        if (fileContentCache.get(relativePath) === content) {
+                            continue;
+                        }
+                        fileContentCache.set(relativePath, content);
+                        filesArray.push({ path: relativePath, content });
+                        hasChanges = true;
+                    }
+                    catch (error) {
+                        // Skip files that can't be read
+                    }
+                }
+            }
+            // If no actual changes, skip indexing
+            if (!hasChanges || filesArray.length === 0) {
+                isProcessing = false;
+                return;
+            }
+            const response = await axios.post(`${BACKEND_URL}/api/nexus/index/incremental`, {
+                repository_id: repoId,
+                repository_path: targetPath,
+                files: filesArray,
+            }, {
+                headers: {
+                    'X-API-Key': config.apiKey,
+                    'Content-Type': 'application/json',
+                },
+                timeout: 60000,
+            });
+            if (response.data.success) {
+                totalIndexed += filesArray.length;
+                lastIndexedTime = Date.now();
+                // Update last indexed file
+                if (filesArray.length === 1) {
+                    lastIndexedFile = filesArray[0].path;
+                }
+                else {
+                    lastIndexedFile = `${filesArray.length} files`;
+                }
+                // Update dashboard
+                updateDashboard();
+            }
+            else {
+                logUpdate.clear();
+                console.log(chalk.gray(`✗ Indexing failed`));
+                console.log(chalk.gray(response.data.error));
+            }
+        }
+        catch (error) {
+            logUpdate.clear();
+            console.log(chalk.gray(`✗ Indexing failed`));
+            console.log(chalk.gray(error.response?.data || error.message));
+        }
+        isProcessing = false;
+        // Check if there are more pending changes and process them
+        if (pendingChanges.size > 0) {
+            scheduleProcess();
+        }
+    };
+    const scheduleProcess = () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(processChanges, 50); // Batch rapid changes
+    };
+    watcher
+        .on('add', (filePath) => {
+        const relativePath = path.relative(targetPath, filePath);
+        pendingChanges.set(filePath, 'add');
+        scheduleProcess();
+    })
+        .on('change', (filePath) => {
+        const relativePath = path.relative(targetPath, filePath);
+        pendingChanges.set(filePath, 'change');
+        scheduleProcess();
+    })
+        .on('unlink', (filePath) => {
+        const relativePath = path.relative(targetPath, filePath);
+        pendingChanges.set(filePath, 'unlink');
+        scheduleProcess();
+    })
+        .on('error', (error) => {
+        console.log(chalk.gray('✗ Watcher error:'), error.message);
+    });
+    console.log(chalk.gray('Press Ctrl+C to stop\n'));
+    process.on('SIGINT', () => {
+        console.log(chalk.gray('\n\n⚠️  Stopping watcher...'));
+        watcher.close();
+        process.exit(0);
+    });
+}
+async function collectFiles(dir) {
+    const files = [];
+    const ignorePatterns = await getGitIgnorePatterns(dir);
+    async function walk(currentPath) {
+        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            const relativePath = path.relative(dir, fullPath);
+            if (shouldIgnoreFile(relativePath, ignorePatterns)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                files.push(fullPath);
+            }
+        }
+    }
+    await walk(dir);
+    return files;
+}
+main().catch((error) => {
+    console.error(chalk.gray('\n✗ Fatal error:'), error.message);
+    process.exit(1);
+});

package/dist/utils/config.d.ts

@@ -0,0 +1,10 @@
+interface Config {
+    email: string;
+    token: string;
+    apiKey: string;
+    expiryTime?: number;
+}
+export declare function getConfig(): Promise<Config | null>;
+export declare function saveConfig(config: Config): Promise<void>;
+export declare function clearConfig(): Promise<void>;
+export {};

package/dist/utils/config.js

@@ -0,0 +1,49 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+const CONFIG_DIR = path.join(os.homedir(), '.optiq');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'session.json');
+export async function getConfig() {
+    try {
+        const data = await fs.readFile(CONFIG_FILE, 'utf-8');
+        const config = JSON.parse(data);
+        // Check if token is expired
+        if (config.expiryTime && Date.now() > config.expiryTime) {
+            await clearConfig();
+            return null;
+        }
+        return {
+            email: config.email,
+            token: config.token,
+            apiKey: config.contextEngineApiKey || config.apiKey,
+        };
+    }
+    catch (error) {
+        return null;
+    }
+}
+export async function saveConfig(config) {
+    try {
+        await fs.mkdir(CONFIG_DIR, { recursive: true });
+        // Calculate expiry time (30 days from now)
+        const expiryTime = Date.now() + (30 * 24 * 60 * 60 * 1000);
+        const sessionData = {
+            token: config.token,
+            email: config.email,
+            expiryTime,
+            contextEngineApiKey: config.apiKey,
+        };
+        await fs.writeFile(CONFIG_FILE, JSON.stringify(sessionData, null, 2), 'utf-8');
+    }
+    catch (error) {
+        throw new Error('Failed to save config');
+    }
+}
+export async function clearConfig() {
+    try {
+        await fs.unlink(CONFIG_FILE);
+    }
+    catch (error) {
+        // Ignore if file doesn't exist
+    }
+}

package/dist/utils/files.d.ts

@@ -0,0 +1,7 @@
+export declare function isValidDirectory(dirPath: string): Promise<{
+    valid: boolean;
+    error?: string;
+    fileCount?: number;
+}>;
+export declare function getGitIgnorePatterns(dir: string): Promise<string[]>;
+export declare function shouldIgnoreFile(relativePath: string, patterns: string[]): boolean;

package/dist/utils/files.js

@@ -0,0 +1,103 @@
+import fs from 'fs/promises';
+import path from 'path';
+const DEFAULT_IGNORE_PATTERNS = [
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'target',
+    '.next',
+    '.nuxt',
+    'coverage',
+    '.cache',
+    '.vscode',
+    '.idea',
+    '*.log',
+    '.DS_Store',
+    'Thumbs.db',
+];
+export async function isValidDirectory(dirPath) {
+    try {
+        const stat = await fs.stat(dirPath);
+        if (!stat.isDirectory()) {
+            return { valid: false, error: 'Path is not a directory' };
+        }
+        // Count files
+        const fileCount = await countFiles(dirPath);
+        if (fileCount === 0) {
+            return { valid: false, error: 'Directory is empty' };
+        }
+        if (fileCount > 50000) {
+            return { valid: false, error: 'Directory has too many files (max: 50,000)' };
+        }
+        return { valid: true, fileCount };
+    }
+    catch (error) {
+        return { valid: false, error: 'Directory does not exist or is not accessible' };
+    }
+}
+async function countFiles(dir) {
+    let count = 0;
+    const ignorePatterns = await getGitIgnorePatterns(dir);
+    async function walk(currentPath) {
+        if (count > 50000)
+            return; // Stop counting if too many
+        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            const relativePath = path.relative(dir, fullPath);
+            if (shouldIgnoreFile(relativePath, ignorePatterns)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                count++;
+            }
+        }
+    }
+    try {
+        await walk(dir);
+    }
+    catch (error) {
+        // Ignore errors during counting
+    }
+    return count;
+}
+export async function getGitIgnorePatterns(dir) {
+    const patterns = [...DEFAULT_IGNORE_PATTERNS];
+    try {
+        const gitignorePath = path.join(dir, '.gitignore');
+        const content = await fs.readFile(gitignorePath, 'utf-8');
+        const lines = content.split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#'));
+        patterns.push(...lines);
+    }
+    catch (error) {
+        // No .gitignore file, use defaults
+    }
+    return patterns;
+}
+export function shouldIgnoreFile(relativePath, patterns) {
+    const parts = relativePath.split(path.sep);
+    for (const pattern of patterns) {
+        // Exact match
+        if (parts.includes(pattern)) {
+            return true;
+        }
+        // Wildcard match
+        if (pattern.includes('*')) {
+            const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+            if (regex.test(relativePath)) {
+                return true;
+            }
+        }
+        // Extension match
+        if (pattern.startsWith('*.') && relativePath.endsWith(pattern.slice(1))) {
+            return true;
+        }
+    }
+    return false;
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@optiqcode/cli",
+  "version": "1.0.0",
+  "description": "CLI tool for Optiq - automatic code indexing and context engine",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "optiq": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "optiq",
+    "code-indexing",
+    "context-engine",
+    "cli",
+    "developer-tools"
+  ],
+  "author": "optiqcode",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/optiqcode/optiq"
+  },
+  "homepage": "https://github.com/optiqcode/optiq#readme",
+  "bugs": {
+    "url": "https://github.com/optiqcode/optiq/issues"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "chalk": "^5.3.0",
+    "chokidar": "^3.5.3",
+    "log-update": "^7.0.1",
+    "ora": "^8.0.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.3.0"
+  }
+}