@rahul05ranjan/dhruv-cli 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -1,23 +1,9 @@
-# [1.4.0](https://github.com/rahul05ranjan/dhruv-cli/compare/v1.5.0...v1.4.0) (2026-09-18)
-
-
-### Bug Fixes
-
-* **test:** allow health --json contract test to inspect stdout on offline service exit code ([6231027](https://github.com/rahul05ranjan/dhruv-cli/commit/623102722d5c3ac2604dfffa276868a3b7eecdb8))
+# [1.4.0](https://github.com/rahul05ranjan/dhruv-cli/compare/v1.6.1...v1.4.0) (2026-09-21)
 
 
 ### Features
 
-* **ai:** ensure complete and streamable responses across commands (closes [#70](https://github.com/rahul05ranjan/dhruv-cli/issues/70)) ([285655e](https://github.com/rahul05ranjan/dhruv-cli/commit/285655e49eab1cbe87492cba2602a27a4bfecdfe))
-* **catalog:** unified command catalog, menu, and shell completions (closes [#79](https://github.com/rahul05ranjan/dhruv-cli/issues/79)) ([13a9c83](https://github.com/rahul05ranjan/dhruv-cli/commit/13a9c836a52933357b9ca187c787e3b9ae8f4948))
-* **cli:** standardize exit codes, timeouts, and cancellation (closes [#72](https://github.com/rahul05ranjan/dhruv-cli/issues/72)) ([d075d16](https://github.com/rahul05ranjan/dhruv-cli/commit/d075d16d1cfb3c000d156bcd238e3c261f0fc66a))
-* **cli:** standardize reliable json output contract (closes [#71](https://github.com/rahul05ranjan/dhruv-cli/issues/71)) ([e0de862](https://github.com/rahul05ranjan/dhruv-cli/commit/e0de86224b54dcf43652b5daf3f4b403d6aa7d8f))
-* **detection:** expand project detection and diagnostics (closes [#77](https://github.com/rahul05ranjan/dhruv-cli/issues/77)) ([221414a](https://github.com/rahul05ranjan/dhruv-cli/commit/221414a7c1156a650c9c746b5345b871e5274c57))
-* **diagnostics:** improve first-run model readiness and health diagnostics (closes [#78](https://github.com/rahul05ranjan/dhruv-cli/issues/78)) ([95cd3a8](https://github.com/rahul05ranjan/dhruv-cli/commit/95cd3a8d772024847a86ba53fb6391f8024ab962))
-* **generate:** previewable generation and multi-language test support (closes [#75](https://github.com/rahul05ranjan/dhruv-cli/issues/75)) ([c7f3dbe](https://github.com/rahul05ranjan/dhruv-cli/commit/c7f3dbe3902ee903220a40a4fae051b3a03797ac))
-* **metrics:** persistent invocation metrics with reset and export (closes [#76](https://github.com/rahul05ranjan/dhruv-cli/issues/76)) ([0b5c4db](https://github.com/rahul05ranjan/dhruv-cli/commit/0b5c4db69e85d10f6afeca1d26e8d9a089ce6e4c))
-* **review:** project-aware review and diff scanning (closes [#73](https://github.com/rahul05ranjan/dhruv-cli/issues/73)) ([290e4a1](https://github.com/rahul05ranjan/dhruv-cli/commit/290e4a18f21dfa9ea5a1f5fb51e2f8d98d83df53))
-* **security:** safe credential redaction and strict checks (closes [#74](https://github.com/rahul05ranjan/dhruv-cli/issues/74)) ([2467d37](https://github.com/rahul05ranjan/dhruv-cli/commit/2467d37f4404f7e16e2a10cfed860a76661d6c60))
+* **core:** source ingestion module for path validation, traversal, and diffs (closes [#99](https://github.com/rahul05ranjan/dhruv-cli/issues/99)) ([3b5761c](https://github.com/rahul05ranjan/dhruv-cli/commit/3b5761c7d2da9037ee86cbb6d890810a0b1d3e64))
 # Changelog
 
 ## [1.1.1](https://github.com/rahul05ranjan/dhruv-cli/compare/v1.1.0...v1.1.1) (2025-06-29)

package/__tests__/cli-contract.test.ts

@@ -1,7 +1,10 @@
 import { describe, expect, it } from '@jest/globals';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { resolve } from 'node:path';
+import { resolve, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { mkdtempSync, rmSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 
 const execFileAsync = promisify(execFile);
 const repoRoot = resolve(__dirname, '..');
@@ -167,4 +170,34 @@ describe('CLI output contract', () => {
     expect(parsed).toHaveProperty('ok');
     expect(parsed.command).toBe('health');
   });
+
+  it('does not persist global flags (--json, --model, --verbose, --timeout) to .dhruv-config.json', async () => {
+    const tempDir = mkdtempSync(join(tmpdir(), 'dhruv-session-flags-'));
+    const tsNodeLoader = pathToFileURL(resolve(repoRoot, 'node_modules/ts-node/esm.mjs')).href;
+    try {
+      const result = await execFileAsync(
+        process.execPath,
+        ['--loader', tsNodeLoader, resolve(repoRoot, sourceEntry), 'metrics', '--json'],
+        {
+          cwd: tempDir,
+          env: {
+            ...process.env,
+            TS_NODE_PROJECT: resolve(repoRoot, 'tsconfig.json'),
+            DHRUV_METRICS_ENABLED: 'false',
+          },
+        },
+      );
+
+      const parsed = JSON.parse(result.stdout.trim()) as Record<string, unknown>;
+      expect(parsed).toMatchObject({
+        ok: true,
+        command: 'metrics',
+      });
+
+      const localConfigFile = join(tempDir, '.dhruv-config.json');
+      expect(existsSync(localConfigFile)).toBe(false);
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
 });

package/__tests__/core.test.ts

@@ -5,7 +5,13 @@ import {
   setAIClient,
   InMemoryAIClient,
 } from '../src/core/ai';
-import { loadConfig, saveConfig } from '../src/config/config';
+import {
+  loadConfig,
+  saveConfig,
+  setSessionConfig,
+  resetSessionConfig,
+  getSessionConfig,
+} from '../src/config/config';
 import { createSpinner } from '../src/utils/ux';
 import { detectProjectType, detectProjectDetails } from '../src/utils/projectType';
 import { getSystemMessage } from '../src/core/prompts';
@@ -134,6 +140,58 @@ describe('Dhruv CLI Core Systems', () => {
         fs.unlinkSync(configPath);
       }
     });
+
+    it('should apply in-memory session overrides without writing to disk', () => {
+      resetSessionConfig();
+      const configPath = path.join(process.cwd(), '.dhruv-config.json');
+      const existedBefore = fs.existsSync(configPath);
+
+      setSessionConfig({
+        model: 'session-model',
+        responseFormat: 'json',
+        verbose: true,
+        timeoutMs: 12345,
+      });
+
+      expect(getSessionConfig()).toEqual({
+        model: 'session-model',
+        responseFormat: 'json',
+        verbose: true,
+        timeoutMs: 12345,
+      });
+
+      const loaded = loadConfig();
+      expect(loaded.model).toBe('session-model');
+      expect(loaded.responseFormat).toBe('json');
+      expect(loaded.verbose).toBe(true);
+      expect(loaded.timeoutMs).toBe(12345);
+
+      if (!existedBefore) {
+        expect(fs.existsSync(configPath)).toBe(false);
+      }
+
+      resetSessionConfig();
+      expect(getSessionConfig()).toEqual({});
+      const afterReset = loadConfig();
+      expect(afterReset.model).not.toBe('session-model');
+    });
+
+    it('should not persist session overrides when saving configuration', () => {
+      resetSessionConfig();
+      const configPath = path.join(process.cwd(), '.dhruv-config.json');
+      if (fs.existsSync(configPath)) fs.unlinkSync(configPath);
+
+      setSessionConfig({ responseFormat: 'json' });
+      saveConfig({ model: 'persistent-model' });
+
+      const fileContent = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      expect(fileContent.model).toBe('persistent-model');
+      // Must not snapshot the in-memory responseFormat into the saved file
+      expect(fileContent.responseFormat).not.toBe('json');
+
+      if (fs.existsSync(configPath)) fs.unlinkSync(configPath);
+      resetSessionConfig();
+    });
   });
 
   describe('Project Type Detection', () => {

package/__tests__/source-bundle.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it, jest, beforeEach, afterEach } from '@jest/globals';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { loadSource } from '../src/core/source-bundle';
+
+jest.mock('../src/utils/ux', () => ({
+  printError: jest.fn(),
+  printInfo: jest.fn(),
+  printSuccess: jest.fn(),
+  printWarning: jest.fn(),
+}));
+
+describe('Source Ingestion Module (loadSource)', () => {
+  let root: string;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'source-bundle-test-'));
+    process.exitCode = 0;
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+    process.exitCode = 0;
+  });
+
+  it('loads a single source file', () => {
+    const file = path.join(root, 'main.ts');
+    fs.writeFileSync(file, 'console.log("hello world");');
+
+    const bundle = loadSource(file);
+
+    expect(bundle).not.toBeNull();
+    expect(bundle?.isDiff).toBe(false);
+    expect(bundle?.capped).toBe(false);
+    expect(bundle?.files).toHaveLength(1);
+    expect(bundle?.files[0].path).toBe('main.ts');
+    expect(bundle?.files[0].content).toBe('console.log("hello world");');
+    expect(bundle?.promptContent).toBe('console.log("hello world");');
+    expect(process.exitCode).toBe(0);
+  });
+
+  it('sets process.exitCode = 1 and returns null when target does not exist', () => {
+    const nonExistent = path.join(root, 'nonexistent.ts');
+
+    const bundle = loadSource(nonExistent);
+
+    expect(bundle).toBeNull();
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('recursively loads directory files while pruning dependency and build directories', () => {
+    fs.mkdirSync(path.join(root, 'src', 'deep'), { recursive: true });
+    fs.mkdirSync(path.join(root, 'node_modules', 'lib'), { recursive: true });
+    fs.mkdirSync(path.join(root, '.next'), { recursive: true });
+    fs.mkdirSync(path.join(root, 'dist'), { recursive: true });
+
+    fs.writeFileSync(path.join(root, 'src', 'index.ts'), 'export const a = 1;');
+    fs.writeFileSync(path.join(root, 'src', 'deep', 'util.js'), 'export const b = 2;');
+    fs.writeFileSync(path.join(root, 'node_modules', 'lib', 'index.js'), 'ignored');
+    fs.writeFileSync(path.join(root, '.next', 'bundle.js'), 'ignored');
+    fs.writeFileSync(path.join(root, 'dist', 'out.js'), 'ignored');
+    fs.writeFileSync(path.join(root, 'readme.md'), '# Markdown ignored');
+
+    const bundle = loadSource(root);
+
+    expect(bundle).not.toBeNull();
+    expect(bundle?.files).toHaveLength(2);
+    const paths = bundle?.files.map((f: { path: string }) => f.path.replace(/\\/g, '/')).sort();
+    expect(paths).toEqual(['src/deep/util.js', 'src/index.ts']);
+    expect(bundle?.promptContent).toContain('// File: src/index.ts');
+    expect(bundle?.promptContent).toContain('// File: src/deep/util.js');
+    expect(bundle?.capped).toBe(false);
+  });
+
+  it('caps directory collection at maxFiles and sets capped to true', () => {
+    fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+    for (let i = 0; i < 15; i++) {
+      fs.writeFileSync(path.join(root, 'src', `file_${String(i).padStart(2, '0')}.ts`), `const v = ${i};`);
+    }
+
+    const bundle = loadSource(root, { maxFiles: 10 });
+
+    expect(bundle).not.toBeNull();
+    expect(bundle?.files).toHaveLength(10);
+    expect(bundle?.capped).toBe(true);
+  });
+
+  it('returns null and sets process.exitCode = 1 when directory contains no code files', () => {
+    fs.writeFileSync(path.join(root, 'notes.txt'), 'text only');
+
+    const bundle = loadSource(root);
+
+    expect(bundle).toBeNull();
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('loads git diff when diff option is specified', () => {
+    execFileSync('git', ['init'], { cwd: root });
+    execFileSync('git', ['config', 'user.name', 'Test'], { cwd: root });
+    execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: root });
+
+    const file = path.join(root, 'code.ts');
+    fs.writeFileSync(file, 'const initial = 1;\n');
+    execFileSync('git', ['add', '.'], { cwd: root });
+    execFileSync('git', ['commit', '-m', 'initial'], { cwd: root });
+
+    fs.appendFileSync(file, 'const changed = 2;\n');
+
+    const bundle = loadSource(root, { diff: true });
+
+    expect(bundle).not.toBeNull();
+    expect(bundle?.isDiff).toBe(true);
+    expect(bundle?.promptContent).toContain('+const changed = 2;');
+    expect(process.exitCode).toBe(0);
+  });
+
+  it('returns null and sets exitCode = 1 when git diff is empty', () => {
+    execFileSync('git', ['init'], { cwd: root });
+    execFileSync('git', ['config', 'user.name', 'Test'], { cwd: root });
+    execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: root });
+
+    const file = path.join(root, 'code.ts');
+    fs.writeFileSync(file, 'const initial = 1;\n');
+    execFileSync('git', ['add', '.'], { cwd: root });
+    execFileSync('git', ['commit', '-m', 'initial'], { cwd: root });
+
+    const bundle = loadSource(root, { diff: true });
+
+    expect(bundle).toBeNull();
+    expect(process.exitCode).toBe(1);
+  });
+});

package/dist/config/config.d.ts

@@ -6,6 +6,9 @@ export interface DhruvConfig {
     timeoutMs: number;
     theme?: 'default' | 'dark' | 'light' | 'mono';
 }
+export declare function setSessionConfig(config: Partial<DhruvConfig>): void;
+export declare function resetSessionConfig(): void;
+export declare function getSessionConfig(): Partial<DhruvConfig>;
 export declare function loadConfig(): DhruvConfig;
 export declare function saveConfig(config: Partial<DhruvConfig>, options?: {
     scope?: ConfigScope;

package/dist/config/config.js

@@ -10,6 +10,16 @@ const defaultConfig = {
     timeoutMs: 45000,
     theme: 'default',
 };
+let sessionConfig = {};
+export function setSessionConfig(config) {
+    sessionConfig = { ...sessionConfig, ...config };
+}
+export function resetSessionConfig() {
+    sessionConfig = {};
+}
+export function getSessionConfig() {
+    return { ...sessionConfig };
+}
 function readConfigFile(file) {
     if (fs.existsSync(file)) {
         try {
@@ -25,11 +35,17 @@ function readConfigFile(file) {
     return defaultConfig;
 }
 export function loadConfig() {
-    if (fs.existsSync(LOCAL_CONFIG_FILE))
-        return readConfigFile(LOCAL_CONFIG_FILE);
-    if (fs.existsSync(GLOBAL_CONFIG_FILE))
-        return readConfigFile(GLOBAL_CONFIG_FILE);
-    return defaultConfig;
+    let base;
+    if (fs.existsSync(LOCAL_CONFIG_FILE)) {
+        base = readConfigFile(LOCAL_CONFIG_FILE);
+    }
+    else if (fs.existsSync(GLOBAL_CONFIG_FILE)) {
+        base = readConfigFile(GLOBAL_CONFIG_FILE);
+    }
+    else {
+        base = defaultConfig;
+    }
+    return validateAndMergeConfig({ ...base, ...sessionConfig });
 }
 function validateAndMergeConfig(config) {
     const validatedConfig = { ...defaultConfig };
@@ -57,7 +73,7 @@ function validateAndMergeConfig(config) {
 export function saveConfig(config, options = {}) {
     const scope = options.scope ?? 'local';
     const file = scope === 'global' ? GLOBAL_CONFIG_FILE : LOCAL_CONFIG_FILE;
-    const current = scope === 'global' ? readConfigFile(GLOBAL_CONFIG_FILE) : loadConfig();
+    const current = fs.existsSync(file) ? readConfigFile(file) : defaultConfig;
     if (scope === 'global')
         fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, JSON.stringify({ ...current, ...config }, null, 2));

package/dist/core/source-bundle.d.ts

@@ -0,0 +1,18 @@
+export declare const CODE_FILE: RegExp;
+export declare const IGNORED_DIRECTORIES: Set<string>;
+export interface SourceFile {
+    path: string;
+    content: string;
+}
+export interface SourceBundle {
+    target: string;
+    files: SourceFile[];
+    isDiff: boolean;
+    capped: boolean;
+    promptContent: string;
+}
+export interface LoadSourceOptions {
+    diff?: boolean;
+    maxFiles?: number;
+}
+export declare function loadSource(target: string, options?: LoadSourceOptions): SourceBundle | null;

package/dist/core/source-bundle.js

@@ -0,0 +1,147 @@
+import fs from 'fs';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import { printError, printInfo } from '../utils/ux.js';
+export const CODE_FILE = /\.(js|ts|jsx|tsx|py|java|cpp|c|go|rs|rb|php)$/;
+export const IGNORED_DIRECTORIES = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '.dhruv-cache',
+    'logs',
+    '.next',
+    '.turbo',
+    '__pycache__',
+    '.pytest_cache',
+    'target',
+    'vendor',
+]);
+export function loadSource(target, options = {}) {
+    if (options.diff) {
+        return loadGitDiff(target);
+    }
+    let stat;
+    try {
+        stat = fs.statSync(target);
+    }
+    catch {
+        printError(`Path "${target}" does not exist or could not be read.`);
+        process.exitCode = 1;
+        return null;
+    }
+    if (stat.isFile()) {
+        return loadSingleFile(target);
+    }
+    if (stat.isDirectory()) {
+        return loadDirectory(target, options.maxFiles ?? 10);
+    }
+    printError(`Path "${target}" is neither a file nor a directory.`);
+    process.exitCode = 1;
+    return null;
+}
+function loadSingleFile(target) {
+    try {
+        const content = fs.readFileSync(target, 'utf-8');
+        const relativePath = path.basename(target);
+        return {
+            target,
+            files: [{ path: relativePath, content }],
+            isDiff: false,
+            capped: false,
+            promptContent: content,
+        };
+    }
+    catch {
+        printError(`Path "${target}" does not exist or could not be read.`);
+        process.exitCode = 1;
+        return null;
+    }
+}
+function loadDirectory(dir, maxFiles) {
+    const collectedFiles = [];
+    let capped = false;
+    function collect(current) {
+        if (collectedFiles.length >= maxFiles) {
+            capped = true;
+            return;
+        }
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (collectedFiles.length >= maxFiles) {
+                capped = true;
+                return;
+            }
+            const absolute = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (!IGNORED_DIRECTORIES.has(entry.name)) {
+                    collect(absolute);
+                }
+            }
+            else if (entry.isFile() && CODE_FILE.test(entry.name)) {
+                try {
+                    const content = fs.readFileSync(absolute, 'utf-8');
+                    const relPath = path.relative(dir, absolute).split(path.sep).join('/');
+                    collectedFiles.push({ path: relPath, content });
+                }
+                catch {
+                    // ignore unreadable file
+                }
+            }
+        }
+    }
+    collect(dir);
+    if (collectedFiles.length === 0) {
+        printError(`No code files found in directory "${dir}".`);
+        process.exitCode = 1;
+        return null;
+    }
+    if (capped) {
+        printInfo(`Note: Directory review is capped at the first ${maxFiles} source files.`);
+    }
+    let promptContent = '';
+    for (const f of collectedFiles) {
+        promptContent += `\n// File: ${f.path}\n${f.content}\n`;
+    }
+    return {
+        target: dir,
+        files: collectedFiles,
+        isDiff: false,
+        capped,
+        promptContent,
+    };
+}
+function loadGitDiff(fileOrDir) {
+    const root = fs.existsSync(fileOrDir) && fs.statSync(fileOrDir).isDirectory() ? fileOrDir : path.dirname(fileOrDir);
+    try {
+        const diff = execFileSync('git', ['diff', '--no-ext-diff', '--unified=80', '--'], {
+            cwd: root,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        if (!diff.trim()) {
+            printError(`No uncommitted changes found in "${fileOrDir}".`);
+            process.exitCode = 1;
+            return null;
+        }
+        return {
+            target: fileOrDir,
+            files: [],
+            isDiff: true,
+            capped: false,
+            promptContent: diff,
+        };
+    }
+    catch {
+        printError(`Could not read a git diff for "${fileOrDir}".`);
+        process.exitCode = 1;
+        return null;
+    }
+}

package/dist/index.js

@@ -110,9 +110,9 @@ program
             config.responseFormat = 'json';
         if (opts.timeout)
             config.timeoutMs = Number(opts.timeout);
-        // Save config for session
+        // Set in-memory config overrides for the session
         const configModule = await import('./config/config.js');
-        configModule.saveConfig(config);
+        configModule.setSessionConfig(config);
     }
 });
 async function loadPlugins(program) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rahul05ranjan/dhruv-cli",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "AI-powered CLI assistant for developers using Ollama",
   "keywords": [
     "ai",

package/src/config/config.ts

@@ -23,6 +23,20 @@ const defaultConfig: DhruvConfig = {
   theme: 'default',
 };
 
+let sessionConfig: Partial<DhruvConfig> = {};
+
+export function setSessionConfig(config: Partial<DhruvConfig>): void {
+  sessionConfig = { ...sessionConfig, ...config };
+}
+
+export function resetSessionConfig(): void {
+  sessionConfig = {};
+}
+
+export function getSessionConfig(): Partial<DhruvConfig> {
+  return { ...sessionConfig };
+}
+
 function readConfigFile(file: string): DhruvConfig {
   if (fs.existsSync(file)) {
     try {
@@ -38,9 +52,15 @@ function readConfigFile(file: string): DhruvConfig {
 }
 
 export function loadConfig(): DhruvConfig {
-  if (fs.existsSync(LOCAL_CONFIG_FILE)) return readConfigFile(LOCAL_CONFIG_FILE);
-  if (fs.existsSync(GLOBAL_CONFIG_FILE)) return readConfigFile(GLOBAL_CONFIG_FILE);
-  return defaultConfig;
+  let base: DhruvConfig;
+  if (fs.existsSync(LOCAL_CONFIG_FILE)) {
+    base = readConfigFile(LOCAL_CONFIG_FILE);
+  } else if (fs.existsSync(GLOBAL_CONFIG_FILE)) {
+    base = readConfigFile(GLOBAL_CONFIG_FILE);
+  } else {
+    base = defaultConfig;
+  }
+  return validateAndMergeConfig({ ...base, ...sessionConfig });
 }
 
 function validateAndMergeConfig(config: Partial<DhruvConfig>): DhruvConfig {
@@ -76,7 +96,7 @@ function validateAndMergeConfig(config: Partial<DhruvConfig>): DhruvConfig {
 export function saveConfig(config: Partial<DhruvConfig>, options: { scope?: ConfigScope } = {}) {
   const scope = options.scope ?? 'local';
   const file = scope === 'global' ? GLOBAL_CONFIG_FILE : LOCAL_CONFIG_FILE;
-  const current = scope === 'global' ? readConfigFile(GLOBAL_CONFIG_FILE) : loadConfig();
+  const current = fs.existsSync(file) ? readConfigFile(file) : defaultConfig;
   if (scope === 'global') fs.mkdirSync(path.dirname(file), { recursive: true });
   fs.writeFileSync(file, JSON.stringify({ ...current, ...config }, null, 2));
 }

package/src/core/source-bundle.ts

@@ -0,0 +1,180 @@
+import fs from 'fs';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import { printError, printInfo } from '../utils/ux.js';
+
+export const CODE_FILE = /\.(js|ts|jsx|tsx|py|java|cpp|c|go|rs|rb|php)$/;
+
+export const IGNORED_DIRECTORIES = new Set([
+  '.git',
+  'node_modules',
+  'dist',
+  'build',
+  'coverage',
+  '.dhruv-cache',
+  'logs',
+  '.next',
+  '.turbo',
+  '__pycache__',
+  '.pytest_cache',
+  'target',
+  'vendor',
+]);
+
+export interface SourceFile {
+  path: string;
+  content: string;
+}
+
+export interface SourceBundle {
+  target: string;
+  files: SourceFile[];
+  isDiff: boolean;
+  capped: boolean;
+  promptContent: string;
+}
+
+export interface LoadSourceOptions {
+  diff?: boolean;
+  maxFiles?: number;
+}
+
+export function loadSource(target: string, options: LoadSourceOptions = {}): SourceBundle | null {
+  if (options.diff) {
+    return loadGitDiff(target);
+  }
+
+  let stat: fs.Stats;
+  try {
+    stat = fs.statSync(target);
+  } catch {
+    printError(`Path "${target}" does not exist or could not be read.`);
+    process.exitCode = 1;
+    return null;
+  }
+
+  if (stat.isFile()) {
+    return loadSingleFile(target);
+  }
+
+  if (stat.isDirectory()) {
+    return loadDirectory(target, options.maxFiles ?? 10);
+  }
+
+  printError(`Path "${target}" is neither a file nor a directory.`);
+  process.exitCode = 1;
+  return null;
+}
+
+function loadSingleFile(target: string): SourceBundle | null {
+  try {
+    const content = fs.readFileSync(target, 'utf-8');
+    const relativePath = path.basename(target);
+    return {
+      target,
+      files: [{ path: relativePath, content }],
+      isDiff: false,
+      capped: false,
+      promptContent: content,
+    };
+  } catch {
+    printError(`Path "${target}" does not exist or could not be read.`);
+    process.exitCode = 1;
+    return null;
+  }
+}
+
+function loadDirectory(dir: string, maxFiles: number): SourceBundle | null {
+  const collectedFiles: SourceFile[] = [];
+  let capped = false;
+
+  function collect(current: string): void {
+    if (collectedFiles.length >= maxFiles) {
+      capped = true;
+      return;
+    }
+
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (collectedFiles.length >= maxFiles) {
+        capped = true;
+        return;
+      }
+
+      const absolute = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (!IGNORED_DIRECTORIES.has(entry.name)) {
+          collect(absolute);
+        }
+      } else if (entry.isFile() && CODE_FILE.test(entry.name)) {
+        try {
+          const content = fs.readFileSync(absolute, 'utf-8');
+          const relPath = path.relative(dir, absolute).split(path.sep).join('/');
+          collectedFiles.push({ path: relPath, content });
+        } catch {
+          // ignore unreadable file
+        }
+      }
+    }
+  }
+
+  collect(dir);
+
+  if (collectedFiles.length === 0) {
+    printError(`No code files found in directory "${dir}".`);
+    process.exitCode = 1;
+    return null;
+  }
+
+  if (capped) {
+    printInfo(`Note: Directory review is capped at the first ${maxFiles} source files.`);
+  }
+
+  let promptContent = '';
+  for (const f of collectedFiles) {
+    promptContent += `\n// File: ${f.path}\n${f.content}\n`;
+  }
+
+  return {
+    target: dir,
+    files: collectedFiles,
+    isDiff: false,
+    capped,
+    promptContent,
+  };
+}
+
+function loadGitDiff(fileOrDir: string): SourceBundle | null {
+  const root = fs.existsSync(fileOrDir) && fs.statSync(fileOrDir).isDirectory() ? fileOrDir : path.dirname(fileOrDir);
+  try {
+    const diff = execFileSync('git', ['diff', '--no-ext-diff', '--unified=80', '--'], {
+      cwd: root,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+
+    if (!diff.trim()) {
+      printError(`No uncommitted changes found in "${fileOrDir}".`);
+      process.exitCode = 1;
+      return null;
+    }
+
+    return {
+      target: fileOrDir,
+      files: [],
+      isDiff: true,
+      capped: false,
+      promptContent: diff,
+    };
+  } catch {
+    printError(`Could not read a git diff for "${fileOrDir}".`);
+    process.exitCode = 1;
+    return null;
+  }
+}

package/src/index.ts

@@ -123,9 +123,9 @@ program
       if (opts.verbose) config.verbose = true;
       if (opts.json) config.responseFormat = 'json';
       if (opts.timeout) config.timeoutMs = Number(opts.timeout);
-      // Save config for session
+      // Set in-memory config overrides for the session
       const configModule = await import('./config/config.js');
-      configModule.saveConfig(config);
+      configModule.setSessionConfig(config);
     }
   });