minovative-mind-cli 1.5.0 → 2.0.0

package/dist/utils/dependencyTracer/modules/graph.js

@@ -0,0 +1,23 @@
+export function bfsTraverse(nodes, startFile, direction, maxDepth) {
+    const visited = new Set();
+    visited.add(startFile);
+    const queue = [{ file: startFile, depth: 0 }];
+    const result = [];
+    while (queue.length > 0) {
+        const { file, depth } = queue.shift();
+        if (depth >= maxDepth)
+            continue;
+        const node = nodes.get(file);
+        if (!node)
+            continue;
+        const neighbors = node[direction];
+        for (const neighbor of neighbors) {
+            if (!visited.has(neighbor)) {
+                visited.add(neighbor);
+                result.push(neighbor);
+                queue.push({ file: neighbor, depth: depth + 1 });
+            }
+        }
+    }
+    return result;
+}

package/dist/utils/dependencyTracer/modules/profiles.d.ts

@@ -0,0 +1,7 @@
+export interface LanguageProfile {
+    extensions: string[];
+    patterns: RegExp[];
+    normalizeSpecifier?: (specifier: string, sourceFile: string) => string;
+}
+export declare const LANGUAGE_PROFILES: LanguageProfile[];
+export declare const PROFILE_BY_EXT: Map<string, LanguageProfile[]>;

package/dist/utils/dependencyTracer/modules/profiles.js

@@ -0,0 +1,120 @@
+export const LANGUAGE_PROFILES = [
+    {
+        extensions: ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.mts', '.cts'],
+        patterns: [
+            /import\s+(?:[\s\S]*?\s+from\s+)?['"](?<specifier>[^'"]+)['"]/gm,
+            /import\s*\(\s*['"](?<specifier>[^'"]+)['"]\s*\)/gm,
+            /require\s*\(\s*['"](?<specifier>[^'"]+)['"]\s*\)/gm,
+            /export\s+(?:[\s\S]*?\s+from\s+)['"](?<specifier>[^'"]+)['"]/gm,
+        ],
+    },
+    {
+        extensions: ['.py'],
+        patterns: [
+            /^from\s+(?<specifier>[^\s]+)\s+import\s/gm,
+            /^import\s+(?!.*\sfrom\s)(?<specifier>[^\s,]+)/gm,
+        ],
+        normalizeSpecifier: (spec) => {
+            if (spec.startsWith('.')) {
+                const dots = spec.match(/^\.+/)[0];
+                const rest = spec.slice(dots.length);
+                const prefix = dots.length === 1 ? './' : '../'.repeat(dots.length - 1);
+                return rest ? `${prefix}${rest.replace(/\./g, '/')}.py` : prefix.slice(0, -1);
+            }
+            return spec.replace(/\./g, '/') + '.py';
+        },
+    },
+    {
+        extensions: ['.rs'],
+        patterns: [
+            /use\s+(?<specifier>(?:crate|self|super)(?:::[a-zA-Z_][a-zA-Z0-9_]*)+)/gm,
+            /mod\s+(?<specifier>[a-zA-Z_][a-zA-Z0-9_]*)\s*;/gm,
+        ],
+        normalizeSpecifier: (spec) => {
+            if (!spec.includes('::')) {
+                return spec + '.rs';
+            }
+            const parts = spec
+                .replace(/^crate::/, '')
+                .replace(/^(self|super)::/, '')
+                .split('::');
+            return parts.join('/') + '.rs';
+        },
+    },
+    {
+        extensions: ['.go'],
+        patterns: [
+            /import\s+(?:[a-zA-Z_][a-zA-Z0-9_]*\s+)?["'](?<specifier>[^"']+)["']/gm,
+            /^\s*(?:[a-zA-Z_][a-zA-Z0-9_]*\s+)?["'](?<specifier>[^"']+)["']\s*$/gm,
+        ],
+    },
+    {
+        extensions: ['.c', '.h', '.cpp', '.hpp', '.cc', '.cxx', '.hh', '.hxx'],
+        patterns: [
+            /^\s*#\s*include\s+"(?<specifier>[^"]+)"/gm,
+            /^\s*#\s*include\s+<(?<specifier>[^>]+)>/gm,
+        ],
+    },
+    {
+        extensions: ['.java', '.kt', '.kts'],
+        patterns: [
+            /^import\s+(?:static\s+)?(?<specifier>[a-zA-Z_][a-zA-Z0-9_.]*\.[a-zA-Z_][a-zA-Z0-9_]*)/gm,
+        ],
+        normalizeSpecifier: (spec) => {
+            return spec.replace(/\./g, '/') + '.java';
+        },
+    },
+    {
+        extensions: ['.css', '.scss', '.sass', '.less', '.styl'],
+        patterns: [
+            /@import\s+(?:url\s*\(\s*)?['"](?<specifier>[^'"]+)['"]/gm,
+            /@use\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /@forward\s+['"](?<specifier>[^'"]+)['"]/gm,
+        ],
+    },
+    {
+        extensions: ['.rb'],
+        patterns: [
+            /require\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /require_relative\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /load\s+['"](?<specifier>[^'"]+)['"]/gm,
+        ],
+    },
+    {
+        extensions: ['.php'],
+        patterns: [
+            /use\s+(?<specifier>[A-Z][a-zA-Z0-9_\\]+)/gm,
+            /(?:include|require)(?:_once)?\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /(?:include|require)(?:_once)?\s*\(\s*['"](?<specifier>[^'"]+)['"]\s*\)/gm,
+        ],
+        normalizeSpecifier: (spec) => {
+            if (spec.includes('\\')) {
+                return spec.replace(/\\/g, '/') + '.php';
+            }
+            return spec;
+        },
+    },
+    {
+        extensions: ['.swift'],
+        patterns: [
+            /^import\s+(?:class\s+|struct\s+|enum\s+|protocol\s+|typealias\s+|func\s+|var\s+|let\s+)?(?<specifier>[a-zA-Z_][a-zA-Z0-9_.]*)/gm,
+        ],
+    },
+    {
+        extensions: ['.dart'],
+        patterns: [
+            /import\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /export\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /part\s+['"](?<specifier>[^'"]+)['"]/gm,
+            /part\s+of\s+['"](?<specifier>[^'"]+)['"]/gm,
+        ],
+    },
+];
+export const PROFILE_BY_EXT = new Map();
+for (const profile of LANGUAGE_PROFILES) {
+    for (const ext of profile.extensions) {
+        const existing = PROFILE_BY_EXT.get(ext) || [];
+        existing.push(profile);
+        PROFILE_BY_EXT.set(ext, existing);
+    }
+}

package/dist/utils/dependencyTracer/modules/resolver.d.ts

@@ -0,0 +1,7 @@
+export interface AliasMapping {
+    prefix: string;
+    targets: string[];
+}
+export declare function loadPathAliases(workspaceRoot: string): Promise<AliasMapping[]>;
+export declare function fileExists(filePath: string): Promise<boolean>;
+export declare function normalizeSlashes(p: string): string;

package/dist/utils/dependencyTracer/modules/resolver.js

@@ -0,0 +1,51 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+let cachedAliases = null;
+let cachedAliasRoot = null;
+export async function loadPathAliases(workspaceRoot) {
+    if (cachedAliasRoot === workspaceRoot && cachedAliases !== null) {
+        return cachedAliases;
+    }
+    const aliases = [];
+    for (const configName of ['tsconfig.json', 'jsconfig.json']) {
+        try {
+            const configPath = path.join(workspaceRoot, configName);
+            const raw = await fs.readFile(configPath, 'utf-8');
+            const cleaned = raw.replace(/\/\/.*$/gm, '').replace(/,\s*([\]}])/g, '');
+            const config = JSON.parse(cleaned);
+            const paths = config?.compilerOptions?.paths;
+            const baseUrl = config?.compilerOptions?.baseUrl || '.';
+            if (paths && typeof paths === 'object') {
+                for (const [pattern, targets] of Object.entries(paths)) {
+                    if (!Array.isArray(targets))
+                        continue;
+                    const prefix = pattern.replace(/\*$/, '');
+                    const resolvedTargets = targets.map((t) => {
+                        const targetBase = t.replace(/\*$/, '');
+                        return path.join(baseUrl, targetBase);
+                    });
+                    aliases.push({ prefix, targets: resolvedTargets });
+                }
+            }
+            break;
+        }
+        catch {
+            // Config doesn't exist or is invalid — try the next one
+        }
+    }
+    cachedAliases = aliases;
+    cachedAliasRoot = workspaceRoot;
+    return aliases;
+}
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function normalizeSlashes(p) {
+    return p.replace(/\\/g, '/');
+}

package/dist/utils/dependencyTracer/modules/types.d.ts

@@ -0,0 +1,4 @@
+export interface DependencyNode {
+    imports: Set<string>;
+    importedBy: Set<string>;
+}

package/dist/utils/dependencyTracer/modules/types.js

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

package/dist/utils/dependencyTracer/modules/walker.d.ts

@@ -0,0 +1 @@
+export declare function probeFilePath(candidate: string): Promise<string | null>;

package/dist/utils/dependencyTracer/modules/walker.js

@@ -0,0 +1,48 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { fileExists } from './resolver.js';
+const PROBE_EXTENSIONS = [
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts',
+    '.py', '.rs', '.go', '.rb', '.php', '.swift', '.dart',
+    '.css', '.scss', '.sass', '.less', '.json',
+];
+const INDEX_FILES = [
+    'index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.mjs',
+    'mod.rs', '__init__.py',
+];
+export async function probeFilePath(candidate) {
+    if (await fileExists(candidate)) {
+        const stat = await fs.stat(candidate);
+        if (stat.isFile())
+            return candidate;
+    }
+    for (const ext of PROBE_EXTENSIONS) {
+        const withExt = candidate + ext;
+        if (await fileExists(withExt)) {
+            return withExt;
+        }
+    }
+    for (const indexFile of INDEX_FILES) {
+        const withIndex = path.join(candidate, indexFile);
+        if (await fileExists(withIndex)) {
+            return withIndex;
+        }
+    }
+    const basename = path.basename(candidate);
+    if (!basename.startsWith('_')) {
+        const dir = path.dirname(candidate);
+        for (const ext of ['.scss', '.sass', '.less', '.css']) {
+            const partial = path.join(dir, `_${basename}${ext}`);
+            if (await fileExists(partial)) {
+                return partial;
+            }
+            if (basename.endsWith(ext)) {
+                const partialWithExt = path.join(dir, `_${basename}`);
+                if (await fileExists(partialWithExt)) {
+                    return partialWithExt;
+                }
+            }
+        }
+    }
+    return null;
+}

package/dist/utils/dependencyTracer.js

@@ -62,7 +62,10 @@ const LANGUAGE_PROFILES = [
                 return spec + '.rs';
             }
             // crate::foo::bar → src/foo/bar.rs (strip 'crate::' prefix)
-            const parts = spec.replace(/^crate::/, '').replace(/^(self|super)::/, '').split('::');
+            const parts = spec
+                .replace(/^crate::/, '')
+                .replace(/^(self|super)::/, '')
+                .split('::');
             return parts.join('/') + '.rs';
         },
     },
@@ -198,12 +201,7 @@ const WALK_IGNORED_DIRS = new Set([
     '.gradle',
     '.idea',
 ]);
-const WALK_IGNORED_FILES = new Set([
-    'package-lock.json',
-    'yarn.lock',
-    'pnpm-lock.yaml',
-    '.DS_Store',
-]);
+const WALK_IGNORED_FILES = new Set(['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', '.DS_Store']);
 // Build a set of bare extensions from EXCLUDED_EXTENSIONS for fast lookup
 const EXCLUDED_EXT_SET = new Set(EXCLUDED_EXTENSIONS.map((glob) => glob.replace('*', '')));
 let cachedAliases = null;
@@ -222,9 +220,7 @@ async function loadPathAliases(workspaceRoot) {
             const configPath = path.join(workspaceRoot, configName);
             const raw = await fs.readFile(configPath, 'utf-8');
             // Strip single-line comments (// ...) and trailing commas for lenient JSON parsing
-            const cleaned = raw
-                .replace(/\/\/.*$/gm, '')
-                .replace(/,\s*([\]}])/g, '$1');
+            const cleaned = raw.replace(/\/\/.*$/gm, '').replace(/,\s*([\]}])/g, '$1');
             const config = JSON.parse(cleaned);
             const paths = config?.compilerOptions?.paths;
             const baseUrl = config?.compilerOptions?.baseUrl || '.';
@@ -269,9 +265,7 @@ function extractImports(content, ext) {
             for (const match of content.matchAll(pattern)) {
                 const raw = match.groups?.specifier;
                 if (raw && raw.trim().length > 0) {
-                    const normalized = profile.normalizeSpecifier
-                        ? profile.normalizeSpecifier(raw.trim(), '')
-                        : raw.trim();
+                    const normalized = profile.normalizeSpecifier ? profile.normalizeSpecifier(raw.trim(), '') : raw.trim();
                     specifiers.add(normalized);
                 }
             }
@@ -282,14 +276,34 @@ function extractImports(content, ext) {
 // ─── Path Resolution ─────────────────────────────────────────────────
 /** Extensions to probe when the import specifier has no extension */
 const PROBE_EXTENSIONS = [
-    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts',
-    '.py', '.rs', '.go', '.rb', '.php', '.swift', '.dart',
-    '.css', '.scss', '.sass', '.less',
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.mts',
+    '.cts',
+    '.py',
+    '.rs',
+    '.go',
+    '.rb',
+    '.php',
+    '.swift',
+    '.dart',
+    '.css',
+    '.scss',
+    '.sass',
+    '.less',
     '.json',
 ];
 /** Index file basenames to probe for directory imports */
 const INDEX_FILES = [
-    'index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.mjs',
+    'index.ts',
+    'index.tsx',
+    'index.js',
+    'index.jsx',
+    'index.mjs',
     'mod.rs', // Rust convention
     '__init__.py', // Python convention
 ];

package/dist/utils/excludedExtensions.js

@@ -43,7 +43,6 @@ export const EXCLUDED_EXTENSIONS = [
     "*.gz",
     "*.tgz",
     // --- Documents ---
-    "*.pdf",
     "*.doc",
     "*.docx",
     "*.ppt",

package/dist/utils/historyPrompt.d.ts

@@ -0,0 +1,9 @@
+export interface HistoryTextOptions {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    history?: string[];
+    validate?: (value: string) => string | Error | undefined;
+}
+export declare const historyText: (opts: HistoryTextOptions) => Promise<string | symbol>;

package/dist/utils/historyPrompt.js

@@ -0,0 +1,87 @@
+import { TextPrompt } from '@clack/core';
+import pc from 'picocolors';
+// Emulate clack/prompts styling characters
+const S_BAR = '│';
+const S_BAR_END = '└';
+const S_STEP_ACTIVE = '◆';
+const S_STEP_CANCEL = '■';
+const S_STEP_ERROR = '▲';
+const S_STEP_SUBMIT = '◇';
+function symbol(state) {
+    switch (state) {
+        case 'initial':
+        case 'active':
+            return pc.cyan(S_STEP_ACTIVE);
+        case 'cancel':
+            return pc.red(S_STEP_CANCEL);
+        case 'error':
+            return pc.yellow(S_STEP_ERROR);
+        case 'submit':
+            return pc.green(S_STEP_SUBMIT);
+        default:
+            return pc.cyan(S_STEP_ACTIVE);
+    }
+}
+export const historyText = (opts) => {
+    const history = opts.history || [];
+    let historyIndex = -1;
+    const prompt = new TextPrompt({
+        validate: opts.validate,
+        placeholder: opts.placeholder,
+        defaultValue: opts.defaultValue,
+        initialValue: opts.initialValue,
+        render() {
+            const title = `${pc.gray(S_BAR)}\n${symbol(this.state)}  ${opts.message}\n`;
+            const placeholder = opts.placeholder
+                ? pc.inverse(opts.placeholder[0]) + pc.dim(opts.placeholder.slice(1))
+                : pc.inverse(pc.hidden('_'));
+            const value = !this.value ? placeholder : this.valueWithCursor;
+            switch (this.state) {
+                case 'error':
+                    return `${title.trim()}\n${pc.yellow(S_BAR)}  ${value}\n${pc.yellow(S_BAR_END)}  ${pc.yellow(this.error)}\n`;
+                case 'submit': {
+                    const submittedText = this.value || opts.placeholder || '';
+                    return `${title}${pc.gray(S_BAR)}  ${pc.bgBlue(pc.white(` ${submittedText} `))}`;
+                }
+                case 'cancel':
+                    return `${title}${pc.gray(S_BAR)}  ${pc.strikethrough(pc.dim(this.value ?? ''))}${this.value?.trim() ? `\n${pc.gray(S_BAR)}` : ''}`;
+                default:
+                    return `${title}${pc.cyan(S_BAR)}  ${value}\n${pc.cyan(S_BAR_END)}\n`;
+            }
+        },
+    });
+    prompt.on('cursor', (key) => {
+        if (key === 'up') {
+            if (history.length > 0 && historyIndex < history.length - 1) {
+                historyIndex++;
+                prompt.value = history[history.length - 1 - historyIndex];
+                const rl = prompt.rl;
+                if (rl) {
+                    rl.line = prompt.value;
+                    rl.cursor = prompt.value.length;
+                }
+            }
+        }
+        else if (key === 'down') {
+            if (historyIndex > 0) {
+                historyIndex--;
+                prompt.value = history[history.length - 1 - historyIndex];
+                const rl = prompt.rl;
+                if (rl) {
+                    rl.line = prompt.value;
+                    rl.cursor = prompt.value.length;
+                }
+            }
+            else if (historyIndex === 0) {
+                historyIndex = -1;
+                prompt.value = '';
+                const rl = prompt.rl;
+                if (rl) {
+                    rl.line = '';
+                    rl.cursor = 0;
+                }
+            }
+        }
+    });
+    return prompt.prompt();
+};

package/dist/utils/logo.d.ts

@@ -1,2 +1,4 @@
 export declare const LOGO: string;
 export declare function printLogo(): void;
+export declare const brandBg: (text: string) => string;
+export declare const brandFg: (text: any) => string;

package/dist/utils/logo.js

@@ -1,12 +1,33 @@
-import pc from 'picocolors';
-export const LOGO = `
-           ${pc.blue('///')}      ${pc.cyan('//')}               ${pc.cyan('\\\\')}      ${pc.blue('\\\\\\')}      ${pc.blue('  __  __  __  __    ____ _     ___ ')}
-          ${pc.blue('///')}      ${pc.cyan('//')}                 ${pc.cyan('\\\\')}      ${pc.blue('\\\\\\')}     ${pc.blue(' |  \\/  ||  \\/  |  / ___| |   |_ _|')}
-         ${pc.blue('///')}      ${pc.cyan('//')}         ${pc.cyan('●')}         ${pc.cyan('\\\\')}      ${pc.blue('\\\\\\')}    ${pc.blue(' | |\\/| || |\\/| | | |   | |    | | ')}
-         ${pc.blue('\\\\\\')}      ${pc.cyan('\\\\')}                   ${pc.cyan('//')}      ${pc.blue('///')}    ${pc.blue(' | |  | || |  | | | |___| |___ | | ')}
-          ${pc.blue('\\\\\\')}      ${pc.cyan('\\\\')}                 ${pc.cyan('//')}      ${pc.blue('///')}     ${pc.blue(' |_|  |_||_|  |_|  \\____|_____|___|')}
-           ${pc.blue('\\\\\\')}      ${pc.cyan('\\\\')}               ${pc.cyan('//')}      ${pc.blue('///')}
-`;
+import gradient from 'gradient-string';
+// Premium hex profiles sampled directly from mino-logo-dark.png
+const leftG = gradient(['#222', '#0044ff']); // Cyan to deep royal blue (inward flow)
+const rightG = gradient(['#0044ff', '#222']); // Deep royal blue to cyan (outward flow)
+const dotG = gradient(['#222', '#0044ff']); // Centered neon core
+const textG = gradient(['#0052ff', '#222']); // Electric blue-to-cyan shift for typography
+export const LOGO = [
+    // Line 1
+    `      ${leftG('████')}    ${leftG('████')}          ${rightG('████')}    ${rightG('████')}                ${textG('██      ██  ██      ██    ████████  ██        ██████')}`,
+    // Line 2
+    `    ${leftG('████')}    ${leftG('████')}              ${rightG('████')}    ${rightG('████')}              ${textG('████  ████  ████  ████    ██        ██          ██  ')}`,
+    // Line 3
+    `  ${leftG('████')}    ${leftG('████')}                  ${rightG('████')}    ${rightG('████')}            ${textG('██ ████ ██  ██ ████ ██    ██        ██          ██  ')}`,
+    // Line 4
+    `${leftG('████')}    ${leftG('████')}          ${dotG('██')}          ${rightG('████')}    ${rightG('████')}          ${textG('██  ██  ██  ██  ██  ██    ██        ██          ██  ')}`,
+    // Line 5
+    `  ${leftG('████')}    ${leftG('████')}                  ${rightG('████')}    ${rightG('████')}            ${textG('██      ██  ██      ██    ██        ██          ██  ')}`,
+    // Line 6
+    `    ${leftG('████')}    ${leftG('████')}              ${rightG('████')}    ${rightG('████')}              ${textG('██      ██  ██      ██    ██        ██          ██  ')}`,
+    // Line 7
+    `      ${leftG('████')}    ${leftG('████')}          ${rightG('████')}    ${rightG('████')}                ${textG('██      ██  ██      ██    ████████  ██████████  ██████')}`,
+].join('\n');
 export function printLogo() {
-    console.log(pc.bold(LOGO));
+    console.log('\n' + LOGO + '\n');
 }
+import pc from 'picocolors';
+// Override picocolors cyan globally to use our custom hex brand color for the entire UI
+const customCyan = (text) => `\x1b[38;2;0;82;255m${text}\x1b[0m`;
+const customBgCyan = (text) => `\x1b[48;2;0;82;255m${text}\x1b[0m`;
+pc.cyan = customCyan;
+pc.bgCyan = customBgCyan;
+export const brandBg = (text) => `\x1b[48;2;0;82;255m${pc.black(text)}\x1b[0m`;
+export const brandFg = customCyan;

package/dist/utils/paste.d.ts

@@ -1 +1,22 @@
+/**
+ * Reads multi-line content from the standard input (stdin) stream.
+ *
+ * This function utilizes the `node:readline` module to collect input line-by-line
+ * in an interactive environment. It is designed to capture large blocks of text
+ * pasted into the terminal by a user.
+ *
+ * ### Behavior:
+ * - Aggregates all incoming lines into an internal array.
+ * - Trims leading and trailing whitespace from the final joined result upon `EOF` (End of File).
+ * - Gracefully handles `SIGINT` (e.g., Ctrl+C) by canceling the collection process
+ *   and returning `null`, preventing process termination if undesired.
+ *
+ * ### Usage:
+ * Useful for scenarios where a CLI tool requires the user to provide a text
+ * payload that is too large or inconvenient to pass via a simple CLI argument.
+ *
+ * @returns {Promise<string | null>} A promise that resolves to:
+ * - A `string` containing the complete, trimmed input content upon successful stream completion.
+ * - `null` if the user interrupts the operation using `SIGINT`.
+ */
 export declare function readPaste(): Promise<string | null>;

package/dist/utils/paste.js

@@ -1,10 +1,31 @@
 import * as readline from 'node:readline';
+/**
+ * Reads multi-line content from the standard input (stdin) stream.
+ *
+ * This function utilizes the `node:readline` module to collect input line-by-line
+ * in an interactive environment. It is designed to capture large blocks of text
+ * pasted into the terminal by a user.
+ *
+ * ### Behavior:
+ * - Aggregates all incoming lines into an internal array.
+ * - Trims leading and trailing whitespace from the final joined result upon `EOF` (End of File).
+ * - Gracefully handles `SIGINT` (e.g., Ctrl+C) by canceling the collection process
+ *   and returning `null`, preventing process termination if undesired.
+ *
+ * ### Usage:
+ * Useful for scenarios where a CLI tool requires the user to provide a text
+ * payload that is too large or inconvenient to pass via a simple CLI argument.
+ *
+ * @returns {Promise<string | null>} A promise that resolves to:
+ * - A `string` containing the complete, trimmed input content upon successful stream completion.
+ * - `null` if the user interrupts the operation using `SIGINT`.
+ */
 export async function readPaste() {
     return new Promise((resolve) => {
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
-            terminal: true
+            terminal: true,
         });
         const content = [];
         let isCanceled = false;

package/dist/utils/profiles.d.ts

@@ -0,0 +1,2 @@
+import { LanguageProfile } from './types.js';
+export declare const LANGUAGE_PROFILES: LanguageProfile[];

package/dist/utils/profiles.js

@@ -0,0 +1,44 @@
+export const LANGUAGE_PROFILES = [
+    {
+        extensions: ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.mts', '.cts'],
+        patterns: [
+            /import\s+(?:[\s\S]*?\s+from\s+)?['"](?<specifier>[^'"]+)['"]/gm,
+            /import\s*\(\s*['"](?<specifier>[^'"]+)['"]\s*\)/gm,
+            /require\s*\(\s*['"](?<specifier>[^'"]+)['"]\s*\)/gm,
+            /export\s+(?:[\s\S]*?\s+from\s+)['"](?<specifier>[^'"]+)['"]/gm,
+        ],
+    },
+    {
+        extensions: ['.py'],
+        patterns: [
+            /^from\s+(?<specifier>[^\s]+)\s+import\s/gm,
+            /^import\s+(?!.*\sfrom\s)(?<specifier>[^\s,]+)/gm,
+        ],
+        normalizeSpecifier: (spec) => {
+            if (spec.startsWith('.')) {
+                const dots = spec.match(/^\.+/)[0];
+                const rest = spec.slice(dots.length);
+                const prefix = dots.length === 1 ? './' : '../'.repeat(dots.length - 1);
+                return rest ? `${prefix}${rest.replace(/\./g, '/')}.py` : prefix.slice(0, -1);
+            }
+            return spec.replace(/\./g, '/') + '.py';
+        },
+    },
+    {
+        extensions: ['.rs'],
+        patterns: [
+            /use\s+(?<specifier>(?:crate|self|super)(?:::[a-zA-Z_][a-zA-Z0-9_]*)+)/gm,
+            /mod\s+(?<specifier>[a-zA-Z_][a-zA-Z0-9_]*)\s*;/gm,
+        ],
+        normalizeSpecifier: (spec, sourceFile) => {
+            if (!spec.includes('::')) {
+                return spec + '.rs';
+            }
+            const parts = spec
+                .replace(/^crate::/, '')
+                .replace(/^(self|super)::/, '')
+                .split('::');
+            return parts.join('/') + '.rs';
+        },
+    }
+];

package/dist/utils/projectStorage.js

@@ -14,13 +14,16 @@ export function getProjectStorageDir(workspaceRoot) {
  */
 export function ensureProjectStorage(workspaceRoot) {
     const storageDir = getProjectStorageDir(workspaceRoot);
-    if (!fs.existsSync(storageDir)) {
-        try {
-            fs.mkdirSync(storageDir, { recursive: true });
-        }
-        catch (err) {
-            // Non-fatal error, CLI can proceed without cache if permissions fail
-            console.warn(pc.yellow(`Failed to create .minovativemind directory: ${err instanceof Error ? err.message : String(err)}`));
+    const embeddingsDir = path.join(storageDir, 'embeddings');
+    for (const dir of [storageDir, embeddingsDir]) {
+        if (!fs.existsSync(dir)) {
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            catch (err) {
+                // Non-fatal error, CLI can proceed without cache if permissions fail
+                console.warn(pc.yellow(`Failed to create directory: ${err instanceof Error ? err.message : String(err)}`));
+            }
         }
     }
 }