@rahul05ranjan/dhruv-cli 1.6.1 → 1.8.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.7.0...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))
+* **distribution:** add canonical MIT LICENSE and package.json license metadata (closes [#107](https://github.com/rahul05ranjan/dhruv-cli/issues/107)) ([5ac966d](https://github.com/rahul05ranjan/dhruv-cli/commit/5ac966dedc091e271e6f2aff5b8e8a8ddad86091))
 # Changelog
 
 ## [1.1.1](https://github.com/rahul05ranjan/dhruv-cli/compare/v1.1.0...v1.1.1) (2025-06-29)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rahul Ranjan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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/__tests__/workflows.test.ts

@@ -116,3 +116,18 @@ describe('security workflow requirements', () => {
     }
   });
 });
+
+describe('package distribution and licensing compliance', () => {
+  it('defines an explicit MIT license in package.json', () => {
+    const pkg = JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf8'));
+    expect(pkg.license).toBe('MIT');
+  });
+
+  it('provides a canonical root LICENSE file with copyright notice', () => {
+    const licensePath = resolve(root, 'LICENSE');
+    expect(existsSync(licensePath)).toBe(true);
+    const content = readFileSync(licensePath, 'utf8');
+    expect(content).toContain('MIT License');
+    expect(content).toContain('Copyright (c) 2026 Rahul Ranjan');
+  });
+});

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,7 +1,8 @@
 {
   "name": "@rahul05ranjan/dhruv-cli",
-  "version": "1.6.1",
+  "version": "1.8.0",
   "description": "AI-powered CLI assistant for developers using Ollama",
+  "license": "MIT",
   "keywords": [
     "ai",
     "cli",

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