@rahul05ranjan/dhruv-cli 1.4.6 → 1.6.0

package/src/core/metrics.ts

@@ -1,5 +1,38 @@
 import promClient from 'prom-client';
 import { logger } from './logger.js';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export interface CommandSummary {
+  runs: number;
+  successes: number;
+  failures: number;
+  durationMs: number;
+}
+
+export interface ModelSummary {
+  requests: number;
+  successes: number;
+  failures: number;
+  durationMs: number;
+}
+
+export interface CacheSummary {
+  hits: number;
+  misses: number;
+}
+
+export interface MetricsSummary {
+  sessions: number;
+  commands: Record<string, CommandSummary>;
+  errors: Record<string, number>;
+  models: Record<string, ModelSummary>;
+  cache: CacheSummary;
+}
+
+function emptySummary(): MetricsSummary {
+  return { sessions: 0, commands: {}, errors: {}, models: {}, cache: { hits: 0, misses: 0 } };
+}
 
 // Create a Registry which registers the metrics
 const register = new promClient.Registry();
@@ -122,6 +155,14 @@ export class MetricsCollector {
     try {
       metrics.commandDuration.observe({ command, success: success.toString() }, duration / 1000);
       metrics.commandCount.inc({ command, success: success.toString() });
+      this.updatePersistent((summary) => {
+        const current = summary.commands[command] ?? { runs: 0, successes: 0, failures: 0, durationMs: 0 };
+        current.runs += 1;
+        if (success) current.successes += 1;
+        else current.failures += 1;
+        current.durationMs += duration;
+        summary.commands[command] = current;
+      });
     } catch (error) {
       logger.error('Failed to record command metrics', error as Error);
     }
@@ -137,6 +178,14 @@ export class MetricsCollector {
       if (tokensUsed) {
         metrics.aiTokensUsed.inc({ model, command_type: commandType }, tokensUsed);
       }
+      this.updatePersistent((summary) => {
+        const current = summary.models[model] ?? { requests: 0, successes: 0, failures: 0, durationMs: 0 };
+        current.requests += 1;
+        if (success) current.successes += 1;
+        else current.failures += 1;
+        current.durationMs += duration;
+        summary.models[model] = current;
+      });
     } catch (error) {
       logger.error('Failed to record AI request metrics', error as Error);
     }
@@ -147,6 +196,9 @@ export class MetricsCollector {
 
     try {
       metrics.cacheHitCount.inc({ cache_type: cacheType });
+      this.updatePersistent((summary) => {
+        summary.cache.hits += 1;
+      });
     } catch (error) {
       logger.error('Failed to record cache hit metrics', error as Error);
     }
@@ -157,6 +209,9 @@ export class MetricsCollector {
 
     try {
       metrics.cacheMissCount.inc({ cache_type: cacheType });
+      this.updatePersistent((summary) => {
+        summary.cache.misses += 1;
+      });
     } catch (error) {
       logger.error('Failed to record cache miss metrics', error as Error);
     }
@@ -177,6 +232,10 @@ export class MetricsCollector {
 
     try {
       metrics.errorCount.inc({ error_type: errorType, command: command || 'unknown' });
+      this.updatePersistent((summary) => {
+        const key = command ? `${errorType}:${command}` : errorType;
+        summary.errors[key] = (summary.errors[key] ?? 0) + 1;
+      });
     } catch (error) {
       logger.error('Failed to record error metrics', error as Error);
     }
@@ -201,6 +260,9 @@ export class MetricsCollector {
 
     try {
       metrics.sessionCount.inc();
+      this.updatePersistent((summary) => {
+        summary.sessions += 1;
+      });
     } catch (error) {
       logger.error('Failed to record session metrics', error as Error);
     }
@@ -216,6 +278,49 @@ export class MetricsCollector {
     }
   }
 
+  public getSummary(): MetricsSummary {
+    return this.readPersistent();
+  }
+
+  public resetPersistent(): void {
+    try {
+      fs.unlinkSync(this.persistentPath());
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        logger.debug('Failed to unlink persistent metrics', { error: (error as Error).message });
+      }
+    }
+  }
+
+  private persistentPath(): string {
+    return path.join(process.cwd(), '.dhruv-metrics.json');
+  }
+
+  private readPersistent(): MetricsSummary {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(this.persistentPath(), 'utf8')) as Partial<MetricsSummary>;
+      return {
+        sessions: typeof parsed.sessions === 'number' ? parsed.sessions : 0,
+        commands: parsed.commands ?? {},
+        errors: parsed.errors ?? {},
+        models: parsed.models ?? {},
+        cache: parsed.cache ?? { hits: 0, misses: 0 },
+      };
+    } catch {
+      return emptySummary();
+    }
+  }
+
+  private updatePersistent(update: (summary: MetricsSummary) => void): void {
+    try {
+      const summary = this.readPersistent();
+      update(summary);
+      fs.writeFileSync(this.persistentPath(), JSON.stringify(summary, null, 2));
+    } catch (error) {
+      logger.debug('Failed to persist metrics', { error: (error as Error).message });
+    }
+  }
+
   public async getMetrics(): Promise<string> {
     return register.metrics();
   }

package/src/index.ts

@@ -20,6 +20,7 @@ import { createRequire } from 'module';
 import { logger, logCommand, logInfo, logError } from './core/logger.js';
 import { metricsCollector } from './core/metrics.js';
 import { securityManager } from './core/security.js';
+import { commandDescription, completionCommands, completionOptions } from './core/command-catalog.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 
@@ -32,65 +33,73 @@ program
 
 program
   .command('explain <query>')
-  .description('Explain a concept or command')
+  .description(commandDescription('explain'))
   .addHelpText('after', '\nExamples:\n  $ dhruv explain "What is async/await?"\n  $ dhruv explain "Docker containers vs VMs"')
   .action(explain);
 
 program
   .command('suggest <query>')
-  .description('Get AI-powered suggestions')
+  .description(commandDescription('suggest'))
   .addHelpText('after', '\nExamples:\n  $ dhruv suggest "React performance optimization"\n  $ dhruv suggest "Node.js project structure"')
   .action(suggest);
 
 program
   .command('fix <query>')
-  .description('Get a fix for a coding issue or error')
+  .description(commandDescription('fix'))
   .addHelpText('after', '\nExamples:\n  $ dhruv fix "TypeError: Cannot read property of undefined"\n  $ dhruv fix "CORS error in Express.js"')
   .action(fix);
 
 program
   .command('review <fileOrDir>')
-  .description('Review code in a file or directory')
-  .action(review);
+  .description(commandDescription('review'))
+  .option('--diff', 'Review the current uncommitted git diff')
+  .action((fileOrDir: string, options: Record<string, any>) => review(fileOrDir, options));
 
 program
   .command('optimize <file>')
-  .description('Optimize a file (e.g., package.json)')
+  .description(commandDescription('optimize'))
   .action(optimize);
 
 program
   .command('security-check [fileOrDir]')
-  .description('Run a security check on code')
-  .action(securityCheck);
+  .description(commandDescription('security-check'))
+  .option('--strict', 'Exit with failure when high-confidence findings are detected')
+  .action((fileOrDir: string | undefined, options: Record<string, any>) => securityCheck(fileOrDir, options));
 
 program
   .command('generate <type> <target>')
-  .description('Generate code/tests for a file')
-  .action(generate);
+  .description(commandDescription('generate'))
+  .option('--apply', 'Write generated tests to disk (preview is the default)')
+  .option('--output <path>', 'Write generated tests to this path')
+  .option('--overwrite', 'Allow replacing an existing output file')
+  .action((type: string, target: string, options: Record<string, any>) => generate(type, target, options));
 
 program
   .command('init')
-  .description('Interactive setup/configuration wizard')
+  .description(commandDescription('init'))
   .action(init);
 
 program
   .command('status')
-  .description('Check Ollama connection and available models')
+  .description(commandDescription('status'))
   .action(status);
 
 program
   .command('health')
-  .description('Run comprehensive health check')
-  .action(health);
+  .description(commandDescription('health'))
+  .option('--details', 'Show every health check and diagnostic detail')
+  .action((options: Record<string, any>) => health(options));
 
 program
   .command('metrics')
-  .description('Display CLI usage metrics')
-  .action(metrics);
+  .description(commandDescription('metrics'))
+  .option('--raw', 'Export raw Prometheus metrics')
+  .option('--reset', 'Clear persisted local metrics')
+  .action((options: Record<string, any>) => metrics(options));
 
 program
   .command('project-type')
-  .description('Detect and print the current project type')
+  .description(commandDescription('project-type'))
   .action(() => {
     const type = detectProjectType();
     console.log(chalk.blue(`Detected project type: ${type}`));
@@ -98,20 +107,22 @@ program
 
 program
   .command('menu')
-  .description('Interactive command palette')
+  .description(commandDescription('menu'))
   .action(menu);
 
 program
   .option('--model <model>', 'Set Ollama model')
   .option('--verbose', 'Enable verbose output')
   .option('--json', 'Output in JSON format')
+  .option('--timeout <milliseconds>', 'Set the AI request timeout')
   .hook('preAction', async (thisCommand) => {
     const opts = thisCommand.opts();
-    if (opts.model || opts.verbose || opts.json) {
+    if (opts.model || opts.verbose || opts.json || opts.timeout) {
       const config: Record<string, unknown> = {};
       if (opts.model) config.model = opts.model;
       if (opts.verbose) config.verbose = true;
       if (opts.json) config.responseFormat = 'json';
+      if (opts.timeout) config.timeoutMs = Number(opts.timeout);
       // Save config for session
       const configModule = await import('./config/config.js');
       configModule.saveConfig(config);
@@ -165,23 +176,85 @@ async function loadPlugins(program: unknown) {
 // Autocomplete: Generate shell completion scripts
 program
   .command('completion')
-  .description('Generate shell completion script')
+  .description(commandDescription('completion'))
   .argument('[shell]', 'shell type (bash|zsh|fish)', 'bash')
   .action((shell: string) => {
+    const commands = completionCommands();
+    const options = completionOptions();
     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`;
+        script = `#compdef dhruv
+_dhruv_completion() {
+  local -a commands
+  commands=(${commands})
+  _arguments -C \\
+    '1:command:->cmds' \\
+    '*::options:->args'
+  case "$state" in
+    cmds)
+      _describe -t commands 'dhruv command' commands
+      ;;
+    args)
+      case $words[1] in
+        generate)
+          _arguments '1:type:(tests documentation docs component)' '*:file:_files'
+          ;;
+        review|optimize|security-check)
+          _arguments '*:file:_files'
+          ;;
+        completion)
+          _arguments '1:shell:(bash zsh fish)'
+          ;;
+        *)
+          _arguments '*:options:(${options})'
+          ;;
+      esac
+      ;;
+  esac
+}
+compdef _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)'`;
+        script = `complete -c dhruv -f -n '__fish_use_subcommand' -a '${commands}'\ncomplete -c dhruv -f -n '__fish_seen_subcommand_from generate' -a 'tests documentation docs component'\ncomplete -c dhruv -f -n '__fish_seen_subcommand_from completion' -a 'bash zsh fish'\ncomplete -c dhruv -f -n 'not __fish_use_subcommand' -a '${options}'`;
         break;
-      default:
+      case 'bash':
         script = String.raw`#!/bin/bash
 _dhruv_completion() {
-  COMPREPLY=( $(compgen -W "$(dhruv --help | awk '/Commands:/,/^$/ {if(NR>1)print $1}')" -- \${COMP_WORDS[1]}) )
+  local cur prev commands options
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="${commands}"
+  options="${options}"
+
+  if [[ "$prev" == "generate" ]]; then
+    COMPREPLY=( $(compgen -W "tests documentation docs component" -- "$cur") )
+    return 0
+  fi
+  if [[ "$prev" == "completion" ]]; then
+    COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") )
+    return 0
+  fi
+  if [[ "$prev" == "review" || "$prev" == "optimize" || "$prev" == "security-check" ]]; then
+    COMPREPLY=( $(compgen -f -- "$cur") )
+    return 0
+  fi
+
+  if [[ "$cur" == -* ]]; then
+    COMPREPLY=( $(compgen -W "$options" -- "$cur") )
+  elif [[ $COMP_CWORD -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+  else
+    COMPREPLY=( $(compgen -W "$commands $options" -- "$cur") )
+  fi
 }
 complete -F _dhruv_completion dhruv`;
+        break;
+      default:
+        console.error(chalk.red(`Unsupported shell "${shell}". Choose bash, zsh, or fish.`));
+        process.exitCode = 2;
+        return;
     }
     console.log(script);
     console.log(`\n# To enable tab completion, add the above to your shell profile or source it directly.`);

package/src/utils/projectType.ts

@@ -1,14 +1,90 @@
 // Use .js extension for ESM compatibility
 import fs from 'fs';
+import path from 'path';
+import { logger } from '../core/logger.js';
 
-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';
+export interface ProjectContext {
+  type: string;
+  framework?: string;
+  diagnostic?: string;
+}
+
+export function detectProjectDetails(directory: string = process.cwd()): ProjectContext {
+  const file = (name: string) => path.join(directory, name);
+
+  if (fs.existsSync(file('package.json'))) {
+    let pkg: { dependencies?: Record<string, string>; devDependencies?: Record<string, string> };
+    try {
+      pkg = JSON.parse(fs.readFileSync(file('package.json'), 'utf-8'));
+    } catch (err) {
+      const diagnostic = `Malformed package.json in ${directory}: ${(err as Error).message}`;
+      logger.warn(diagnostic);
+      return { type: 'unknown', diagnostic };
+    }
+
+    const dependencies = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (dependencies.react) return { type: 'node', framework: 'react' };
+    if (dependencies.next) return { type: 'node', framework: 'nextjs' };
+    if (dependencies.vue) return { type: 'node', framework: 'vue' };
+    if (dependencies['@angular/core']) return { type: 'node', framework: 'angular' };
+    if (dependencies.svelte) return { type: 'node', framework: 'svelte' };
+    if (dependencies['@nestjs/core']) return { type: 'node', framework: 'nestjs' };
+    if (dependencies.express) return { type: 'node', framework: 'node-express' };
+    if (dependencies.typescript || fs.existsSync(file('tsconfig.json'))) return { type: 'node-typescript' };
+    return { type: 'node' };
+  }
+
+  if (fs.existsSync(file('tsconfig.json'))) {
+    return { type: 'node-typescript' };
+  }
+
+  if (fs.existsSync(file('requirements.txt')) || fs.existsSync(file('pyproject.toml')) || fs.existsSync(file('Pipfile')) || fs.existsSync(file('setup.py'))) {
+    let framework: string | undefined;
+    if (fs.existsSync(file('manage.py'))) {
+      framework = 'django';
+    } else if (fs.existsSync(file('requirements.txt'))) {
+      try {
+        const reqs = fs.readFileSync(file('requirements.txt'), 'utf-8');
+        if (/fastapi/i.test(reqs)) framework = 'fastapi';
+        else if (/flask/i.test(reqs)) framework = 'flask';
+        else if (/django/i.test(reqs)) framework = 'django';
+      } catch (err) {
+        const diagnostic = `Error reading requirements.txt: ${(err as Error).message}`;
+        logger.warn(diagnostic);
+        return { type: 'python', diagnostic };
+      }
+    }
+    return { type: 'python', framework };
+  }
+
+  if (fs.existsSync(file('go.mod'))) return { type: 'go' };
+  if (fs.existsSync(file('Cargo.toml'))) return { type: 'rust' };
+  if (fs.existsSync(file('pom.xml')) || fs.existsSync(file('build.gradle')) || fs.existsSync(file('build.gradle.kts'))) {
+    let framework: string | undefined;
+    try {
+      const pomPath = file('pom.xml');
+      const gradlePath = file('build.gradle');
+      const content = fs.existsSync(pomPath)
+        ? fs.readFileSync(pomPath, 'utf-8')
+        : (fs.existsSync(gradlePath) ? fs.readFileSync(gradlePath, 'utf-8') : '');
+      if (/spring-boot/i.test(content)) framework = 'spring-boot';
+    } catch {
+      // safe fallback
+    }
+    return { type: 'java', framework };
+  }
+
+  return { type: 'unknown' };
+}
+
+export function detectProjectType(directory: string = process.cwd()): string {
+  const details = detectProjectDetails(directory);
+  if (details.type === 'unknown') return 'unknown';
+  if (details.framework) {
+    if (details.framework === 'react' || details.framework === 'nextjs' || details.framework === 'node-express') {
+      return details.framework;
+    }
+    return `${details.type}-${details.framework}`;
   }
-  if (fs.existsSync('requirements.txt')) return 'python';
-  if (fs.existsSync('pyproject.toml')) return 'python';
-  return 'unknown';
+  return details.type;
 }

package/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "target": "ES2020",
     "module": "ESNext",
-    "moduleResolution": "Node",
+    "moduleResolution": "Bundler",
     "outDir": "./dist",
     "rootDir": "./src",
     "esModuleInterop": true,

package/.github/workflows/auto-assign.yml

@@ -1,14 +0,0 @@
-name: Auto Assign
-
-on:
-  pull_request:
-    types: [opened, reopened]
-
-jobs:
-  add-assignees:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: kentaro-m/auto-assign-action@v1.2.4
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          configuration-path: .github/auto_assign.yml

package/.github/workflows/build-publish.yml

@@ -1,154 +0,0 @@
-name: Build & Publish
-
-on:
-  # Automatic main releases are owned by release.yml.
-  workflow_dispatch:
-    inputs:
-      version_type:
-        description: 'Version bump type'
-        required: true
-        default: 'patch'
-        type: choice
-        options:
-          - patch
-          - minor
-          - major
-          - prerelease
-
-permissions:
-  contents: write
-  packages: write
-  id-token: write
-
-jobs:
-  build-and-publish:
-    name: Build and Publish
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    environment: npm-publish
-    steps:
-      - name: Harden Runner
-        uses: step-security/harden-runner@v2
-        with:
-          egress-policy: audit
-
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '22.14.0'
-          cache: 'npm'
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install npm with trusted publishing support
-        run: npm install --global npm@11.17.0
-
-      - name: Install dependencies
-        run: npm ci --prefer-offline --no-audit
-
-      - name: Run tests
-        run: npm run test:ci
-
-      - name: Run linting
-        run: npm run lint
-
-      - name: Build project
-        run: npm run build
-
-      - name: Generate documentation
-        run: npm run docs
-
-      - name: Configure Git
-        run: |
-          git config --global user.name "GitHub Actions"
-          git config --global user.email "actions@github.com"
-
-      - name: Check if version needs update
-        id: check_version
-        run: |
-          CURRENT_VERSION=$(node -p "require('./package.json').version")
-          echo "current_version=$CURRENT_VERSION" >> $GITHUB_OUTPUT
-          
-          # Check if this version exists on NPM
-          if npm view @rahul05ranjan/dhruv-cli@$CURRENT_VERSION version 2>/dev/null; then
-            echo "needs_version_bump=true" >> $GITHUB_OUTPUT
-            echo "Version $CURRENT_VERSION already exists on NPM, needs bump"
-          else
-            echo "needs_version_bump=false" >> $GITHUB_OUTPUT
-            echo "Version $CURRENT_VERSION is new, can publish"
-          fi
-
-      - name: Manual version bump
-        if: github.event_name == 'workflow_dispatch'
-        run: |
-          npm version ${{ github.event.inputs.version_type }} --no-git-tag-version
-          git add package.json package-lock.json
-          git commit -m "chore: bump version to $(node -p "require('./package.json').version") [skip ci]"
-          git push
-
-      - name: Get final version
-        id: final_version
-        run: |
-          VERSION=$(node -p "require('./package.json').version")
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          echo "Final version to publish: $VERSION"
-
-      - name: Create Git tag
-        run: |
-          TAG="v${{ steps.final_version.outputs.version }}"
-          if git rev-parse "$TAG" >/dev/null 2>&1; then
-            echo "Tag $TAG already exists, skipping tag creation"
-          else
-            git tag "$TAG"
-            git push origin "$TAG"
-          fi
-
-      - name: Publish to NPM
-        # npm 11.5.1+ uses the workflow's OIDC identity without a stored token.
-        run: |
-          echo "Publishing version ${{ steps.final_version.outputs.version }}"
-          npm publish --access public --tag latest --provenance
-
-      - name: Create GitHub Release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: v${{ steps.final_version.outputs.version }}
-          name: Release v${{ steps.final_version.outputs.version }}
-          body: |
-            ## What's Changed
-            
-            Version ${{ steps.final_version.outputs.version }} of dhruv-cli
-            
-            ### Installation
-            ```bash
-            npm install -g @rahul05ranjan/dhruv-cli@${{ steps.final_version.outputs.version }}
-            ```
-            
-            **Full Changelog**: https://github.com/${{ github.repository }}/compare/v${{ steps.check_version.outputs.current_version }}...v${{ steps.final_version.outputs.version }}
-          files: |
-            dist/**
-            docs/api/**
-          draft: false
-          prerelease: false
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Update documentation
-        uses: peaceiris/actions-gh-pages@v4
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ./docs/api
-          publish_branch: gh-pages
-          enable_jekyll: false
-
-      - name: Notify success
-        if: success()
-        run: |
-          echo "✅ Successfully published @rahul05ranjan/dhruv-cli@${{ steps.final_version.outputs.version }}"
-          echo "📦 NPM: https://www.npmjs.com/package/@rahul05ranjan/dhruv-cli"
-          echo "📖 Documentation: https://${{ github.repository_owner }}.github.io/${{ github.event.repository.name }}"
-          echo "🏷️ Release: https://github.com/${{ github.repository }}/releases/tag/v${{ steps.final_version.outputs.version }}"