@rahul05ranjan/dhruv-cli 0.0.0-development

package/dist/commands/generate.js

@@ -0,0 +1,62 @@
+import { askOllama } from '../core/ai.js';
+import chalk from 'chalk';
+import { loadConfig } from '../config/config.js';
+import fs from 'fs';
+import { highlightCode, printError, printSuccess } from '../utils/ux.js';
+export async function generate(type, target) {
+    const config = loadConfig();
+    let content = '';
+    if (fs.existsSync(target)) {
+        content = fs.readFileSync(target, 'utf-8');
+    }
+    let streamed = '';
+    try {
+        process.stdout.write(chalk.green('Generated code: '));
+        await askOllama({
+            prompt: `Generate only a valid JavaScript ${type} file for this code, no explanations, no Markdown, just the code.\n${content}`,
+            model: config.model,
+            onToken: (token) => {
+                streamed += token;
+                process.stdout.write(chalk.cyan(token));
+            }
+        });
+        process.stdout.write('\n');
+        // Robust code extraction for tests
+        let codeToSave = streamed;
+        if (type === 'tests' && target && typeof streamed === 'string') {
+            const codeBlockMatch = streamed.match(/```(?:[a-z]*)?\n([\s\S]*?)```/);
+            if (codeBlockMatch && codeBlockMatch[1]) {
+                codeToSave = codeBlockMatch[1].trim();
+            }
+            else {
+                // Remove Markdown, explanations, and keep only lines that look like code
+                codeToSave = streamed
+                    .replace(/```[a-z]*\n|```/g, '') // remove code block markers
+                    .split('\n')
+                    .filter(line => line.trim() && !/^\s*#|^\s*\/\//.test(line) && /[;{}()=]/.test(line))
+                    .join('\n')
+                    .trim();
+            }
+            const testFile = target.replace(/\.[^.]+$/, '.test.js');
+            fs.writeFileSync(testFile, codeToSave);
+            printSuccess(`Test file saved: ${testFile}`);
+        }
+        if (typeof highlightCode === 'function' && streamed.match(/```[a-z]*[\s\S]*?```/)) {
+            const codeBlocks = streamed.match(/```([a-z]*)\n([\s\S]*?)```/g) || [];
+            for (const block of codeBlocks) {
+                const [, lang, code] = block.match(/```([a-z]*)\n([\s\S]*?)```/) || [];
+                if (code)
+                    try {
+                        console.log(highlightCode(code, lang || 'js'));
+                    }
+                    catch (err) {
+                        console.error('Highlight error:', err);
+                    }
+            }
+        }
+    }
+    catch (err) {
+        printError('Failed to generate code.');
+        console.error(chalk.red(err.message));
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,54 @@
+import inquirer from 'inquirer';
+import { saveConfig, loadConfig } from '../config/config.js';
+import chalk from 'chalk';
+export async function init() {
+    const current = loadConfig();
+    let modelChoices = [current.model];
+    try {
+        // Dynamically import node-fetch for compatibility
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const fetch = (await import('node-fetch')).default;
+        // Fetch models from Ollama REST API
+        const res = await fetch('http://localhost:11434/api/tags');
+        if (res.ok) {
+            const data = (await res.json());
+            if (Array.isArray(data.models) && data.models.length > 0) {
+                modelChoices = data.models.map((m) => m.name);
+            }
+        }
+    }
+    catch {
+        // If Ollama is not running or fails, fallback to current model
+    }
+    const answers = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'model',
+            message: 'Which Ollama model do you want to use?',
+            choices: modelChoices,
+            default: current.model,
+        },
+        {
+            type: 'list',
+            name: 'responseFormat',
+            message: 'Preferred response format?',
+            choices: ['text', 'json', 'markdown'],
+            default: current.responseFormat,
+        },
+        {
+            type: 'confirm',
+            name: 'verbose',
+            message: 'Enable verbose output?',
+            default: current.verbose,
+        },
+        {
+            type: 'list',
+            name: 'theme',
+            message: 'Choose a color theme:',
+            choices: ['default', 'dark', 'light', 'mono'],
+            default: current.theme || 'default',
+        },
+    ]);
+    saveConfig(answers);
+    console.log(chalk.green('Configuration saved!'));
+}

package/dist/commands/menu.d.ts

@@ -0,0 +1 @@
+export declare function menu(): Promise<void>;

package/dist/commands/menu.js

@@ -0,0 +1,33 @@
+import inquirer from 'inquirer';
+import { themed } from '../utils/ux.js';
+const commands = [
+    { name: 'Explain', value: 'explain' },
+    { name: 'Suggest', value: 'suggest' },
+    { name: 'Fix', value: 'fix' },
+    { name: 'Review', value: 'review' },
+    { name: 'Optimize', value: 'optimize' },
+    { name: 'Security Check', value: 'security-check' },
+    { name: 'Generate', value: 'generate' },
+    { name: 'Init (Setup)', value: 'init' },
+    { name: 'Project Type', value: 'project-type' },
+    { name: 'Exit', value: 'exit' }
+];
+export async function menu() {
+    let running = true;
+    while (running) {
+        const { cmd } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'cmd',
+                message: themed('What do you want to do?', 'primary'),
+                choices: commands
+            }
+        ]);
+        if (cmd === 'exit') {
+            running = false;
+            break;
+        }
+        // For demo, just print the command. In real use, you would call the command handler.
+        console.log(themed(`You selected: ${cmd}`, 'accent'));
+    }
+}

package/dist/commands/optimize.d.ts

@@ -0,0 +1 @@
+export declare function optimize(file: string): Promise<void>;

package/dist/commands/optimize.js

@@ -0,0 +1,42 @@
+import { askOllama } from '../core/ai.js';
+import chalk from 'chalk';
+import { loadConfig } from '../config/config.js';
+import fs from 'fs';
+import { highlightCode, printError } from '../utils/ux.js';
+export async function optimize(file) {
+    const config = loadConfig();
+    let content = '';
+    if (fs.existsSync(file)) {
+        content = fs.readFileSync(file, 'utf-8');
+    }
+    let streamed = '';
+    try {
+        process.stdout.write(chalk.green('Optimization suggestion: '));
+        await askOllama({
+            prompt: `Optimize this file:\n${content}`,
+            model: config.model,
+            onToken: (token) => {
+                streamed += token;
+                process.stdout.write(chalk.cyan(token));
+            }
+        });
+        process.stdout.write('\n');
+        if (typeof highlightCode === 'function' && streamed.match(/```[a-z]*[\s\S]*?```/)) {
+            const codeBlocks = streamed.match(/```([a-z]*)\n([\s\S]*?)```/g) || [];
+            for (const block of codeBlocks) {
+                const [, lang, code] = block.match(/```([a-z]*)\n([\s\S]*?)```/) || [];
+                if (code)
+                    try {
+                        console.log(highlightCode(code, lang || 'js'));
+                    }
+                    catch (err) {
+                        console.error('Highlight error:', err);
+                    }
+            }
+        }
+    }
+    catch (err) {
+        printError('Failed to optimize.');
+        console.error(chalk.red(err.message));
+    }
+}

package/dist/commands/review.d.ts

@@ -0,0 +1 @@
+export declare function review(fileOrDir: string): Promise<void>;

package/dist/commands/review.js

@@ -0,0 +1,54 @@
+import { askOllama } from '../core/ai.js';
+import chalk from 'chalk';
+import { loadConfig } from '../config/config.js';
+import fs from 'fs';
+import { highlightCode, printError, createProgressBar } from '../utils/ux.js';
+export async function review(fileOrDir) {
+    const config = loadConfig();
+    let code = '';
+    if (fs.existsSync(fileOrDir)) {
+        const stat = fs.statSync(fileOrDir);
+        if (stat.isDirectory()) {
+            const files = fs.readdirSync(fileOrDir);
+            const bar = createProgressBar(files.length);
+            for (const f of files) {
+                code += fs.readFileSync(`${fileOrDir}/${f}`, 'utf-8') + '\n';
+                bar.increment();
+            }
+            bar.stop();
+        }
+        else {
+            code = fs.readFileSync(fileOrDir, 'utf-8');
+        }
+    }
+    let streamed = '';
+    try {
+        process.stdout.write(chalk.green('Review: '));
+        await askOllama({
+            prompt: `Review this code:\n${code}`,
+            model: config.model,
+            onToken: (token) => {
+                streamed += token;
+                process.stdout.write(chalk.cyan(token));
+            }
+        });
+        process.stdout.write('\n');
+        if (typeof highlightCode === 'function' && streamed.match(/```[a-z]*[\s\S]*?```/)) {
+            const codeBlocks = streamed.match(/```([a-z]*)\n([\s\S]*?)```/g) || [];
+            for (const block of codeBlocks) {
+                const [, lang, code] = block.match(/```([a-z]*)\n([\s\S]*?)```/) || [];
+                if (code)
+                    try {
+                        console.log(highlightCode(code, lang || 'js'));
+                    }
+                    catch (err) {
+                        console.error('Highlight error:', err);
+                    }
+            }
+        }
+    }
+    catch (err) {
+        printError('Failed to review code.');
+        console.error(chalk.red(err.message));
+    }
+}

package/dist/commands/security-check.d.ts

@@ -0,0 +1 @@
+export declare function securityCheck(fileOrDir?: string): Promise<void>;

package/dist/commands/security-check.js

@@ -0,0 +1,48 @@
+import { askOllama } from '../core/ai.js';
+import chalk from 'chalk';
+import { loadConfig } from '../config/config.js';
+import fs from 'fs';
+import { highlightCode, printError } from '../utils/ux.js';
+export async function securityCheck(fileOrDir = '.') {
+    const config = loadConfig();
+    let code = '';
+    if (fs.existsSync(fileOrDir)) {
+        const stat = fs.statSync(fileOrDir);
+        if (stat.isDirectory()) {
+            code = fs.readdirSync(fileOrDir).map(f => fs.readFileSync(`${fileOrDir}/${f}`, 'utf-8')).join('\n');
+        }
+        else {
+            code = fs.readFileSync(fileOrDir, 'utf-8');
+        }
+    }
+    let streamed = '';
+    try {
+        process.stdout.write(chalk.green('Security check result: '));
+        await askOllama({
+            prompt: `Security check for this code:\n${code}`,
+            model: config.model,
+            onToken: (token) => {
+                streamed += token;
+                process.stdout.write(chalk.cyan(token));
+            }
+        });
+        process.stdout.write('\n');
+        if (typeof highlightCode === 'function' && streamed.match(/```[a-z]*[\s\S]*?```/)) {
+            const codeBlocks = streamed.match(/```([a-z]*)\n([\s\S]*?)```/g) || [];
+            for (const block of codeBlocks) {
+                const [, lang, code] = block.match(/```([a-z]*)\n([\s\S]*?)```/) || [];
+                if (code)
+                    try {
+                        console.log(highlightCode(code, lang || 'js'));
+                    }
+                    catch (err) {
+                        console.error('Highlight error:', err);
+                    }
+            }
+        }
+    }
+    catch (err) {
+        printError('Failed to run security check.');
+        console.error(chalk.red(err.message));
+    }
+}

package/dist/commands/suggest.d.ts

@@ -0,0 +1 @@
+export declare function suggest(query: string): Promise<void>;

package/dist/commands/suggest.js

@@ -0,0 +1,41 @@
+import { askOllama } from '../core/ai.js';
+import ora from 'ora';
+import chalk from 'chalk';
+import { loadConfig } from '../config/config.js';
+import { highlightCode, printError } from '../utils/ux.js';
+export async function suggest(query) {
+    const config = loadConfig();
+    const spinner = ora('Generating suggestions...').start();
+    let streamed = '';
+    try {
+        spinner.stop();
+        process.stdout.write(chalk.green('Suggestions: '));
+        await askOllama({
+            prompt: `Suggest: ${query}`,
+            model: config.model,
+            onToken: (token) => {
+                streamed += token;
+                process.stdout.write(chalk.cyan(token));
+            }
+        });
+        process.stdout.write('\n');
+        if (typeof highlightCode === 'function' && streamed.match(/```[a-z]*[\s\S]*?```/)) {
+            // Highlight code blocks if present
+            const codeBlocks = streamed.match(/```([a-z]*)\n([\s\S]*?)```/g) || [];
+            for (const block of codeBlocks) {
+                const [, lang, code] = block.match(/```([a-z]*)\n([\s\S]*?)```/) || [];
+                if (code)
+                    try {
+                        console.log(highlightCode(code, lang || 'js'));
+                    }
+                    catch (err) {
+                        console.error('Highlight error:', err);
+                    }
+            }
+        }
+    }
+    catch (err) {
+        printError('Failed to get suggestions.');
+        console.error(chalk.red(err.message));
+    }
+}

package/dist/config/config.d.ts

@@ -0,0 +1,8 @@
+export interface DhruvConfig {
+    model: string;
+    verbose: boolean;
+    responseFormat: 'text' | 'json' | 'markdown';
+    theme?: 'default' | 'dark' | 'light' | 'mono';
+}
+export declare function loadConfig(): DhruvConfig;
+export declare function saveConfig(config: Partial<DhruvConfig>): void;

package/dist/config/config.js

@@ -0,0 +1,20 @@
+import fs from 'fs';
+import path from 'path';
+const CONFIG_FILE = path.join(process.cwd(), '.dhruv-config.json');
+const defaultConfig = {
+    model: 'codellama',
+    verbose: false,
+    responseFormat: 'text',
+    theme: 'default',
+};
+export function loadConfig() {
+    if (fs.existsSync(CONFIG_FILE)) {
+        return { ...defaultConfig, ...JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8')) };
+    }
+    return defaultConfig;
+}
+export function saveConfig(config) {
+    const current = loadConfig();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, ...config }, null, 2));
+}
+// Use .js extension for ESM compatibility if imported elsewhere

package/dist/core/ai.d.ts

@@ -0,0 +1,5 @@
+export declare function askOllama({ prompt, model, onToken }: {
+    prompt: string;
+    model?: string;
+    onToken?: (token: string) => void;
+}): Promise<string>;

package/dist/core/ai.js

@@ -0,0 +1,43 @@
+import { Ollama } from 'ollama';
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+const CACHE_DIR = path.join(process.cwd(), '.dhruv-cache');
+if (!fs.existsSync(CACHE_DIR))
+    fs.mkdirSync(CACHE_DIR);
+function getCacheKey(prompt, model) {
+    const hash = crypto.createHash('sha256').update(`${model || 'default'}:${prompt}`).digest('hex');
+    return path.join(CACHE_DIR, hash);
+}
+export async function askOllama({ prompt, model, onToken }) {
+    const cacheKey = getCacheKey(prompt, model);
+    if (fs.existsSync(cacheKey)) {
+        const cached = fs.readFileSync(cacheKey, 'utf-8');
+        if (onToken)
+            onToken(cached);
+        return cached;
+    }
+    try {
+        let result = '';
+        const ollama = new Ollama();
+        // Await the iterator, then stream
+        const iterator = await ollama.generate({ model: model || 'codellama', prompt, stream: true });
+        for await (const chunk of iterator) {
+            let token = '';
+            if (typeof chunk === 'object' && chunk !== null && 'response' in chunk) {
+                token = chunk.response;
+            }
+            else if (typeof chunk === 'string') {
+                token = chunk;
+            }
+            if (onToken)
+                onToken(token);
+            result += token;
+        }
+        fs.writeFileSync(cacheKey, result.trim());
+        return result.trim();
+    }
+    catch (err) {
+        throw new Error('Ollama AI error: ' + err.message);
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { explain } from './commands/explain.js';
+import { suggest } from './commands/suggest.js';
+import { fix } from './commands/fix.js';
+import { review } from './commands/review.js';
+import { optimize } from './commands/optimize.js';
+import { securityCheck } from './commands/security-check.js';
+import { generate } from './commands/generate.js';
+import { init } from './commands/init.js';
+import { detectProjectType } from './utils/projectType.js';
+import { menu } from './commands/menu.js';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+const program = new Command();
+program
+    .name('dhruv')
+    .description('AI-powered CLI assistant for developers using Ollama')
+    .version(pkg.version);
+program
+    .command('explain <query>')
+    .description('Explain a concept or command')
+    .action(explain);
+program
+    .command('suggest <query>')
+    .description('Get AI-powered suggestions')
+    .action(suggest);
+program
+    .command('fix <query>')
+    .description('Get a fix for a coding issue or error')
+    .action(fix);
+program
+    .command('review <fileOrDir>')
+    .description('Review code in a file or directory')
+    .action(review);
+program
+    .command('optimize <file>')
+    .description('Optimize a file (e.g., package.json)')
+    .action(optimize);
+program
+    .command('security-check [fileOrDir]')
+    .description('Run a security check on code')
+    .action(securityCheck);
+program
+    .command('generate <type> <target>')
+    .description('Generate code/tests for a file')
+    .action(generate);
+program
+    .command('init')
+    .description('Interactive setup/configuration wizard')
+    .action(init);
+program
+    .command('project-type')
+    .description('Detect and print the current project type')
+    .action(() => {
+    const type = detectProjectType();
+    console.log(chalk.blue(`Detected project type: ${type}`));
+});
+program
+    .command('menu')
+    .description('Interactive command palette')
+    .action(menu);
+program
+    .option('--model <model>', 'Set Ollama model')
+    .option('--verbose', 'Enable verbose output')
+    .option('--json', 'Output in JSON format')
+    .hook('preAction', async (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.model || opts.verbose || opts.json) {
+        const config = {};
+        if (opts.model)
+            config.model = opts.model;
+        if (opts.verbose)
+            config.verbose = true;
+        if (opts.json)
+            config.responseFormat = 'json';
+        // Save config for session
+        const configModule = await import('./config/config.js');
+        configModule.saveConfig(config);
+    }
+});
+async function loadPlugins(program) {
+    const PLUGIN_DIR = path.join(process.cwd(), 'plugins');
+    if (fs.existsSync(PLUGIN_DIR)) {
+        const files = fs.readdirSync(PLUGIN_DIR).filter(f => f.endsWith('.js'));
+        for (const file of files) {
+            try {
+                const pluginPath = path.join(PLUGIN_DIR, file).replace(/\\/g, '/');
+                const pluginUrl = new URL('file://' + (pluginPath.startsWith('/') ? '' : '/') + pluginPath);
+                const plugin = await import(pluginUrl.href);
+                if (typeof plugin.default === 'function')
+                    plugin.default(program);
+                else if (typeof plugin === 'function')
+                    plugin(program);
+            }
+            catch (e) {
+                console.error(chalk.red(`Failed to load plugin ${file}: ${e.message}`));
+            }
+        }
+    }
+}
+(async () => {
+    await loadPlugins(program);
+    program.parse(process.argv);
+})();
+// Autocomplete: Generate shell completion scripts
+program
+    .command('completion')
+    .description('Generate shell completion script')
+    .argument('[shell]', 'shell type (bash|zsh|fish)', 'bash')
+    .action((shell) => {
+    let script = '';
+    switch (shell) {
+        case 'zsh':
+            script = `#compdef dhruv\n_dhruv_completion() {\n  reply=( $(dhruv --help | awk '/Commands:/,/^$/ {if(NR>1)print $1}') )\n}\ncompctl -K _dhruv_completion dhruv`;
+            break;
+        case 'fish':
+            script = `function __fish_dhruv_complete\n  dhruv --help | awk '/Commands:/,/^$/ {if(NR>1)print $1}'\nend\ncomplete -c dhruv -a '(__fish_dhruv_complete)'`;
+            break;
+        default:
+            script = String.raw `#!/bin/bash
+_dhruv_completion() {
+  COMPREPLY=( $(compgen -W "$(dhruv --help | awk '/Commands:/,/^$/ {if(NR>1)print $1}')" -- \${COMP_WORDS[1]}) )
+}
+complete -F _dhruv_completion dhruv`;
+    }
+    console.log(script);
+    console.log(`\n# To enable tab completion, add the above to your shell profile or source it directly.`);
+});
+process.on('uncaughtException', async (err) => {
+    const ux = await import('./utils/ux.js');
+    ux.printError('Uncaught error: ' + err.message);
+    process.exit(1);
+});
+process.on('unhandledRejection', async (reason) => {
+    const ux = await import('./utils/ux.js');
+    ux.printError('Unhandled rejection: ' + (reason?.message || reason));
+    process.exit(1);
+});

package/dist/utils/projectType.d.ts

@@ -0,0 +1 @@
+export declare function detectProjectType(): string;

package/dist/utils/projectType.js

@@ -0,0 +1,17 @@
+// Use .js extension for ESM compatibility
+import fs from 'fs';
+export function detectProjectType() {
+    if (fs.existsSync('package.json')) {
+        const pkg = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+        if (pkg.dependencies?.react || pkg.devDependencies?.react)
+            return 'react';
+        if (pkg.dependencies?.express || pkg.devDependencies?.express)
+            return 'node-express';
+        return 'node';
+    }
+    if (fs.existsSync('requirements.txt'))
+        return 'python';
+    if (fs.existsSync('pyproject.toml'))
+        return 'python';
+    return 'unknown';
+}

package/dist/utils/ux.d.ts

@@ -0,0 +1,5 @@
+export declare function highlightCode(code: string, lang?: string): string;
+export declare function printError(message: string): void;
+export declare function printSuccess(message: string): void;
+export declare function createProgressBar(total: number): any;
+export declare function themed(text: string, type?: 'primary' | 'accent'): string;

package/dist/utils/ux.js

@@ -0,0 +1,44 @@
+import chalk from 'chalk';
+// @ts-expect-error: cli-progress has no type definitions
+import cliProgress from 'cli-progress';
+import { highlight } from 'cli-highlight';
+import { loadConfig } from '../config/config.js';
+function getTheme() {
+    const config = loadConfig();
+    switch (config.theme) {
+        case 'dark':
+            return { primary: chalk.cyanBright, accent: chalk.magentaBright, error: chalk.redBright, success: chalk.greenBright };
+        case 'light':
+            return { primary: chalk.blue, accent: chalk.yellow, error: chalk.red, success: chalk.green };
+        case 'mono':
+            return { primary: chalk.white, accent: chalk.gray, error: chalk.white.bgRed, success: chalk.white.bgGreen };
+        default:
+            return { primary: chalk.cyan, accent: chalk.green, error: chalk.bgRed.white, success: chalk.bgGreen.white };
+    }
+}
+export function highlightCode(code, lang = 'js') {
+    return highlight(code, { language: lang, ignoreIllegals: true });
+}
+export function printError(message) {
+    const { error } = getTheme();
+    console.error(error(' ERROR '), error(message));
+}
+export function printSuccess(message) {
+    const { success } = getTheme();
+    console.log(success(' SUCCESS '), success(message));
+}
+export function createProgressBar(total) {
+    const { primary } = getTheme();
+    const bar = new cliProgress.SingleBar({
+        format: primary('Progress') + ' |{bar}| {percentage}% | {value}/{total}',
+        barCompleteChar: '\u2588',
+        barIncompleteChar: '\u2591',
+        hideCursor: true
+    });
+    bar.start(total, 0);
+    return bar;
+}
+export function themed(text, type = 'primary') {
+    const theme = getTheme();
+    return theme[type](text);
+}