minovative-mind-cli 1.0.0

package/dist/services/verificationService.js

@@ -0,0 +1,148 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+export async function detectVerificationCommand(workspaceRoot) {
+    try {
+        const pkgJsonPath = path.join(workspaceRoot, 'package.json');
+        const pkgJsonStr = await fs.readFile(pkgJsonPath, 'utf-8');
+        const pkgJson = JSON.parse(pkgJsonStr);
+        if (pkgJson.scripts) {
+            if (pkgJson.scripts.build)
+                return 'npm run build';
+            if (pkgJson.scripts.typecheck)
+                return 'npm run typecheck';
+            if (pkgJson.scripts.lint)
+                return 'npm run lint';
+            if (pkgJson.scripts.check)
+                return 'npm run check';
+        }
+    }
+    catch {
+        // not a node project or no package.json
+    }
+    try {
+        await fs.access(path.join(workspaceRoot, 'Makefile'));
+        return 'make check';
+    }
+    catch { }
+    try {
+        await fs.access(path.join(workspaceRoot, 'Cargo.toml'));
+        return 'cargo check';
+    }
+    catch { }
+    return null;
+}
+export async function runVerification(workspaceRoot) {
+    const command = await detectVerificationCommand(workspaceRoot);
+    if (!command)
+        return null;
+    const MAX_VERIFY_OUTPUT = 20_000; // 20KB cap on verification output
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            cwd: workspaceRoot,
+            timeout: 90_000, // 90s (1 min & 30 secs) - builds can take a while (e.g., Next.js)
+            maxBuffer: 1024 * 1024, // 1 MB buffer
+        });
+        return {
+            success: true,
+            command,
+            output: stdout.length > MAX_VERIFY_OUTPUT ? stdout.substring(0, MAX_VERIFY_OUTPUT) + '\n... (truncated)' : stdout,
+            errors: [],
+        };
+    }
+    catch (err) {
+        const rawStdout = (err.stdout || '').substring(0, MAX_VERIFY_OUTPUT);
+        const rawStderr = (err.stderr || '').substring(0, MAX_VERIFY_OUTPUT);
+        const output = rawStdout + '\n' + rawStderr;
+        const lines = output.split('\n');
+        // Extract error lines with context
+        const errors = [];
+        let capturingError = false;
+        for (const line of lines) {
+            const lower = line.toLowerCase();
+            if (lower.includes('error') || lower.includes('err!')) {
+                capturingError = true;
+                errors.push(line);
+            }
+            else if (capturingError) {
+                if (line.trim() === '' || lower.includes('warning') || lower.includes('info')) {
+                    capturingError = false;
+                }
+                else {
+                    errors.push(line);
+                }
+            }
+        }
+        return {
+            success: false,
+            command,
+            output,
+            errors: errors.slice(0, 30), // limit to 30 error lines for the model
+        };
+    }
+}
+export function formatVerificationForModel(result) {
+    return `The following verification errors were detected after your changes:
+
+Command: ${result.command}
+
+Errors:
+${result.errors.join('\n')}
+
+Please fix these errors using the modify_file tool.`;
+}
+export async function verifyChangedFiles(workspaceRoot, filePaths) {
+    if (filePaths.length === 0)
+        return null;
+    const errors = [];
+    const tryExec = async (cmd, files, isEslint = false) => {
+        if (files.length === 0)
+            return;
+        const chunkedFiles = files.map((f) => `"${f}"`).join(' ');
+        const fullCmd = `${cmd} ${chunkedFiles}`;
+        try {
+            await execAsync(fullCmd, { cwd: workspaceRoot, timeout: 15_000 });
+        }
+        catch (err) {
+            const out = (err.stdout || '') + '\n' + (err.stderr || '');
+            const lowerOut = out.toLowerCase();
+            // Ignore if the linter command is missing, or if ESLint simply skipped the file because it is in .eslintignore
+            if (lowerOut.includes('command not found') ||
+                lowerOut.includes('enoent') ||
+                lowerOut.includes('not recognized') ||
+                lowerOut.includes('could not determine executable to run') ||
+                lowerOut.includes('file ignored because of a matching ignore pattern') ||
+                err.code === 127) {
+                return;
+            }
+            let errorMsg = `[${cmd} Error]\n${out.trim().substring(0, 5000)}`;
+            // Intercept ESLint fatal crashes
+            if (isEslint && out.includes('Oops! Something went wrong! :(')) {
+                return;
+            }
+            errors.push(errorMsg);
+        }
+    };
+    // Group by language
+    const jsFiles = filePaths.filter((f) => /\.(js|jsx|ts|tsx)$/.test(f));
+    const pyFiles = filePaths.filter((f) => f.endsWith('.py'));
+    const rsFiles = filePaths.filter((f) => f.endsWith('.rs'));
+    const goFiles = filePaths.filter((f) => f.endsWith('.go'));
+    // JS/TS: Use npx --no -- to prevent npm from intercepting eslint flags. Use --quiet to only report errors.
+    await tryExec('npx --no -- eslint --quiet', jsFiles, true);
+    // Python
+    await tryExec('flake8', pyFiles);
+    // Rust (rustfmt is usually global if cargo is available)
+    await tryExec('rustfmt --check', rsFiles);
+    // Go
+    await tryExec('go vet', goFiles);
+    // Project-level build check (e.g., npm run build)
+    const buildResult = await runVerification(workspaceRoot);
+    if (buildResult && !buildResult.success) {
+        const buildErrorMsg = `[Build Error: ${buildResult.command}]\n${buildResult.errors.join('\n').substring(0, 5000)}`;
+        errors.push(buildErrorMsg);
+    }
+    return errors.length > 0 ? errors.join('\n\n---\n\n') : null;
+}

package/dist/utils/atomicWrite.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Writes data to a file atomically by writing to a temporary file first,
+ * then renaming the temporary file to the target path.
+ * This prevents file corruption if the process crashes during a write operation.
+ */
+export declare function atomicWriteFile(targetPath: string, data: string, encoding?: BufferEncoding): Promise<void>;

package/dist/utils/atomicWrite.js

@@ -0,0 +1,29 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+/**
+ * Writes data to a file atomically by writing to a temporary file first,
+ * then renaming the temporary file to the target path.
+ * This prevents file corruption if the process crashes during a write operation.
+ */
+export async function atomicWriteFile(targetPath, data, encoding = 'utf-8') {
+    const dir = path.dirname(targetPath);
+    const tempPath = path.join(dir, `.${path.basename(targetPath)}.${Date.now()}.tmp`);
+    try {
+        // Ensure the directory exists
+        await fs.mkdir(dir, { recursive: true });
+        // Write to the temporary file
+        await fs.writeFile(tempPath, data, encoding);
+        // Atomically rename it over the target file
+        await fs.rename(tempPath, targetPath);
+    }
+    catch (error) {
+        // Clean up temp file on failure if it exists
+        try {
+            await fs.unlink(tempPath);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        throw error;
+    }
+}

package/dist/utils/config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Firebase configuration for Minovative Mind production backend.
+ */
+export declare const FIREBASE_API_KEY = "AIzaSyAFqOlkNO3uFGYO1kaEBGEFD9CXLt0mnIs";
+export declare const GITHUB_CLIENT_ID = "Ov23linFYFfjO3JILG7r";
+export declare const GEMINI_MODELS: {
+    readonly FLASH_PRO: "gemini-2.5-pro";
+    readonly FLASH_LATEST: "gemini-2.5-flash";
+};
+export declare const CLAUDE_MODELS: {
+    readonly OPUS: "claude-opus-4-6";
+    readonly SONNET: "claude-sonnet-4-6";
+};
+/** Default Gemini model for the coding agent. */
+export declare const DEFAULT_MODEL: "gemini-2.5-flash";
+/** Maximum tokens the model can output per response. */
+export declare const MAX_OUTPUT_TOKENS = 65000;

package/dist/utils/config.js

@@ -0,0 +1,17 @@
+/**
+ * Firebase configuration for Minovative Mind production backend.
+ */
+export const FIREBASE_API_KEY = 'AIzaSyAFqOlkNO3uFGYO1kaEBGEFD9CXLt0mnIs';
+export const GITHUB_CLIENT_ID = 'Ov23linFYFfjO3JILG7r';
+export const GEMINI_MODELS = {
+    FLASH_PRO: 'gemini-2.5-pro',
+    FLASH_LATEST: 'gemini-2.5-flash',
+};
+export const CLAUDE_MODELS = {
+    OPUS: 'claude-opus-4-6',
+    SONNET: 'claude-sonnet-4-6',
+};
+/** Default Gemini model for the coding agent. */
+export const DEFAULT_MODEL = GEMINI_MODELS.FLASH_LATEST;
+/** Maximum tokens the model can output per response. */
+export const MAX_OUTPUT_TOKENS = 65_000;

package/dist/utils/contextPrompts.d.ts

@@ -0,0 +1,3 @@
+import { ContextAgentResult } from '../services/contextAgent.js';
+export declare function sanitizeForCDATA(content: string): string;
+export declare function buildContextInjection(context: ContextAgentResult): string;

package/dist/utils/contextPrompts.js

@@ -0,0 +1,34 @@
+export function sanitizeForCDATA(content) {
+    // Prevent CDATA breakout by escaping ]]>
+    return content.replace(/\]\]>/g, ']]\\\\u200B>');
+}
+export function buildContextInjection(context) {
+    let injection = `<project_context>
+## Project Profile
+${context.projectType}
+
+## Project Structure
+${context.projectTree}
+
+## Investigation Summary
+${context.summary}
+`;
+    if (context.webSearchSummary) {
+        injection += `
+## Web Search Findings
+${context.webSearchSummary}
+`;
+    }
+    if (context.relevantFiles.size > 0) {
+        injection += `\n## Relevant File Contents\n`;
+        for (const [filePath, content] of context.relevantFiles.entries()) {
+            injection += `<workspace_file path="${filePath}">
+<content_data><![CDATA[
+${sanitizeForCDATA(content)}
+]]></content_data>
+</workspace_file>\n`;
+        }
+    }
+    injection += `</project_context>`;
+    return injection;
+}

package/dist/utils/dependencyTracer.d.ts

@@ -0,0 +1,48 @@
+export interface DependencyNode {
+    /** Files this file directly imports (forward/downstream) */
+    imports: Set<string>;
+    /** Files that directly import this file (reverse/upstream) */
+    importedBy: Set<string>;
+}
+export interface DependencyGraph {
+    /** What files does `filePath` directly import? */
+    getImports(filePath: string): string[];
+    /** What files directly import `filePath`? (who breaks if this changes?) */
+    getImportedBy(filePath: string): string[];
+    /** Transitive: all files reachable via importedBy chains, up to maxDepth */
+    getReverseDependencyTree(filePath: string, maxDepth?: number): string[];
+    /** Transitive: all files reachable via import chains, up to maxDepth */
+    getForwardDependencyTree(filePath: string, maxDepth?: number): string[];
+    /** The full raw graph for inspection */
+    readonly nodes: ReadonlyMap<string, DependencyNode>;
+}
+/**
+ * Builds a complete bidirectional dependency graph of the workspace.
+ *
+ * Performance: This is pure regex + filesystem walking — no AST parsing.
+ * For a typical project (<5,000 source files), this completes in <1s.
+ * The graph is ephemeral: built once per `gatherContext` call and discarded.
+ */
+export declare function buildDependencyGraph(workspaceRoot: string): Promise<DependencyGraph>;
+export interface FindDependenciesResult {
+    filePath: string;
+    forwardDeps: string[];
+    reverseDeps: string[];
+    forwardTree: string[];
+    reverseTree: string[];
+}
+/**
+ * High-level function exposed as a tool to the agents.
+ * Builds the dependency graph (or reuses if already built in this invocation),
+ * then queries it for the specified file.
+ */
+export declare function findDependencies(workspaceRoot: string, filePath: string, direction?: 'both' | 'forward' | 'reverse', maxDepth?: number): Promise<FindDependenciesResult>;
+/**
+ * Formats a FindDependenciesResult into a human-readable string
+ * suitable for feeding back to the LLM.
+ */
+export declare function formatDependencyResult(result: FindDependenciesResult): string;
+/**
+ * Resets the tsconfig alias cache (useful between workspace changes).
+ */
+export declare function resetAliasCache(): void;