minovative-mind-cli 2.10.0 → 2.11.2

package/dist/services/userProfileService.d.ts

@@ -0,0 +1,97 @@
+/**
+ * @file userProfileService.ts
+ * @description Global Adaptive User Profile & Persona Memory Bank service for Minovative Mind CLI.
+ *
+ * Persists learned user traits, communication preferences, idea formulation styles, and agent observations
+ * globally at `~/.minovativemind/user_profile.json`.
+ *
+ * Features:
+ * - Zero-latency, non-blocking asynchronous insight extraction via `gemini-3.5-flash-lite`.
+ * - Bounded memory management (capped at 25 side-notes max) and atomic write operations.
+ * - Dynamic XML/Markdown prompt context formatting for real-time personalization.
+ * - Full transparency and data control for the user via `/profile` slash command.
+ */
+/**
+ * Communication style traits observed by the agent.
+ */
+export interface UserProfileCommunicationStyle {
+    tonePreference?: string;
+    verbosity?: string;
+    formulationStyle?: string;
+}
+/**
+ * Cognitive problem-solving, collaboration, and decision-making traits observed by the agent.
+ */
+export interface UserProfileCognitiveTraits {
+    architecturalStyle?: string;
+    decisionPreference?: string;
+    riskTolerance?: string;
+    delegationDepth?: string;
+    debuggingStyle?: string;
+    explanationFormat?: string;
+}
+/**
+ * Technical habits and technology strengths observed by the agent.
+ */
+export interface UserProfileTechnicalPreferences {
+    strengths?: string[];
+    conventions?: string[];
+}
+/**
+ * Global User Profile representation.
+ */
+export interface UserProfile {
+    communicationStyle?: UserProfileCommunicationStyle;
+    cognitiveTraits?: UserProfileCognitiveTraits;
+    technicalPreferences?: UserProfileTechnicalPreferences;
+    agentNotes: string[];
+    lastUpdated?: number;
+}
+/** Maximum number of side-notes retained to prevent unbounded memory growth */
+export declare const MAX_AGENT_SIDE_NOTES = 25;
+/** Global directory path for .minovativemind data */
+export declare function getGlobalMinovativeMindDir(): string;
+/** Global file path for user_profile.json */
+export declare function getUserProfilePath(): string;
+/**
+ * Ensures that the global ~/.minovativemind directory exists with safe permissions.
+ */
+export declare function ensureGlobalStorage(): void;
+/**
+ * Loads the user profile from disk or returns a fresh default structure.
+ */
+export declare function loadUserProfile(): Promise<UserProfile>;
+/**
+ * Saves the user profile to disk using atomic temporary file write pattern.
+ */
+export declare function saveUserProfile(profile: UserProfile): Promise<void>;
+/**
+ * Deletes a specific side-note by index.
+ *
+ * @param index - The 0-based index of the side note to remove.
+ * @returns Promise resolving to true if deleted, false if index out of bounds.
+ */
+export declare function deleteSideNote(index: number): Promise<boolean>;
+/**
+ * Clears the user profile memory and all AI-generated side-notes.
+ */
+export declare function clearUserProfile(): Promise<void>;
+/**
+ * Formats the user profile into a lightweight prompt context injection string (<user_profile> block).
+ * Returns empty string if no meaningful profile traits or notes exist yet.
+ */
+export declare function formatUserProfileForContext(profile: UserProfile): string;
+/**
+ * Uses a dedicated Flash-Lite classifier agent with structured JSON output
+ * to determine whether a turn is trivial/low-signal (greetings, affirmations, confirmations, terminal commands)
+ * or contains substantive personal/technical traits.
+ */
+export declare function classifyTurnSignal(userPrompt: string, aiResponse: string, abortSignal?: AbortSignal): Promise<{
+    isTrivial: boolean;
+    reason?: string;
+}>;
+/**
+ * Analyzes dialogue from a completed turn using Flash-Lite to extract subtle user observations
+ * and update the persistent global user profile in the background.
+ */
+export declare function extractAndSaveUserInsights(userPrompt: string, aiResponse: string, abortSignal?: AbortSignal): Promise<UserProfile | null>;

package/dist/services/userProfileService.js

@@ -0,0 +1,410 @@
+/**
+ * @file userProfileService.ts
+ * @description Global Adaptive User Profile & Persona Memory Bank service for Minovative Mind CLI.
+ *
+ * Persists learned user traits, communication preferences, idea formulation styles, and agent observations
+ * globally at `~/.minovativemind/user_profile.json`.
+ *
+ * Features:
+ * - Zero-latency, non-blocking asynchronous insight extraction via `gemini-3.5-flash-lite`.
+ * - Bounded memory management (capped at 25 side-notes max) and atomic write operations.
+ * - Dynamic XML/Markdown prompt context formatting for real-time personalization.
+ * - Full transparency and data control for the user via `/profile` slash command.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { debugLog } from '../utils/logger.js';
+import { createUserProfileExtractorSession, createTrivialMessageClassifierSession, } from './ai.js';
+/** Maximum number of side-notes retained to prevent unbounded memory growth */
+export const MAX_AGENT_SIDE_NOTES = 25;
+/** Global directory path for .minovativemind data */
+export function getGlobalMinovativeMindDir() {
+    return path.join(os.homedir(), '.minovativemind');
+}
+/** Global file path for user_profile.json */
+export function getUserProfilePath() {
+    return path.join(getGlobalMinovativeMindDir(), 'user_profile.json');
+}
+/**
+ * Ensures that the global ~/.minovativemind directory exists with safe permissions.
+ */
+export function ensureGlobalStorage() {
+    const globalDir = getGlobalMinovativeMindDir();
+    if (!fs.existsSync(globalDir)) {
+        try {
+            fs.mkdirSync(globalDir, { recursive: true, mode: 0o700 });
+        }
+        catch (err) {
+            debugLog(`Failed to create global directory ${globalDir}: ${err}`);
+        }
+    }
+}
+/**
+ * Loads the user profile from disk or returns a fresh default structure.
+ */
+export async function loadUserProfile() {
+    ensureGlobalStorage();
+    const profilePath = getUserProfilePath();
+    if (!fs.existsSync(profilePath)) {
+        return {
+            communicationStyle: {},
+            cognitiveTraits: {},
+            technicalPreferences: { strengths: [], conventions: [] },
+            agentNotes: [],
+            lastUpdated: Date.now(),
+        };
+    }
+    try {
+        const raw = await fs.promises.readFile(profilePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return {
+            communicationStyle: parsed.communicationStyle || {},
+            cognitiveTraits: parsed.cognitiveTraits || {},
+            technicalPreferences: {
+                strengths: Array.isArray(parsed.technicalPreferences?.strengths) ? parsed.technicalPreferences.strengths : [],
+                conventions: Array.isArray(parsed.technicalPreferences?.conventions)
+                    ? parsed.technicalPreferences.conventions
+                    : [],
+            },
+            agentNotes: Array.isArray(parsed.agentNotes) ? parsed.agentNotes : [],
+            lastUpdated: parsed.lastUpdated || Date.now(),
+        };
+    }
+    catch (err) {
+        debugLog(`Failed to read user profile: ${err}`);
+        return {
+            communicationStyle: {},
+            cognitiveTraits: {},
+            technicalPreferences: { strengths: [], conventions: [] },
+            agentNotes: [],
+            lastUpdated: Date.now(),
+        };
+    }
+}
+/**
+ * Saves the user profile to disk using atomic temporary file write pattern.
+ */
+export async function saveUserProfile(profile) {
+    ensureGlobalStorage();
+    const profilePath = getUserProfilePath();
+    const tempPath = `${profilePath}.tmp.${Date.now()}`;
+    profile.lastUpdated = Date.now();
+    // Ensure side-notes do not exceed maximum cap
+    if (profile.agentNotes.length > MAX_AGENT_SIDE_NOTES) {
+        profile.agentNotes = profile.agentNotes.slice(-MAX_AGENT_SIDE_NOTES);
+    }
+    const payload = JSON.stringify(profile, null, 2);
+    try {
+        await fs.promises.writeFile(tempPath, payload, { encoding: 'utf-8', mode: 0o600 });
+        await fs.promises.rename(tempPath, profilePath);
+        debugLog(`User profile saved successfully to ${profilePath}`);
+    }
+    catch (err) {
+        debugLog(`Failed to save user profile: ${err}`);
+        if (fs.existsSync(tempPath)) {
+            try {
+                await fs.promises.unlink(tempPath);
+            }
+            catch {
+                // ignore cleanup error
+            }
+        }
+    }
+}
+/**
+ * Deletes a specific side-note by index.
+ *
+ * @param index - The 0-based index of the side note to remove.
+ * @returns Promise resolving to true if deleted, false if index out of bounds.
+ */
+export async function deleteSideNote(index) {
+    const profile = await loadUserProfile();
+    if (index < 0 || index >= profile.agentNotes.length) {
+        return false;
+    }
+    profile.agentNotes.splice(index, 1);
+    await saveUserProfile(profile);
+    return true;
+}
+/**
+ * Clears the user profile memory and all AI-generated side-notes.
+ */
+export async function clearUserProfile() {
+    const emptyProfile = {
+        communicationStyle: {},
+        technicalPreferences: { strengths: [], conventions: [] },
+        agentNotes: [],
+        lastUpdated: Date.now(),
+    };
+    await saveUserProfile(emptyProfile);
+}
+/**
+ * Formats the user profile into a lightweight prompt context injection string (<user_profile> block).
+ * Returns empty string if no meaningful profile traits or notes exist yet.
+ */
+export function formatUserProfileForContext(profile) {
+    const hasStyle = profile.communicationStyle?.tonePreference ||
+        profile.communicationStyle?.verbosity ||
+        profile.communicationStyle?.formulationStyle;
+    const hasCognitive = profile.cognitiveTraits?.architecturalStyle ||
+        profile.cognitiveTraits?.decisionPreference ||
+        profile.cognitiveTraits?.riskTolerance ||
+        profile.cognitiveTraits?.delegationDepth ||
+        profile.cognitiveTraits?.debuggingStyle ||
+        profile.cognitiveTraits?.explanationFormat;
+    const hasStrengths = profile.technicalPreferences?.strengths && profile.technicalPreferences.strengths.length > 0;
+    const hasConventions = profile.technicalPreferences?.conventions && profile.technicalPreferences.conventions.length > 0;
+    const hasNotes = profile.agentNotes && profile.agentNotes.length > 0;
+    if (!hasStyle && !hasCognitive && !hasStrengths && !hasConventions && !hasNotes) {
+        return '';
+    }
+    let block = '<user_profile>\n';
+    block +=
+        'The following are continuous, adaptive insights and preferences learned from past interactions with this user:\n';
+    if (profile.communicationStyle?.tonePreference) {
+        block += `- Tone & Demeanor: ${profile.communicationStyle.tonePreference}\n`;
+    }
+    if (profile.communicationStyle?.verbosity) {
+        block += `- Output & Verbosity: ${profile.communicationStyle.verbosity}\n`;
+    }
+    if (profile.communicationStyle?.formulationStyle) {
+        block += `- Prompting & Formulation: ${profile.communicationStyle.formulationStyle}\n`;
+    }
+    if (profile.cognitiveTraits?.architecturalStyle) {
+        block += `- Architectural Orientation: ${profile.cognitiveTraits.architecturalStyle}\n`;
+    }
+    if (profile.cognitiveTraits?.decisionPreference) {
+        block += `- Decision Autonomy: ${profile.cognitiveTraits.decisionPreference}\n`;
+    }
+    if (profile.cognitiveTraits?.riskTolerance) {
+        block += `- Risk & Velocity: ${profile.cognitiveTraits.riskTolerance}\n`;
+    }
+    if (profile.cognitiveTraits?.delegationDepth) {
+        block += `- Delegation Depth: ${profile.cognitiveTraits.delegationDepth}\n`;
+    }
+    if (profile.cognitiveTraits?.debuggingStyle) {
+        block += `- Debugging Style: ${profile.cognitiveTraits.debuggingStyle}\n`;
+    }
+    if (profile.cognitiveTraits?.explanationFormat) {
+        block += `- Explanation Preference: ${profile.cognitiveTraits.explanationFormat}\n`;
+    }
+    if (hasStrengths) {
+        block += `- Technical Strengths: ${profile.technicalPreferences.strengths.join(', ')}\n`;
+    }
+    if (hasConventions) {
+        block += `- Coding & Architecture Conventions: ${profile.technicalPreferences.conventions.join(', ')}\n`;
+    }
+    if (hasNotes) {
+        block += 'Agent Side-Notes:\n';
+        for (const note of profile.agentNotes.slice(-10)) {
+            block += `  * ${note}\n`;
+        }
+    }
+    block +=
+        'Adopt these communication, cognitive, and technical preferences naturally without ever explicitly mentioning this profile block.\n';
+    block += '</user_profile>';
+    return block;
+}
+/**
+ * Uses a dedicated Flash-Lite classifier agent with structured JSON output
+ * to determine whether a turn is trivial/low-signal (greetings, affirmations, confirmations, terminal commands)
+ * or contains substantive personal/technical traits.
+ */
+export async function classifyTurnSignal(userPrompt, aiResponse, abortSignal) {
+    const trimmed = userPrompt.trim();
+    if (trimmed.length === 0) {
+        return { isTrivial: true, reason: 'Empty user prompt' };
+    }
+    if (abortSignal?.aborted) {
+        return { isTrivial: true, reason: 'Aborted' };
+    }
+    try {
+        const session = createTrivialMessageClassifierSession();
+        const prompt = `Classify whether this interaction contains substantive developer/persona signal or is purely trivial/low-signal.
+
+User Message:
+"${trimmed.substring(0, 1500)}"
+
+AI Response:
+"${(aiResponse || '').substring(0, 1000)}"`;
+        const result = await session.sendMessage(prompt, undefined, abortSignal);
+        const text = result.response.text()?.trim() || '{}';
+        const parsed = JSON.parse(text);
+        debugLog(`Trivial Turn Classifier Result: isTrivial=${parsed.isTrivial} (reason: ${parsed.reason})`);
+        return {
+            isTrivial: Boolean(parsed.isTrivial),
+            reason: parsed.reason,
+        };
+    }
+    catch (err) {
+        debugLog(`Trivial Turn Classifier failed, defaulting to false: ${err}`);
+        return { isTrivial: false };
+    }
+}
+/**
+ * Analyzes dialogue from a completed turn using Flash-Lite to extract subtle user observations
+ * and update the persistent global user profile in the background.
+ */
+export async function extractAndSaveUserInsights(userPrompt, aiResponse, abortSignal) {
+    if (!userPrompt || userPrompt.trim().length === 0 || !aiResponse || aiResponse.length < 20) {
+        return null;
+    }
+    if (abortSignal?.aborted) {
+        return null;
+    }
+    // Evaluate with dedicated Flash-Lite Trivial Turn Classifier Agent
+    const classification = await classifyTurnSignal(userPrompt, aiResponse, abortSignal);
+    if (classification.isTrivial) {
+        debugLog(`Skipping profile extraction for trivial turn: ${classification.reason || 'low-signal'}`);
+        return null;
+    }
+    try {
+        const currentProfile = await loadUserProfile();
+        const session = createUserProfileExtractorSession();
+        const existingNotesText = currentProfile.agentNotes.length > 0
+            ? currentProfile.agentNotes.map((n, idx) => `[${idx}] ${n}`).join('\n')
+            : 'None recorded yet.';
+        const prompt = `Analyze the following interaction to observe the user's communication style, personality, thought formulation, and technical habits.
+Review the existing numbered side-notes. If any new statement or habit contradicts, supersedes, or invalidates an existing note, specify its index in "deleteNoteIndices" or "updateNotes".
+
+Existing Agent Side-Notes:
+${existingNotesText}
+
+User Message:
+"${userPrompt.substring(0, 3000)}"
+
+AI Response Summary:
+"${aiResponse.substring(0, 1500)}"`;
+        const result = await session.sendMessage(prompt, undefined, abortSignal);
+        const text = result.response.text()?.trim() || '{}';
+        const parsed = JSON.parse(text);
+        debugLog(`User Profile Extractor Parsed: ${JSON.stringify(parsed)}`);
+        let changed = false;
+        if (parsed.tonePreference && parsed.tonePreference.trim().length > 0) {
+            currentProfile.communicationStyle = currentProfile.communicationStyle || {};
+            currentProfile.communicationStyle.tonePreference = parsed.tonePreference.trim();
+            changed = true;
+        }
+        if (parsed.verbosity && parsed.verbosity.trim().length > 0) {
+            currentProfile.communicationStyle = currentProfile.communicationStyle || {};
+            currentProfile.communicationStyle.verbosity = parsed.verbosity.trim();
+            changed = true;
+        }
+        if (parsed.formulationStyle && parsed.formulationStyle.trim().length > 0) {
+            currentProfile.communicationStyle = currentProfile.communicationStyle || {};
+            currentProfile.communicationStyle.formulationStyle = parsed.formulationStyle.trim();
+            changed = true;
+        }
+        // Process cognitive & decision-making traits
+        if (parsed.cognitiveTraits && typeof parsed.cognitiveTraits === 'object') {
+            currentProfile.cognitiveTraits = currentProfile.cognitiveTraits || {};
+            const keys = [
+                'architecturalStyle',
+                'decisionPreference',
+                'riskTolerance',
+                'delegationDepth',
+                'debuggingStyle',
+                'explanationFormat',
+            ];
+            for (const k of keys) {
+                if (typeof parsed.cognitiveTraits[k] === 'string' && parsed.cognitiveTraits[k].trim().length > 0) {
+                    currentProfile.cognitiveTraits[k] = parsed.cognitiveTraits[k].trim();
+                    changed = true;
+                }
+            }
+        }
+        if (Array.isArray(parsed.strengths) && parsed.strengths.length > 0) {
+            currentProfile.technicalPreferences = currentProfile.technicalPreferences || { strengths: [], conventions: [] };
+            const existing = new Set(currentProfile.technicalPreferences.strengths || []);
+            for (const s of parsed.strengths) {
+                if (typeof s === 'string' && s.trim().length > 0) {
+                    existing.add(s.trim());
+                    changed = true;
+                }
+            }
+            currentProfile.technicalPreferences.strengths = Array.from(existing).slice(0, 15);
+        }
+        if (Array.isArray(parsed.removeStrengths) && parsed.removeStrengths.length > 0) {
+            if (currentProfile.technicalPreferences?.strengths) {
+                const toRemove = new Set(parsed.removeStrengths.map((s) => s.toLowerCase().trim()));
+                const filtered = currentProfile.technicalPreferences.strengths.filter((s) => !toRemove.has(s.toLowerCase().trim()));
+                if (filtered.length !== currentProfile.technicalPreferences.strengths.length) {
+                    currentProfile.technicalPreferences.strengths = filtered;
+                    changed = true;
+                }
+            }
+        }
+        if (Array.isArray(parsed.conventions) && parsed.conventions.length > 0) {
+            currentProfile.technicalPreferences = currentProfile.technicalPreferences || { strengths: [], conventions: [] };
+            const existing = new Set(currentProfile.technicalPreferences.conventions || []);
+            for (const c of parsed.conventions) {
+                if (typeof c === 'string' && c.trim().length > 0) {
+                    existing.add(c.trim());
+                    changed = true;
+                }
+            }
+            currentProfile.technicalPreferences.conventions = Array.from(existing).slice(0, 15);
+        }
+        if (Array.isArray(parsed.removeConventions) && parsed.removeConventions.length > 0) {
+            if (currentProfile.technicalPreferences?.conventions) {
+                const toRemove = new Set(parsed.removeConventions.map((c) => c.toLowerCase().trim()));
+                const filtered = currentProfile.technicalPreferences.conventions.filter((c) => !toRemove.has(c.toLowerCase().trim()));
+                if (filtered.length !== currentProfile.technicalPreferences.conventions.length) {
+                    currentProfile.technicalPreferences.conventions = filtered;
+                    changed = true;
+                }
+            }
+        }
+        // Process targeted deletions of outdated/contradicted notes (in descending order)
+        if (Array.isArray(parsed.deleteNoteIndices) && parsed.deleteNoteIndices.length > 0) {
+            const validIndices = parsed.deleteNoteIndices
+                .filter((idx) => typeof idx === 'number' && idx >= 0 && idx < currentProfile.agentNotes.length)
+                .sort((a, b) => b - a);
+            for (const idx of validIndices) {
+                currentProfile.agentNotes.splice(idx, 1);
+                changed = true;
+            }
+        }
+        // Process targeted updates to existing notes
+        if (Array.isArray(parsed.updateNotes) && parsed.updateNotes.length > 0) {
+            for (const item of parsed.updateNotes) {
+                if (typeof item?.index === 'number' &&
+                    item.index >= 0 &&
+                    item.index < currentProfile.agentNotes.length &&
+                    typeof item?.updatedText === 'string' &&
+                    item.updatedText.trim().length > 0) {
+                    currentProfile.agentNotes[item.index] = item.updatedText.trim();
+                    changed = true;
+                }
+            }
+        }
+        // Process newly added side-notes
+        const notesToAdd = Array.isArray(parsed.addNotes)
+            ? parsed.addNotes
+            : Array.isArray(parsed.newSideNotes)
+                ? parsed.newSideNotes
+                : [];
+        if (notesToAdd.length > 0) {
+            for (const note of notesToAdd) {
+                if (typeof note === 'string' && note.trim().length > 0) {
+                    const cleanNote = note.trim();
+                    // Avoid duplicate or near-identical notes
+                    if (!currentProfile.agentNotes.some((existing) => existing.toLowerCase() === cleanNote.toLowerCase())) {
+                        currentProfile.agentNotes.push(cleanNote);
+                        changed = true;
+                    }
+                }
+            }
+        }
+        if (changed) {
+            await saveUserProfile(currentProfile);
+            return currentProfile;
+        }
+        return null;
+    }
+    catch (err) {
+        debugLog(`User Profile insight extraction skipped/failed: ${err}`);
+        return null;
+    }
+}

package/dist/utils/analysisRunner.d.ts

@@ -10,6 +10,8 @@ export interface EphemeralScriptOptions {
     maxOutputChars?: number;
     /** AbortSignal to cancel execution. */
     abortSignal?: AbortSignal;
+    /** Optional custom environment variables to merge into execution environment. */
+    env?: Record<string, string>;
 }
 export interface PropertyTestConfig {
     numRuns?: number;
@@ -23,10 +25,37 @@ export interface PropertyTestResult extends EphemeralScriptResult {
     seed?: number;
     numRunsCompleted?: number;
 }
+/** Supported canonical language names list. */
+export declare const SUPPORTED_LANGUAGES: readonly ["node", "ts-node", "python", "bash", "go", "rust", "c", "cpp", "ruby", "php", "java"];
+export type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
 /**
  * Normalizes user/AI provided language string to a standard runtime identifier.
  */
 export declare function normalizeLanguage(lang: string): string;
+/**
+ * Detects programming language heuristic markers directly from script source code syntax.
+ * Useful when language is omitted or set to 'auto'.
+ *
+ * @param code - The source code to analyze.
+ * @returns Detected runtime identifier (e.g., 'python', 'rust', 'go', 'cpp', 'c', 'bash', 'ruby', 'php', 'java', 'ts-node', 'node').
+ */
+export declare function detectLanguageFromCode(code: string): string;
+/**
+ * Detects the dominant programming language / runtime for a workspace based on project manifest files.
+ *
+ * @param workspaceRoot - Path to the workspace root directory.
+ * @returns Detected runtime identifier (e.g., 'rust', 'go', 'python', 'cpp', 'ts-node', 'node').
+ */
+export declare function detectProjectRuntime(workspaceRoot: string): Promise<string>;
+/**
+ * Resolves the effective runtime language by combining explicit language input,
+ * source code syntax heuristics, and workspace project manifests.
+ *
+ * @param workspaceRoot - Path to workspace root directory.
+ * @param language - Optional language parameter passed by user/agent.
+ * @param code - Optional source code string to inspect.
+ */
+export declare function resolveEffectiveRuntime(workspaceRoot: string, language?: string, code?: string): Promise<string>;
 /**
  * Detects whether the workspace package.json specifies `"type": "module"`.
  * Returns `'module'` or `'commonjs'`.