@rahul05ranjan/dhruv-cli 1.4.6 → 1.6.0

package/dist/core/command-runner.js

@@ -15,23 +15,46 @@ import { metricsCollector } from '../core/metrics.js';
 import { securityManager } from '../core/security.js';
 /** Maps typed AI errors to user-facing hints — once, not per command. */
 function describeAIError(error, model) {
-    switch (error.kind) {
+    if (!error || typeof error !== 'object' || !('kind' in error)) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (/econnrefused|failed to connect|fetch failed/i.test(msg)) {
+            return `💡 Make sure Ollama is running: ollama serve`;
+        }
+        if (/model.*not found/i.test(msg)) {
+            return `💡 Install the model: ollama pull ${model}`;
+        }
+        return msg;
+    }
+    const typedError = error;
+    switch (typedError.kind) {
         case 'connection':
             return `💡 Make sure Ollama is running: ollama serve`;
         case 'model-not-found':
-            return `💡 Install the model: ollama pull ${error.model || model}`;
+            return `💡 Install the model: ollama pull ${typedError.model || model}`;
         case 'empty-response':
-            return `💡 Model returned nothing. Install it: ollama pull ${error.model || model}`;
+            return `💡 Model returned nothing. Install it: ollama pull ${typedError.model || model}`;
+        case 'timeout':
+            return `💡 The request timed out after ${typedError.timeoutMs}ms. Try again, use a smaller prompt, or increase --timeout.`;
+        case 'cancelled':
+            return '💡 Request cancelled. Run the command again when ready.';
         default:
-            return error.cause;
+            return typedError.cause;
     }
 }
 export async function runCommand(spec) {
     const startTime = Date.now();
     const { name, input } = spec;
     const config = loadConfig();
+    const jsonOutput = config.responseFormat === 'json';
+    const writeJson = (result) => {
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+    };
     const fail = (error) => {
-        printError(error);
+        process.exitCode = 2;
+        if (jsonOutput)
+            writeJson({ ok: false, command: name, error, model: config.model, durationMs: Date.now() - startTime });
+        else
+            printError(error);
         logCommand(name, startTime, false, { error });
         metricsCollector.recordCommand(name, Date.now() - startTime, false);
     };
@@ -46,30 +69,92 @@ export async function runCommand(spec) {
         fail('Rate limit exceeded. Please try again later.');
         return;
     }
-    const spinner = ora('Thinking...').start();
+    const spinner = jsonOutput ? undefined : ora('Thinking...').start();
+    let requestTimeout;
+    let sigintHandler;
     try {
-        spinner.stop();
-        console.log(chalk.yellowBright('🤖 Dhruv CLI: AI-powered developer assistant'));
-        console.log(chalk.green.bold(spec.header));
-        console.log();
-        const response = await ask(spec.buildRequest(input, config.model));
-        console.log('\n');
-        if (spec.footer) {
-            console.log(chalk.dim(spec.footer));
+        spinner?.stop();
+        if (!jsonOutput) {
+            console.log(chalk.yellowBright('🤖 Dhruv CLI: AI-powered developer assistant'));
+            console.log(chalk.green.bold(spec.header));
+            console.log();
+        }
+        let streamed = false;
+        const controller = new AbortController();
+        const request = {
+            ...spec.buildRequest(input, config.model),
+            signal: controller.signal,
+            onToken: (token) => {
+                streamed = true;
+                if (!jsonOutput)
+                    process.stdout.write(token);
+            },
+        };
+        const aiStartTime = Date.now();
+        const responsePromise = ask(request);
+        const cancellationPromise = new Promise((_, reject) => {
+            sigintHandler = () => {
+                controller.abort();
+                reject({ kind: 'cancelled' });
+            };
+            process.once('SIGINT', sigintHandler);
+        });
+        const response = config.timeoutMs > 0
+            ? await Promise.race([
+                responsePromise,
+                cancellationPromise,
+                new Promise((_, reject) => {
+                    requestTimeout = setTimeout(() => {
+                        controller.abort();
+                        reject({ kind: 'timeout', timeoutMs: config.timeoutMs });
+                    }, config.timeoutMs);
+                }),
+            ])
+            : await Promise.race([responsePromise, cancellationPromise]);
+        if (requestTimeout)
+            clearTimeout(requestTimeout);
+        if (sigintHandler)
+            process.removeListener('SIGINT', sigintHandler);
+        if (!response.trim()) {
+            throw { kind: 'empty-response', model: config.model };
+        }
+        const durationMs = Date.now() - startTime;
+        if (jsonOutput) {
+            writeJson({ ok: true, command: name, model: config.model, response, durationMs });
+        }
+        else {
+            if (!streamed)
+                process.stdout.write(response);
+            process.stdout.write('\n');
+            if (spec.footer)
+                console.log(chalk.dim(spec.footer));
         }
         if (spec.onComplete)
             spec.onComplete(response, input);
-        const duration = Date.now() - startTime;
+        metricsCollector.recordAIRequest(config.model, name, Date.now() - aiStartTime, true);
         logCommand(name, startTime, true, { model: config.model });
-        logPerformance(name, duration);
-        metricsCollector.recordCommand(name, duration, true);
-        logger.info(`${name} command completed successfully`, { duration });
+        logPerformance(name, durationMs);
+        metricsCollector.recordCommand(name, durationMs, true);
+        logger.info(`${name} command completed successfully`, { duration: durationMs });
     }
     catch (err) {
-        spinner.stop();
+        spinner?.stop();
+        if (requestTimeout)
+            clearTimeout(requestTimeout);
+        if (sigintHandler)
+            process.removeListener('SIGINT', sigintHandler);
+        const cancelled = typeof err === 'object' && err !== null && 'kind' in err && err.kind === 'cancelled';
+        process.exitCode = cancelled ? 130 : 1;
         const duration = Date.now() - startTime;
-        printError(`Command failed.`);
-        console.log(chalk.yellow(describeAIError(err, config.model)));
+        const hint = describeAIError(err, config.model);
+        metricsCollector.recordAIRequest(config.model, name, duration, false);
+        if (jsonOutput) {
+            writeJson({ ok: false, command: name, model: config.model, error: 'Command failed.', hint, durationMs: duration });
+        }
+        else {
+            printError(`Command failed.`);
+            console.log(chalk.yellow(hint));
+        }
         logError(`${name} command failed`, err, { command: name });
         logCommand(name, startTime, false, { error: err.message });
         metricsCollector.recordCommand(name, duration, false);

package/dist/core/logger.js

@@ -31,6 +31,7 @@ class Logger {
             // Console transport for development
             new winston.transports.Console({
                 level: config.verbose ? 'debug' : 'info',
+                stderrLevels: ['error', 'warn', 'info', 'debug'],
                 format: winston.format.combine(winston.format.colorize(), winston.format.simple(), winston.format.printf(({ timestamp, level, message }) => {
                     return `${timestamp} ${level}: ${message}`;
                 }))

package/dist/core/metrics.d.ts

@@ -1,4 +1,27 @@
 import promClient from 'prom-client';
+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;
+}
 export declare const metrics: {
     commandDuration: promClient.Histogram<"success" | "command">;
     commandCount: promClient.Counter<"success" | "command">;
@@ -27,6 +50,11 @@ export declare class MetricsCollector {
     updateMemoryUsage(): void;
     recordSession(): void;
     recordPluginLoaded(): void;
+    getSummary(): MetricsSummary;
+    resetPersistent(): void;
+    private persistentPath;
+    private readPersistent;
+    private updatePersistent;
     getMetrics(): Promise<string>;
     getMetricsJSON(): Promise<promClient.MetricObjectWithValues<promClient.MetricValue<string>>[]>;
     getRegistry(): promClient.Registry;

package/dist/core/metrics.js

@@ -1,5 +1,10 @@
 import promClient from 'prom-client';
 import { logger } from './logger.js';
+import fs from 'node:fs';
+import path from 'node:path';
+function emptySummary() {
+    return { sessions: 0, commands: {}, errors: {}, models: {}, cache: { hits: 0, misses: 0 } };
+}
 // Create a Registry which registers the metrics
 const register = new promClient.Registry();
 // Add a default label which is added to all metrics
@@ -100,6 +105,16 @@ 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);
@@ -114,6 +129,16 @@ 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);
@@ -124,6 +149,9 @@ export class MetricsCollector {
             return;
         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);
@@ -134,6 +162,9 @@ export class MetricsCollector {
             return;
         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);
@@ -154,6 +185,10 @@ export class MetricsCollector {
             return;
         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);
@@ -178,6 +213,9 @@ export class MetricsCollector {
             return;
         try {
             metrics.sessionCount.inc();
+            this.updatePersistent((summary) => {
+                summary.sessions += 1;
+            });
         }
         catch (error) {
             logger.error('Failed to record session metrics', error);
@@ -193,6 +231,47 @@ export class MetricsCollector {
             logger.error('Failed to record plugin loaded metrics', error);
         }
     }
+    getSummary() {
+        return this.readPersistent();
+    }
+    resetPersistent() {
+        try {
+            fs.unlinkSync(this.persistentPath());
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.debug('Failed to unlink persistent metrics', { error: error.message });
+            }
+        }
+    }
+    persistentPath() {
+        return path.join(process.cwd(), '.dhruv-metrics.json');
+    }
+    readPersistent() {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.persistentPath(), 'utf8'));
+            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();
+        }
+    }
+    updatePersistent(update) {
+        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.message });
+        }
+    }
     async getMetrics() {
         return register.metrics();
     }

package/dist/index.js

@@ -19,6 +19,7 @@ import { menu } from './commands/menu.js';
 import { createRequire } from 'module';
 import { logger, logInfo, logError } from './core/logger.js';
 import { metricsCollector } from './core/metrics.js';
+import { commandDescription, completionCommands, completionOptions } from './core/command-catalog.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 const program = new Command();
@@ -28,69 +29,78 @@ program
     .version(pkg.version);
 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, options) => 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, options) => 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, target, options) => 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) => 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) => 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}`));
 });
 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 = {};
         if (opts.model)
             config.model = opts.model;
@@ -98,6 +108,8 @@ program
             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);
@@ -148,23 +160,85 @@ async function loadPlugins(program) {
 // 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) => {
+    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/dist/utils/projectType.d.ts

@@ -1 +1,7 @@
-export declare function detectProjectType(): string;
+export interface ProjectContext {
+    type: string;
+    framework?: string;
+    diagnostic?: string;
+}
+export declare function detectProjectDetails(directory?: string): ProjectContext;
+export declare function detectProjectType(directory?: string): string;

package/dist/utils/projectType.js

@@ -1,17 +1,95 @@
 // 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';
+import path from 'path';
+import { logger } from '../core/logger.js';
+export function detectProjectDetails(directory = process.cwd()) {
+    const file = (name) => path.join(directory, name);
+    if (fs.existsSync(file('package.json'))) {
+        let pkg;
+        try {
+            pkg = JSON.parse(fs.readFileSync(file('package.json'), 'utf-8'));
+        }
+        catch (err) {
+            const diagnostic = `Malformed package.json in ${directory}: ${err.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('requirements.txt'))
-        return 'python';
-    if (fs.existsSync('pyproject.toml'))
-        return 'python';
-    return 'unknown';
+    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;
+        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.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;
+        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 = process.cwd()) {
+    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}`;
+    }
+    return details.type;
 }