@rahul05ranjan/dhruv-cli 0.0.0-development

package/src/commands/generate.ts

@@ -0,0 +1,55 @@
+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: string, target: string) {
+  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: string) => {
+        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 as Error).message));
+  }
+}

package/src/commands/init.ts

@@ -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: any = (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()) as { models?: { name: string }[] };
+      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/src/commands/menu.ts

@@ -0,0 +1,35 @@
+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/src/commands/optimize.ts

@@ -0,0 +1,36 @@
+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: string) {
+  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: string) => {
+        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 as Error).message));
+  }
+}

package/src/commands/review.ts

@@ -0,0 +1,47 @@
+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: string) {
+  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: string) => {
+        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 as Error).message));
+  }
+}

package/src/commands/security-check.ts

@@ -0,0 +1,41 @@
+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: string = '.') {
+  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: string) => {
+        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 as Error).message));
+  }
+}

package/src/commands/suggest.ts

@@ -0,0 +1,35 @@
+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: string) {
+  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: string) => {
+        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 as Error).message));
+  }
+}

package/src/config/config.ts

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

package/src/core/ai.test.js

@@ -0,0 +1,40 @@
+/* global process */
+import { Ollama } from 'ollama';
+import path from 'path';
+import crypto from 'crypto';
+import fs from 'fs';
+
+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();
+    for await (const chunk of ollama.generate(model || 'codellama', prompt)) {
+      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 && err.message ? err.message : err));
+  }
+}

package/src/core/ai.ts

@@ -0,0 +1,41 @@
+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: string, model?: string) {
+  const hash = crypto.createHash('sha256').update(`${model || 'default'}:${prompt}`).digest('hex');
+  return path.join(CACHE_DIR, hash);
+}
+
+export async function askOllama({ prompt, model, onToken }: { prompt: string; model?: string; onToken?: (token: string) => void }) {
+  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 as { response: string }).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 as Error).message);
+  }
+}

package/src/index.ts

@@ -0,0 +1,154 @@
+#!/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: Record<string, unknown> = {};
+      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: unknown) {
+  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 as Error).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: string) => {
+    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: unknown) => {
+  const ux = await import('./utils/ux.js');
+  ux.printError('Unhandled rejection: ' + ((reason as Error)?.message || reason));
+  process.exit(1);
+});

package/src/utils/projectType.ts

@@ -0,0 +1,14 @@
+// Use .js extension for ESM compatibility
+import fs from 'fs';
+
+export function detectProjectType(): string {
+  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/src/utils/ux.ts

@@ -0,0 +1,50 @@
+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: string, lang = 'js') {
+  return highlight(code, { language: lang, ignoreIllegals: true });
+}
+
+export function printError(message: string) {
+  const { error } = getTheme();
+  console.error(error(' ERROR '), error(message));
+}
+
+export function printSuccess(message: string) {
+  const { success } = getTheme();
+  console.log(success(' SUCCESS '), success(message));
+}
+
+export function createProgressBar(total: number) {
+  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: string, type: 'primary' | 'accent' = 'primary') {
+  const theme = getTheme();
+  return theme[type](text);
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "declaration": true
+  },
+  "include": ["src/**/*", "node-fetch.d.ts"],
+  "exclude": ["node_modules", "dist"]
+}