@rahul05ranjan/dhruv-cli 1.6.1 → 1.7.0

package/CHANGELOG.md

@@ -1,9 +1,9 @@
-# [1.4.0](https://github.com/rahul05ranjan/dhruv-cli/compare/v1.6.0...v1.4.0) (2026-09-21)
+# [1.4.0](https://github.com/rahul05ranjan/dhruv-cli/compare/v1.6.1...v1.4.0) (2026-09-21)
 
 
-### Bug Fixes
+### Features
 
-* **config:** keep one-off global flags in-memory and avoid writing local config (closes [#92](https://github.com/rahul05ranjan/dhruv-cli/issues/92)) ([3dd3f99](https://github.com/rahul05ranjan/dhruv-cli/commit/3dd3f99babe42d3804bfa438f38a3ddd6e1f1d72))
+* **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__/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/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/package.json

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

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;
+  }
+}