commit-sense-cli 1.0.1

package/README.md

@@ -0,0 +1,43 @@
+# CommitSense
+
+CommitSense helps developers write accurate, meaningful, and semantically correct Conventional Commits by analyzing diffs and suggesting the appropriate commit type and scope.
+
+## Features 
+
+- **Fast & Local**: Runs entirely on your machine.
+- **Smart Suggestions**: Analyzes staged files to suggest commit types (feat, fix, chore, etc.).
+- **Advanced Analysis** :
+    - **Dependency Checks**: Detects `chore` for `package.json` updates.
+    - **Code Aware**: Detects `feat` for new exports and `refactor` for removed exports.
+    - **Scope Detection**: Intelligent scope suggestion based on directory structure (prioritizing feature folders over utility folders).
+- **Zero Config**: Works out of the box for most projects.
+
+## Installation
+
+```bash
+npm install -g commit-sense
+```
+
+## Usage
+
+Stage your changes:
+
+```bash
+git add .
+```
+
+Run CommitSense instead of `git commit`:
+
+```bash
+commit-sense
+```
+
+Follow the interactive prompts to confirm or edit the commit message.
+
+## Development
+
+1. Clone the repo
+2. Install dependencies: `npm install`
+3. Build: `npm run build`
+4. Run locally: `npm run dev` (or `node bin/commitsense.js`)
+

package/bin/commitsense.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/index.js');

package/dist/analysis/analyzer.d.ts

@@ -0,0 +1,16 @@
+import { CommitType } from './classifier';
+export interface AnalysisResult {
+    type: CommitType;
+    confidence: number;
+    reason: string;
+}
+export interface FileChange {
+    path: string;
+    diff: string;
+}
+export interface Analyzer {
+    analyze(fileChanges: FileChange[]): Promise<AnalysisResult[]>;
+}
+export declare class DependencyAnalyzer implements Analyzer {
+    analyze(fileChanges: FileChange[]): Promise<AnalysisResult[]>;
+}

package/dist/analysis/analyzer.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyAnalyzer = void 0;
+class DependencyAnalyzer {
+    async analyze(fileChanges) {
+        const results = [];
+        for (const file of fileChanges) {
+            if (file.path.endsWith('package.json')) {
+                const diff = file.diff;
+                // Simple regex to check for dependency changes
+                // Look for lines adding/changing dependencies
+                // + "react": "^18.0.0"
+                const addedDeps = (diff.match(/^\+.*"(dependencies|devDependencies|peerDependencies)"/m));
+                const changedLine = (diff.match(/^\+.*:\s*".*"/mg));
+                if (addedDeps || changedLine) {
+                    // Check if it is a devDependency (chore) or runtime dependency (fix/feat/chore depending on convention)
+                    // For now, let's treat all dependency updates as 'chore' but with high confidence, 
+                    // unless we can detect it's a critical fix? 
+                    // Standard convention: 
+                    // valid: chore(deps): update react
+                    // So 'chore' is safe.
+                    results.push({
+                        type: 'chore',
+                        confidence: 0.9,
+                        reason: `Detected dependency change in ${file.path}`
+                    });
+                }
+            }
+            if (file.path.endsWith('package-lock.json') || file.path.endsWith('yarn.lock') || file.path.endsWith('pnpm-lock.yaml')) {
+                results.push({
+                    type: 'chore',
+                    confidence: 0.9,
+                    reason: `Detected lockfile change in ${file.path}`
+                });
+            }
+        }
+        return results;
+    }
+}
+exports.DependencyAnalyzer = DependencyAnalyzer;

package/dist/analysis/classifier.d.ts

@@ -0,0 +1,8 @@
+import { FileChange } from './analyzer';
+export type CommitType = 'feat' | 'fix' | 'chore' | 'docs' | 'style' | 'refactor' | 'test' | 'ci';
+export interface CommitClassification {
+    type: CommitType;
+    confidence: number;
+    reason: string;
+}
+export declare function classifyChanges(fileChanges: FileChange[]): Promise<CommitClassification>;

package/dist/analysis/classifier.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyChanges = classifyChanges;
+const analyzer_1 = require("./analyzer");
+const codeAnalyzer_1 = require("./codeAnalyzer");
+const simpleAnalyzer_1 = require("./simpleAnalyzer");
+async function classifyChanges(fileChanges) {
+    const analyzers = [
+        new analyzer_1.DependencyAnalyzer(),
+        new codeAnalyzer_1.CodeAnalyzer(),
+        new simpleAnalyzer_1.SimpleAnalyzer()
+    ];
+    let bestResult = {
+        type: 'feat',
+        confidence: 0,
+        reason: 'Default'
+    };
+    for (const analyzer of analyzers) {
+        const results = await analyzer.analyze(fileChanges);
+        for (const result of results) {
+            if (result.confidence > bestResult.confidence) {
+                bestResult = result;
+            }
+        }
+    }
+    return bestResult;
+}

package/dist/analysis/codeAnalyzer.d.ts

@@ -0,0 +1,4 @@
+import { Analyzer, AnalysisResult, FileChange } from './analyzer';
+export declare class CodeAnalyzer implements Analyzer {
+    analyze(fileChanges: FileChange[]): Promise<AnalysisResult[]>;
+}

package/dist/analysis/codeAnalyzer.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeAnalyzer = void 0;
+class CodeAnalyzer {
+    async analyze(fileChanges) {
+        const results = [];
+        for (const file of fileChanges) {
+            // Only analyze source code files
+            if (!file.path.match(/\.(ts|js|jsx|tsx)$/))
+                continue;
+            if (file.path.endsWith('.d.ts'))
+                continue; // Skip type definitions for now? Or maybe they are important for API?
+            const diff = file.diff;
+            // Regex for detecting exported members
+            // This is a naive heuristic but works for MVP
+            const removedExportRegex = /^-.*export\s+(const|let|var|function|class|interface|type|enum)\s+([a-zA-Z0-9_$]+)/m;
+            const addedExportRegex = /^\+.*export\s+(const|let|var|function|class|interface|type|enum)\s+([a-zA-Z0-9_$]+)/m;
+            // Check for BREAKING CHANGES (removed exports)
+            // We need to be careful: if a line is modified, it appears as - then +, so we need to see if the same name is added back.
+            const removedExports = new Set();
+            const addedExports = new Set();
+            const lines = diff.split('\n');
+            for (const line of lines) {
+                const removedMatch = line.match(removedExportRegex);
+                if (removedMatch) {
+                    removedExports.add(removedMatch[2]);
+                }
+                const addedMatch = line.match(addedExportRegex);
+                if (addedMatch) {
+                    addedExports.add(addedMatch[2]);
+                }
+            }
+            // identify truly removed exports (not just modified lines)
+            for (const removed of removedExports) {
+                if (!addedExports.has(removed)) {
+                    results.push({
+                        type: 'refactor', // defaulting to refactor or feat? logic says removing api is breaking, usually requires 'feat!' or just footer. for type, maybe 'refactor' or 'chore'?
+                        // Actually, breaking changes can be any type, but usually feat or fix.
+                        // For the purpose of *type* classification:
+                        // Removing API -> refactor (if cleanup) or feat (if breaking change logic)
+                        // Let's stick to 'refactor' for now, but with proper breaking change detection we might want to flag it in footer.
+                        confidence: 0.8,
+                        reason: `Detected removal of exported symbol '${removed}' in ${file.path}`
+                    });
+                }
+            }
+            // Identify NEW exports
+            for (const added of addedExports) {
+                if (!removedExports.has(added)) {
+                    results.push({
+                        type: 'feat',
+                        confidence: 0.9,
+                        reason: `Detected new exported symbol '${added}' in ${file.path}`
+                    });
+                }
+            }
+        }
+        return results;
+    }
+}
+exports.CodeAnalyzer = CodeAnalyzer;

package/dist/analysis/scope.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Detects the scope of the commit based on the staged files.
+ * @param stagedFiles List of staged files
+ * @returns The detected scope, or an empty string if no clear scope found.
+ */
+export declare function detectScope(stagedFiles: string[]): string;

package/dist/analysis/scope.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectScope = detectScope;
+const path_1 = __importDefault(require("path"));
+/**
+ * Detects the scope of the commit based on the staged files.
+ * @param stagedFiles List of staged files
+ * @returns The detected scope, or an empty string if no clear scope found.
+ */
+function detectScope(stagedFiles) {
+    if (stagedFiles.length === 0)
+        return '';
+    const scopes = {};
+    for (const file of stagedFiles) {
+        const dirname = path_1.default.dirname(file);
+        if (dirname === '.')
+            continue; // Root files don't suggest specific scope usually
+        const parts = dirname.split(path_1.default.sep);
+        // Use the first directory as the scope (e.g., 'src' in 'src/utils/foo.ts')
+        // Or maybe the last significant folder? 
+        // Let's try to be smart: if it's 'src/components/Button', scope is 'components' or 'Button'?
+        // Convention varies. Let's try the *first* folder for now (e.g. 'auth' in 'packages/auth')
+        // or the *last* folder if it's nested deep?
+        // Strategy: 
+        // 1. If 'packages/*', use the package name.
+        // 2. If 'src/*', use the immediate subdirectory.
+        let candidate = '';
+        if (parts[0] === 'packages' && parts.length > 1) {
+            candidate = parts[1];
+        }
+        else if (parts[0] === 'src' && parts.length > 1) {
+            candidate = parts[1];
+        }
+        else {
+            candidate = parts[0];
+        }
+        if (candidate) {
+            scopes[candidate] = (scopes[candidate] || 0) + 1;
+        }
+    }
+    // Filter out blacklisted scopes if there are other candidates
+    const BLACKLIST = ['utils', 'helpers', 'common', 'shared', 'types', 'interfaces'];
+    // Calculate counts
+    let maxScope = '';
+    let maxCount = 0;
+    // First pass: try to find non-blacklisted scopes
+    const nonBlacklistedScopes = Object.entries(scopes).filter(([s]) => !BLACKLIST.includes(s));
+    const candidates = nonBlacklistedScopes.length > 0 ? nonBlacklistedScopes : Object.entries(scopes);
+    for (const [scope, count] of candidates) {
+        if (count > maxCount) {
+            maxCount = count;
+            maxScope = scope;
+        }
+    }
+    return maxScope;
+}

package/dist/analysis/simpleAnalyzer.d.ts

@@ -0,0 +1,4 @@
+import { Analyzer, AnalysisResult, FileChange } from './analyzer';
+export declare class SimpleAnalyzer implements Analyzer {
+    analyze(fileChanges: FileChange[]): Promise<AnalysisResult[]>;
+}

package/dist/analysis/simpleAnalyzer.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleAnalyzer = void 0;
+const EXTENSION_MAPPING = {
+    '.md': 'docs',
+    '.txt': 'docs',
+    '.spec.ts': 'test',
+    '.test.ts': 'test',
+    '.spec.js': 'test',
+    '.test.js': 'test',
+    '.json': 'chore',
+    '.yaml': 'chore',
+    '.yml': 'chore',
+    '.css': 'style',
+    '.scss': 'style',
+    '.less': 'style',
+};
+const FILENAME_MAPPING = {
+    'package.json': 'chore',
+    'package-lock.json': 'chore',
+    'tsconfig.json': 'chore',
+    '.gitignore': 'chore',
+    '.eslintrc': 'chore',
+    '.prettierrc': 'chore',
+    'README.md': 'docs',
+    'LICENSE': 'chore',
+    'Dockerfile': 'ci',
+    '.github': 'ci',
+};
+class SimpleAnalyzer {
+    async analyze(fileChanges) {
+        const typeCounts = {};
+        const total = fileChanges.length;
+        for (const file of fileChanges) {
+            const path = file.path;
+            const basename = path.split('/').pop() || '';
+            const ext = '.' + path.split('.').pop();
+            let type = 'feat'; // Default assumption
+            if (path.includes('test/') || path.includes('tests/')) {
+                type = 'test';
+            }
+            else if (path.startsWith('.github/') || path.includes('/.github/')) {
+                type = 'ci';
+            }
+            else if (path.startsWith('docs/')) {
+                type = 'docs';
+            }
+            else if (FILENAME_MAPPING[basename]) {
+                type = FILENAME_MAPPING[basename];
+            }
+            else {
+                for (const extKey in EXTENSION_MAPPING) {
+                    if (path.endsWith(extKey)) {
+                        type = EXTENSION_MAPPING[extKey];
+                        break;
+                    }
+                }
+            }
+            typeCounts[type] = (typeCounts[type] || 0) + 1;
+        }
+        // Return the majority vote as a single result with confidence
+        let maxType = 'feat';
+        let maxCount = 0;
+        for (const [t, count] of Object.entries(typeCounts)) {
+            if (count > maxCount) {
+                maxCount = count;
+                maxType = t;
+            }
+        }
+        const confidence = total > 0 ? (maxCount / total) * 0.5 : 0; // Lower confidence for simple extension matching (max 0.5)
+        return [{
+                type: maxType,
+                confidence,
+                reason: `Detected ${maxType} based on file extensions (${maxCount}/${total} files).`
+            }];
+    }
+}
+exports.SimpleAnalyzer = SimpleAnalyzer;

package/dist/classifier.d.ts

@@ -0,0 +1,7 @@
+export type CommitType = 'feat' | 'fix' | 'chore' | 'docs' | 'style' | 'refactor' | 'test' | 'ci';
+export interface CommitClassification {
+    type: CommitType;
+    confidence: number;
+    reason: string;
+}
+export declare function classifyChanges(stagedFiles: string[]): CommitClassification;

package/dist/classifier.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyChanges = classifyChanges;
+const EXTENSION_MAPPING = {
+    '.md': 'docs',
+    '.txt': 'docs',
+    '.spec.ts': 'test',
+    '.test.ts': 'test',
+    '.spec.js': 'test',
+    '.test.js': 'test',
+    '.json': 'chore',
+    '.yaml': 'chore',
+    '.yml': 'chore',
+    '.css': 'style',
+    '.scss': 'style',
+    '.less': 'style',
+};
+const FILENAME_MAPPING = {
+    'package.json': 'chore',
+    'package-lock.json': 'chore',
+    'tsconfig.json': 'chore',
+    '.gitignore': 'chore',
+    '.eslintrc': 'chore',
+    '.prettierrc': 'chore',
+    'README.md': 'docs',
+    'LICENSE': 'chore',
+    'Dockerfile': 'ci',
+    '.github': 'ci',
+};
+function classifyChanges(stagedFiles) {
+    const typeCounts = {};
+    for (const file of stagedFiles) {
+        const basename = file.split('/').pop() || '';
+        const ext = '.' + file.split('.').pop();
+        let type = 'feat'; // Default assumption
+        if (file.includes('test/') || file.includes('tests/')) {
+            type = 'test';
+        }
+        else if (file.startsWith('.github/') || file.includes('/.github/')) {
+            type = 'ci';
+        }
+        else if (file.startsWith('docs/')) {
+            type = 'docs';
+        }
+        else if (FILENAME_MAPPING[basename]) {
+            type = FILENAME_MAPPING[basename];
+        }
+        else {
+            // Check extensions, prioritize longer matches (e.g. .spec.ts over .ts if we had .ts)
+            for (const extKey in EXTENSION_MAPPING) {
+                if (file.endsWith(extKey)) {
+                    type = EXTENSION_MAPPING[extKey];
+                    break;
+                }
+            }
+        }
+        typeCounts[type] = (typeCounts[type] || 0) + 1;
+    }
+    // Find majority
+    let maxType = 'feat';
+    let maxCount = 0;
+    for (const [t, count] of Object.entries(typeCounts)) {
+        if (count > maxCount) {
+            maxCount = count;
+            maxType = t;
+        }
+    }
+    // Simple confidence logic
+    const total = stagedFiles.length;
+    const confidence = total > 0 ? maxCount / total : 0;
+    return {
+        type: maxType,
+        confidence,
+        reason: `Detected ${maxType} based on ${maxCount}/${total} files.`
+    };
+}

package/dist/git.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get a list of currently staged files.
+ * @returns Array of file paths (relative to repo root)
+ */
+export declare function getStagedFiles(): Promise<string[]>;
+/**
+ * Get the diff of a specific staged file.
+ * @param filePath Relative path to the file
+ */
+export declare function getStagedFileDiff(filePath: string): Promise<string>;

package/dist/git.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStagedFiles = getStagedFiles;
+exports.getStagedFileDiff = getStagedFileDiff;
+const simple_git_1 = __importDefault(require("simple-git"));
+const git = (0, simple_git_1.default)();
+/**
+ * Get a list of currently staged files.
+ * @returns Array of file paths (relative to repo root)
+ */
+async function getStagedFiles() {
+    try {
+        const diff = await git.diff(['--cached', '--name-only', '--diff-filter=ACMR']);
+        return diff.split('\n').filter(Boolean).map(f => f.trim());
+    }
+    catch (error) {
+        console.error('Error getting staged files:', error);
+        process.exit(1);
+    }
+}
+/**
+ * Get the diff of a specific staged file.
+ * @param filePath Relative path to the file
+ */
+async function getStagedFileDiff(filePath) {
+    try {
+        return await git.diff(['--cached', filePath]);
+    }
+    catch (error) {
+        console.error(`Error getting diff for ${filePath}:`, error);
+        return '';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const git_1 = require("./utils/git");
+const classifier_1 = require("./analysis/classifier");
+const scope_1 = require("./analysis/scope");
+const child_process_1 = require("child_process");
+async function main() {
+    console.log(chalk_1.default.cyan('CommitSense - Smart Commit Wizard'));
+    // 1. Get staged files
+    const stagedFiles = await (0, git_1.getStagedFiles)();
+    if (stagedFiles.length === 0) {
+        console.log(chalk_1.default.yellow('No staged files found. Please stage your changes first.'));
+        process.exit(0);
+    }
+    console.log(chalk_1.default.gray(`Found ${stagedFiles.length} staged file(s):`));
+    stagedFiles.slice(0, 5).forEach(f => console.log(chalk_1.default.gray(` - ${f}`)));
+    if (stagedFiles.length > 5)
+        console.log(chalk_1.default.gray(` ... and ${stagedFiles.length - 5} more.`));
+    // 2. Analyze
+    const fileChanges = await Promise.all(stagedFiles.map(async (file) => ({
+        path: file,
+        diff: await (0, git_1.getStagedFileDiff)(file)
+    })));
+    const classification = await (0, classifier_1.classifyChanges)(fileChanges);
+    const suggestedScope = (0, scope_1.detectScope)(stagedFiles);
+    // 3. Prompt
+    const response = await (0, prompts_1.default)([
+        {
+            type: 'select',
+            name: 'type',
+            message: 'Select commit type:',
+            choices: [
+                { title: 'feat', value: 'feat', description: 'A new feature' },
+                { title: 'fix', value: 'fix', description: 'A bug fix' },
+                { title: 'chore', value: 'chore', description: 'Build process or auxiliary tool changes' },
+                { title: 'docs', value: 'docs', description: 'Documentation only changes' },
+                { title: 'style', value: 'style', description: 'Markup, white-space, formatting, missing semi-colons...' },
+                { title: 'refactor', value: 'refactor', description: 'A code change that neither fixes a bug or adds a feature' },
+                { title: 'perf', value: 'perf', description: 'A code change that improves performance' },
+                { title: 'test', value: 'test', description: 'Adding missing tests' },
+                { title: 'ci', value: 'ci', description: 'CI related changes' },
+            ],
+            initial: ['feat', 'fix', 'chore', 'docs', 'style', 'refactor', 'perf', 'test', 'ci'].indexOf(classification.type)
+        },
+        {
+            type: 'text',
+            name: 'scope',
+            message: 'Scope (optional):',
+            initial: suggestedScope
+        },
+        {
+            type: 'text',
+            name: 'description',
+            message: 'Short description:',
+            validate: (value) => value.length > 0 ? true : 'Description is required'
+        },
+        {
+            type: 'text',
+            name: 'body',
+            message: 'Long description (optional):',
+        },
+        {
+            type: 'text',
+            name: 'footer',
+            message: 'Footer (optional, e.g. BREAKING CHANGE):',
+        },
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: (prev, values) => {
+                const scopePart = values.scope ? `(${values.scope})` : '';
+                const title = `${values.type}${scopePart}: ${values.description}`;
+                console.log(chalk_1.default.green('\nPreview:'));
+                console.log(chalk_1.default.bold(title));
+                if (values.body)
+                    console.log(`\n${values.body}`);
+                if (values.footer)
+                    console.log(`\n${values.footer}`);
+                return 'Commit now?';
+            },
+            initial: true
+        }
+    ]);
+    if (!response.confirm) {
+        console.log(chalk_1.default.yellow('Commit cancelled.'));
+        process.exit(0);
+    }
+    // 4. Construct Commit Message
+    const scopePart = response.scope ? `(${response.scope})` : '';
+    let commitMsg = `${response.type}${scopePart}: ${response.description}`;
+    if (response.body) {
+        commitMsg += `\n\n${response.body}`;
+    }
+    if (response.footer) {
+        commitMsg += `\n\n${response.footer}`;
+    }
+    // 5. Execute Commit
+    const child = (0, child_process_1.spawn)('git', ['commit', '-m', commitMsg], { stdio: 'inherit' });
+    child.on('close', (code) => {
+        if (code === 0) {
+            console.log(chalk_1.default.green('Commit successful!'));
+        }
+        else {
+            console.log(chalk_1.default.red(`Commit failed with code ${code}`));
+        }
+    });
+}
+main().catch(err => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/scope.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Detects the scope of the commit based on the staged files.
+ * @param stagedFiles List of staged files
+ * @returns The detected scope, or an empty string if no clear scope found.
+ */
+export declare function detectScope(stagedFiles: string[]): string;

package/dist/scope.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectScope = detectScope;
+const path_1 = __importDefault(require("path"));
+/**
+ * Detects the scope of the commit based on the staged files.
+ * @param stagedFiles List of staged files
+ * @returns The detected scope, or an empty string if no clear scope found.
+ */
+function detectScope(stagedFiles) {
+    if (stagedFiles.length === 0)
+        return '';
+    const scopes = {};
+    for (const file of stagedFiles) {
+        const dirname = path_1.default.dirname(file);
+        if (dirname === '.')
+            continue; // Root files don't suggest specific scope usually
+        const parts = dirname.split(path_1.default.sep);
+        // Use the first directory as the scope (e.g., 'src' in 'src/utils/foo.ts')
+        // Or maybe the last significant folder? 
+        // Let's try to be smart: if it's 'src/components/Button', scope is 'components' or 'Button'?
+        // Convention varies. Let's try the *first* folder for now (e.g. 'auth' in 'packages/auth')
+        // or the *last* folder if it's nested deep?
+        // Strategy: 
+        // 1. If 'packages/*', use the package name.
+        // 2. If 'src/*', use the immediate subdirectory.
+        let candidate = '';
+        if (parts[0] === 'packages' && parts.length > 1) {
+            candidate = parts[1];
+        }
+        else if (parts[0] === 'src' && parts.length > 1) {
+            candidate = parts[1];
+        }
+        else {
+            candidate = parts[0];
+        }
+        if (candidate) {
+            scopes[candidate] = (scopes[candidate] || 0) + 1;
+        }
+    }
+    // Find the most frequent scope
+    let maxScope = '';
+    let maxCount = 0;
+    for (const [scope, count] of Object.entries(scopes)) {
+        if (count > maxCount) {
+            maxCount = count;
+            maxScope = scope;
+        }
+    }
+    return maxScope;
+}

package/dist/utils/git.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get a list of currently staged files.
+ * @returns Array of file paths (relative to repo root)
+ */
+export declare function getStagedFiles(): Promise<string[]>;
+/**
+ * Get the diff of a specific staged file.
+ * @param filePath Relative path to the file
+ */
+export declare function getStagedFileDiff(filePath: string): Promise<string>;

package/dist/utils/git.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStagedFiles = getStagedFiles;
+exports.getStagedFileDiff = getStagedFileDiff;
+const simple_git_1 = __importDefault(require("simple-git"));
+const git = (0, simple_git_1.default)();
+/**
+ * Get a list of currently staged files.
+ * @returns Array of file paths (relative to repo root)
+ */
+async function getStagedFiles() {
+    try {
+        const diff = await git.diff(['--cached', '--name-only', '--diff-filter=ACMR']);
+        return diff.split('\n').filter(Boolean).map(f => f.trim());
+    }
+    catch (error) {
+        console.error('Error getting staged files:', error);
+        process.exit(1);
+    }
+}
+/**
+ * Get the diff of a specific staged file.
+ * @param filePath Relative path to the file
+ */
+async function getStagedFileDiff(filePath) {
+    try {
+        return await git.diff(['--cached', filePath]);
+    }
+    catch (error) {
+        console.error('Error getting diff for:', filePath, error);
+        return '';
+    }
+}

package/docs/ROADMAP.md

@@ -0,0 +1,119 @@
+# CommitSense Roadmap
+
+## Vision
+
+CommitSense helps developers write accurate, meaningful, and
+semantically correct Conventional Commits by analyzing diffs and
+suggesting the appropriate commit type and scope.
+
+------------------------------------------------------------------------
+
+## Phase 1 -- MVP (Local npm CLI)
+
+### Goals
+
+-   Fast execution (\<300ms)
+-   Deterministic rule-based classification
+-   Zero-config setup
+-   Git hook integration
+
+### Core Features
+
+-   Read staged diff
+-   Detect changed file types
+-   Classify commit type (feat, fix, chore, docs, test, style, refactor)
+-   Detect scope from directory structure
+-   Suggest improved Conventional Commit message
+-   Interactive confirmation before commit
+
+### Tech Stack
+
+-   Node.js + TypeScript
+-   simple-git or native child_process
+-   diff parser
+-   Optional lightweight AST (Babel) for export detection
+
+------------------------------------------------------------------------
+
+## Phase 2 -- Advanced Classification
+
+### Goals
+
+-   Improve semantic accuracy
+-   Detect breaking changes
+-   Detect behavior changes vs refactor
+
+### Features
+
+-   Detect added/removed exports
+-   Detect API contract changes
+-   Detect dependency version updates
+-   Breaking change suggestion (feat!)
+-   Scope mismatch detection
+
+------------------------------------------------------------------------
+
+## Phase 3 -- GitHub Action
+
+### Goals
+
+-   CI integration
+-   PR-level validation
+
+### Features
+
+-   Validate all commits in PR
+-   Comment suggested corrections
+-   Commit quality score
+-   Flag risky commits
+
+------------------------------------------------------------------------
+
+## Phase 4 -- SaaS (CommitSense Cloud)
+
+### Goals
+
+-   Team-level insights
+-   Release hygiene monitoring
+-   Commit analytics dashboard
+
+### Features
+
+-   Commit quality trends
+-   Breaking change history
+-   Module-level commit insights
+-   Team commit discipline score
+-   Slack/Discord notifications
+
+------------------------------------------------------------------------
+
+## Long-Term Expansion Ideas
+
+-   AI-assisted diff explanation (optional premium feature)
+-   Automatic semantic version bump suggestion
+-   Release notes auto-generation
+-   Architecture-aware scope validation
+
+------------------------------------------------------------------------
+
+## Success Metrics
+
+-   \< 1 second runtime locally
+-   Low false-positive rate
+-   Easy installation via npm
+-   High adoption in open-source projects
+
+------------------------------------------------------------------------
+
+## First Milestone Checklist
+
+-   [ ] Initialize TypeScript CLI project
+-   [ ] Implement staged diff reader
+-   [ ] Implement basic commit type classifier
+-   [ ] Implement scope detection logic
+-   [ ] Add interactive CLI prompt
+-   [ ] Publish v0.1.0 to npm
+
+------------------------------------------------------------------------
+
+Built with clarity, speed, and developer experience in mind.

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "commit-sense-cli",
+  "version": "1.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "bin": {
+    "commit-sense-cli": "bin/commitsense.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md",
+    "LICENSE",
+    "docs"
+  ],
+  "directories": {
+    "doc": "docs"
+  },
+  "scripts": {
+    "test": "jest",
+    "build": "tsc",
+    "dev": "ts-node src/index.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abhishekpanda0620/commit-sense.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "bugs": {
+    "url": "https://github.com/abhishekpanda0620/commit-sense/issues"
+  },
+  "homepage": "https://github.com/abhishekpanda0620/commit-sense#readme",
+  "dependencies": {
+    "@types/node": "^25.2.3",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "prompts": "^2.4.2",
+    "simple-git": "^3.30.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/prompts": "^2.4.9",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6"
+  }
+}