opencode-mem 2.0.1 → 2.1.1

package/dist/config.d.ts

@@ -28,6 +28,11 @@ export declare const CONFIG: {
     deduplicationEnabled: boolean;
     deduplicationSimilarityThreshold: number;
     userMemoryAnalysisInterval: number;
+    userProfileMaxPreferences: number;
+    userProfileMaxPatterns: number;
+    userProfileMaxWorkflows: number;
+    userProfileConfidenceDecayDays: number;
+    userProfileChangelogRetentionCount: number;
 };
 export declare function isConfigured(): boolean;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAmTA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;oBAwBb,aAAa,GACb,kBAAkB,GAClB,WAAW;;;;;;;;;;;;;;CAiBhB,CAAC;AAEF,wBAAgB,YAAY,IAAI,OAAO,CAEtC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AA2WA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;oBAwBb,aAAa,GACb,kBAAkB,GAClB,WAAW;;;;;;;;;;;;;;;;;;;CAyBhB,CAAC;AAEF,wBAAgB,YAAY,IAAI,OAAO,CAEtC"}

package/dist/config.js

@@ -56,6 +56,11 @@ const DEFAULTS = {
     deduplicationEnabled: true,
     deduplicationSimilarityThreshold: 0.9,
     userMemoryAnalysisInterval: 10,
+    userProfileMaxPreferences: 20,
+    userProfileMaxPatterns: 15,
+    userProfileMaxWorkflows: 10,
+    userProfileConfidenceDecayDays: 30,
+    userProfileChangelogRetentionCount: 5,
 };
 function isValidRegex(pattern) {
     try {
@@ -121,18 +126,32 @@ const CONFIG_TEMPLATE = `{
   // Web Server Settings
   // ============================================
   
+  // Enable web UI for managing memories (accessible at http://localhost:4747)
   "webServerEnabled": true,
+  
+  // Port for web UI server
   "webServerPort": 4747,
+  
+  // Host address for web UI (use 127.0.0.1 for local only, 0.0.0.0 for network access)
   "webServerHost": "127.0.0.1",
   
   // ============================================
   // Database Settings
   // ============================================
   
+  // Maximum vectors per database shard (auto-creates new shard when limit reached)
   "maxVectorsPerShard": 50000,
+  
+  // Automatically delete old memories based on retention period
   "autoCleanupEnabled": true,
+  
+  // Days to keep memories before auto-cleanup (only if autoCleanupEnabled is true)
   "autoCleanupRetentionDays": 30,
+  
+  // Automatically detect and remove duplicate memories
   "deduplicationEnabled": true,
+  
+  // Similarity threshold (0-1) for detecting duplicates (higher = stricter)
   "deduplicationSimilarityThreshold": 0.90,
   
   // ============================================
@@ -178,37 +197,69 @@ const CONFIG_TEMPLATE = `{
   //   "memoryApiUrl": "https://api.groq.com/openai/v1"
   //   "memoryApiKey": "gsk_..."
   
-  // Multi-iteration settings (for openai-responses and anthropic)
+  // Maximum iterations for multi-turn AI analysis (for openai-responses and anthropic)
   "autoCaptureMaxIterations": 5,
+  
+  // Timeout per iteration in milliseconds (30 seconds default)
   "autoCaptureIterationTimeout": 30000,
   
-  // Session management
+  // Days to keep AI session history before cleanup
   "aiSessionRetentionDays": 7,
   
   // ============================================
   // User Memory Learning
   // ============================================
   
-  // Analyze user prompts every N prompts to learn patterns and preferences
+  // Analyze user prompts every N prompts to build/update your user profile
   // When N uncaptured prompts accumulate, AI will analyze them to identify:
-  // - User preferences (code style, communication style)
-  // - User patterns (recurring topics, problem domains)
-  // - User workflows (development habits, sequences)
+  // - User preferences (code style, communication style, tool preferences)
+  // - User patterns (recurring topics, problem domains, technical interests)
+  // - User workflows (development habits, sequences, learning style)
+  // - Skill level (overall and per-domain assessment)
   "userMemoryAnalysisInterval": 10,
   
+  // Maximum number of preferences to keep in user profile (sorted by confidence)
+  // Preferences are things like "prefers code without comments", "likes concise responses"
+  "userProfileMaxPreferences": 20,
+  
+  // Maximum number of patterns to keep in user profile (sorted by frequency)
+  // Patterns are recurring topics like "often asks about database optimization"
+  "userProfileMaxPatterns": 15,
+  
+  // Maximum number of workflows to keep in user profile (sorted by frequency)
+  // Workflows are sequences like "usually asks for tests after implementation"
+  "userProfileMaxWorkflows": 10,
+  
+  // Days before preference confidence starts to decay (if not reinforced)
+  // Preferences that aren't seen again will gradually lose confidence and be removed
+  "userProfileConfidenceDecayDays": 30,
+  
+  // Number of profile versions to keep in changelog (for rollback/debugging)
+  // Older versions are automatically cleaned up
+  "userProfileChangelogRetentionCount": 5,
+  
   // ============================================
   // Search Settings
   // ============================================
   
+  // Minimum similarity score (0-1) for memory search results
   "similarityThreshold": 0.6,
+  
+  // Maximum number of user-scoped memories to return in search
   "maxMemories": 5,
+  
+  // Maximum number of project-scoped memories to return in search
   "maxProjectMemories": 10,
   
   // ============================================
   // Advanced Settings
   // ============================================
   
+  // Inject user profile into AI context (preferences, patterns, workflows)
   "injectProfile": true,
+  
+  // Additional regex patterns to trigger manual memory capture
+  // Default patterns: "remember", "memorize", "save this", "note this", etc.
   "keywordPatterns": []
 }
 `;
@@ -278,6 +329,11 @@ export const CONFIG = {
     deduplicationEnabled: fileConfig.deduplicationEnabled ?? DEFAULTS.deduplicationEnabled,
     deduplicationSimilarityThreshold: fileConfig.deduplicationSimilarityThreshold ?? DEFAULTS.deduplicationSimilarityThreshold,
     userMemoryAnalysisInterval: fileConfig.userMemoryAnalysisInterval ?? DEFAULTS.userMemoryAnalysisInterval,
+    userProfileMaxPreferences: fileConfig.userProfileMaxPreferences ?? DEFAULTS.userProfileMaxPreferences,
+    userProfileMaxPatterns: fileConfig.userProfileMaxPatterns ?? DEFAULTS.userProfileMaxPatterns,
+    userProfileMaxWorkflows: fileConfig.userProfileMaxWorkflows ?? DEFAULTS.userProfileMaxWorkflows,
+    userProfileConfidenceDecayDays: fileConfig.userProfileConfidenceDecayDays ?? DEFAULTS.userProfileConfidenceDecayDays,
+    userProfileChangelogRetentionCount: fileConfig.userProfileChangelogRetentionCount ?? DEFAULTS.userProfileChangelogRetentionCount,
 };
 export function isConfigured() {
     return true;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAyC/D,eAAO,MAAM,iBAAiB,EAAE,MA+kB/B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAyC/D,eAAO,MAAM,iBAAiB,EAAE,MAwlB/B,CAAC"}

package/dist/index.js

@@ -184,12 +184,10 @@ export const OpenCodeMemPlugin = async (ctx) => {
                             return;
                         }
                     }
-                    const [profileResult, userMemoriesResult, projectMemoriesListResult] = await Promise.all([
-                        memoryClient.getProfile(tags.user.tag, userMessage),
+                    const [userMemoriesResult, projectMemoriesListResult] = await Promise.all([
                         memoryClient.searchMemories(userMessage, tags.user.tag),
                         memoryClient.listMemories(tags.project.tag, CONFIG.maxProjectMemories),
                     ]);
-                    const profile = profileResult.success ? profileResult : null;
                     const userMemories = userMemoriesResult.success ? userMemoriesResult : { results: [] };
                     const projectMemoriesList = projectMemoriesListResult.success
                         ? projectMemoriesListResult
@@ -205,7 +203,8 @@ export const OpenCodeMemPlugin = async (ctx) => {
                         total: projectMemoriesList.memories?.length || 0,
                         timing: 0,
                     };
-                    const memoryContext = formatContextForPrompt(profile, userMemories, projectMemories);
+                    const userId = tags.user.userEmail || null;
+                    const memoryContext = formatContextForPrompt(userId, userMemories, projectMemories);
                     if (memoryContext) {
                         const contextPart = {
                             id: `memory-context-${Date.now()}`,
@@ -409,18 +408,27 @@ export const OpenCodeMemPlugin = async (ctx) => {
                                 });
                             }
                             case "profile": {
-                                const result = await memoryClient.getProfile(tags.user.tag, args.query);
-                                if (!result.success) {
+                                const { userProfileManager } = await import("./services/user-profile/user-profile-manager.js");
+                                const userId = tags.user.userEmail || "unknown";
+                                const profile = userProfileManager.getActiveProfile(userId);
+                                if (!profile) {
                                     return JSON.stringify({
-                                        success: false,
-                                        error: result.error || "Failed to fetch profile",
+                                        success: true,
+                                        profile: null,
+                                        message: "No user profile found",
                                     });
                                 }
+                                const profileData = JSON.parse(profile.profileData);
                                 return JSON.stringify({
                                     success: true,
                                     profile: {
-                                        static: result.profile?.static || [],
-                                        dynamic: result.profile?.dynamic || [],
+                                        preferences: profileData.preferences,
+                                        patterns: profileData.patterns,
+                                        workflows: profileData.workflows,
+                                        skillLevel: profileData.skillLevel,
+                                        version: profile.version,
+                                        lastAnalyzed: profile.lastAnalyzedAt,
+                                        totalPromptsAnalyzed: profile.totalPromptsAnalyzed,
                                     },
                                 });
                             }

package/dist/services/client.d.ts

@@ -1,9 +1,4 @@
 import type { MemoryType } from "../types/index.js";
-import type { SearchResult } from "./sqlite/types.js";
-interface ProfileData {
-    static: string[];
-    dynamic: string[];
-}
 export declare class LocalMemoryClient {
     private initPromise;
     private isInitialized;
@@ -19,7 +14,7 @@ export declare class LocalMemoryClient {
     close(): void;
     searchMemories(query: string, containerTag: string): Promise<{
         success: true;
-        results: SearchResult[];
+        results: import("./sqlite/types.js").SearchResult[];
         total: number;
         timing: number;
         error?: undefined;
@@ -30,15 +25,6 @@ export declare class LocalMemoryClient {
         total: number;
         timing: number;
     }>;
-    getProfile(containerTag: string, query?: string): Promise<{
-        success: true;
-        profile: ProfileData;
-        error?: undefined;
-    } | {
-        success: false;
-        error: string;
-        profile: null;
-    }>;
     addMemory(content: string, containerTag: string, metadata?: {
         type?: MemoryType;
         source?: "manual" | "auto-capture" | "import" | "api";
@@ -101,5 +87,4 @@ export declare class LocalMemoryClient {
     }>;
 }
 export declare const memoryClient: LocalMemoryClient;
-export {};
 //# sourceMappingURL=client.d.ts.map

package/dist/services/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/services/client.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAgB,YAAY,EAAE,MAAM,mBAAmB,CAAC;AA2CpE,UAAU,WAAW;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,aAAa,CAAkB;;YAIzB,UAAU;IAiBlB,MAAM,CAAC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjE,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAIjC,SAAS,IAAI;QACX,WAAW,EAAE,OAAO,CAAC;QACrB,WAAW,EAAE,OAAO,CAAC;QACrB,KAAK,EAAE,OAAO,CAAC;KAChB;IAQD,KAAK,IAAI,IAAI;IAIP,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;;;;;;;;;;;;;IA6BlD,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;;;;;;;;;IAyC/C,SAAS,CACb,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,UAAU,CAAC;QAClB,MAAM,CAAC,EAAE,QAAQ,GAAG,cAAc,GAAG,QAAQ,GAAG,KAAK,CAAC;QACtD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB;;;;;;;;;IAqDG,YAAY,CAAC,QAAQ,EAAE,MAAM;;;;;;;IA2B7B,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,SAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDpD;AAED,eAAO,MAAM,YAAY,mBAA0B,CAAC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/services/client.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AA4CpD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,aAAa,CAAkB;;YAIzB,UAAU;IAiBlB,MAAM,CAAC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjE,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAIjC,SAAS,IAAI;QACX,WAAW,EAAE,OAAO,CAAC;QACrB,WAAW,EAAE,OAAO,CAAC;QACrB,KAAK,EAAE,OAAO,CAAC;KAChB;IAQD,KAAK,IAAI,IAAI;IAIP,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;;;;;;;;;;;;;IA6BlD,SAAS,CACb,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,UAAU,CAAC;QAClB,MAAM,CAAC,EAAE,QAAQ,GAAG,cAAc,GAAG,QAAQ,GAAG,KAAK,CAAC;QACtD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB;;;;;;;;;IAqDG,YAAY,CAAC,QAAQ,EAAE,MAAM;;;;;;;IA2B7B,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,SAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDpD;AAED,eAAO,MAAM,YAAY,mBAA0B,CAAC"}

package/dist/services/client.js

@@ -96,41 +96,6 @@ export class LocalMemoryClient {
             return { success: false, error: errorMessage, results: [], total: 0, timing: 0 };
         }
     }
-    async getProfile(containerTag, query) {
-        try {
-            await this.initialize();
-            const { scope, hash } = extractScopeFromContainerTag(containerTag);
-            const shards = shardManager.getAllShards(scope, hash);
-            if (shards.length === 0) {
-                log("getProfile: no shards found", { containerTag });
-                return { success: true, profile: { static: [], dynamic: [] } };
-            }
-            const staticFacts = [];
-            const dynamicFacts = [];
-            for (const shard of shards) {
-                const db = connectionManager.getConnection(shard.dbPath);
-                const memories = vectorSearch.listMemories(db, containerTag, CONFIG.maxProfileItems * 2);
-                for (const m of memories) {
-                    if (m.type === "preference") {
-                        staticFacts.push(m.content);
-                    }
-                    else {
-                        dynamicFacts.push(m.content);
-                    }
-                }
-            }
-            const profile = {
-                static: staticFacts.slice(0, CONFIG.maxProfileItems),
-                dynamic: dynamicFacts.slice(0, CONFIG.maxProfileItems),
-            };
-            return { success: true, profile };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            log("getProfile: error", { error: errorMessage });
-            return { success: false, error: errorMessage, profile: null };
-        }
-    }
     async addMemory(content, containerTag, metadata) {
         try {
             await this.initialize();

package/dist/services/context.d.ts

@@ -6,12 +6,6 @@ interface MemoryResultMinimal {
 interface MemoriesResponseMinimal {
     results?: MemoryResultMinimal[];
 }
-interface ProfileResponse {
-    profile?: {
-        static: string[];
-        dynamic: string[];
-    };
-}
-export declare function formatContextForPrompt(profile: ProfileResponse | null, userMemories: MemoriesResponseMinimal, projectMemories: MemoriesResponseMinimal): string;
+export declare function formatContextForPrompt(userId: string | null, userMemories: MemoriesResponseMinimal, projectMemories: MemoriesResponseMinimal): string;
 export {};
 //# sourceMappingURL=context.d.ts.map

package/dist/services/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/services/context.ts"],"names":[],"mappings":"AAEA,UAAU,mBAAmB;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,uBAAuB;IAC/B,OAAO,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACjC;AAED,UAAU,eAAe;IACvB,OAAO,CAAC,EAAE;QACR,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;CACH;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,eAAe,GAAG,IAAI,EAC/B,YAAY,EAAE,uBAAuB,EACrC,eAAe,EAAE,uBAAuB,GACvC,MAAM,CA8CR"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/services/context.ts"],"names":[],"mappings":"AAGA,UAAU,mBAAmB;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,uBAAuB;IAC/B,OAAO,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACjC;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,YAAY,EAAE,uBAAuB,EACrC,eAAe,EAAE,uBAAuB,GACvC,MAAM,CAmCR"}

package/dist/services/context.js

@@ -1,19 +1,11 @@
 import { CONFIG } from "../config.js";
-export function formatContextForPrompt(profile, userMemories, projectMemories) {
+import { getUserProfileContext } from "./user-profile/profile-context.js";
+export function formatContextForPrompt(userId, userMemories, projectMemories) {
     const parts = ["[MEMORY]"];
-    if (CONFIG.injectProfile && profile?.profile) {
-        const { static: staticFacts, dynamic: dynamicFacts } = profile.profile;
-        if (staticFacts.length > 0) {
-            parts.push("\nUser Profile:");
-            staticFacts.slice(0, CONFIG.maxProfileItems).forEach((fact) => {
-                parts.push(`- ${fact}`);
-            });
-        }
-        if (dynamicFacts.length > 0) {
-            parts.push("\nRecent Context:");
-            dynamicFacts.slice(0, CONFIG.maxProfileItems).forEach((fact) => {
-                parts.push(`- ${fact}`);
-            });
+    if (CONFIG.injectProfile && userId) {
+        const profileContext = getUserProfileContext(userId);
+        if (profileContext) {
+            parts.push("\n" + profileContext);
         }
     }
     const projectResults = projectMemories.results || [];

package/dist/services/user-memory-learning.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-memory-learning.d.ts","sourceRoot":"","sources":["../../src/services/user-memory-learning.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAQvD,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,WAAW,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAyEf"}
+{"version":3,"file":"user-memory-learning.d.ts","sourceRoot":"","sources":["../../src/services/user-memory-learning.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AASvD,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,WAAW,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CA8Ef"}

package/dist/services/user-memory-learning.js

@@ -1,8 +1,8 @@
-import { memoryClient } from "./client.js";
 import { getTags } from "./tags.js";
 import { log } from "./logger.js";
 import { CONFIG } from "../config.js";
 import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
+import { userProfileManager } from "./user-profile/user-profile-manager.js";
 export async function performUserMemoryLearning(ctx, directory) {
     try {
         const count = userPromptManager.countUnanalyzedForUserLearning();
@@ -14,50 +14,41 @@ export async function performUserMemoryLearning(ctx, directory) {
         if (prompts.length === 0) {
             return;
         }
-        const context = buildUserAnalysisContext(prompts);
-        const memories = await analyzeUserPatterns(ctx, context);
-        if (!memories || memories.length === 0) {
-            log("User memory learning: no patterns identified", { promptCount: prompts.length });
+        const tags = getTags(directory);
+        const userId = tags.user.userEmail || "unknown";
+        const existingProfile = userProfileManager.getActiveProfile(userId);
+        const context = buildUserAnalysisContext(prompts, existingProfile);
+        const updatedProfileData = await analyzeUserProfile(context, existingProfile);
+        if (!updatedProfileData) {
+            log("User memory learning: no profile updates", { promptCount: prompts.length });
             userPromptManager.markMultipleAsUserLearningCaptured(prompts.map((p) => p.id));
             return;
         }
-        const tags = getTags(directory);
-        let savedCount = 0;
-        for (const memory of memories) {
-            const result = await memoryClient.addMemory(memory.summary, tags.user.tag, {
-                type: memory.type,
-                source: "user-learning",
-                promptCount: prompts.length,
-                analysisTimestamp: Date.now(),
-                reasoning: memory.reasoning,
-                displayName: tags.user.displayName,
-                userName: tags.user.userName,
-                userEmail: tags.user.userEmail,
-            });
-            if (result.success) {
-                savedCount++;
-            }
+        if (existingProfile) {
+            const changeSummary = generateChangeSummary(JSON.parse(existingProfile.profileData), updatedProfileData);
+            userProfileManager.updateProfile(existingProfile.id, updatedProfileData, prompts.length, changeSummary);
         }
-        userPromptManager.markMultipleAsUserLearningCaptured(prompts.map((p) => p.id));
-        if (savedCount > 0) {
-            await ctx.client?.tui
-                .showToast({
-                body: {
-                    title: "User Memory Learning",
-                    message: `Learned ${savedCount} pattern${savedCount > 1 ? "s" : ""} from ${prompts.length} prompts`,
-                    variant: "success",
-                    duration: 3000,
-                },
-            })
-                .catch(() => { });
+        else {
+            userProfileManager.createProfile(userId, tags.user.displayName || "Unknown", tags.user.userName || "unknown", tags.user.userEmail || "unknown", updatedProfileData, prompts.length);
         }
+        userPromptManager.markMultipleAsUserLearningCaptured(prompts.map((p) => p.id));
+        await ctx.client?.tui
+            .showToast({
+            body: {
+                title: "User Profile Updated",
+                message: `Analyzed ${prompts.length} prompts and updated your profile`,
+                variant: "success",
+                duration: 3000,
+            },
+        })
+            .catch(() => { });
     }
     catch (error) {
         log("User memory learning error", { error: String(error) });
         await ctx.client?.tui
             .showToast({
             body: {
-                title: "User Memory Learning Failed",
+                title: "User Profile Update Failed",
                 message: String(error),
                 variant: "error",
                 duration: 5000,
@@ -66,37 +57,63 @@ export async function performUserMemoryLearning(ctx, directory) {
             .catch(() => { });
     }
 }
-function buildUserAnalysisContext(prompts) {
-    return `# User Prompt History Analysis
+function generateChangeSummary(oldProfile, newProfile) {
+    const changes = [];
+    const prefDiff = newProfile.preferences.length - oldProfile.preferences.length;
+    if (prefDiff > 0)
+        changes.push(`+${prefDiff} preferences`);
+    const patternDiff = newProfile.patterns.length - oldProfile.patterns.length;
+    if (patternDiff > 0)
+        changes.push(`+${patternDiff} patterns`);
+    const workflowDiff = newProfile.workflows.length - oldProfile.workflows.length;
+    if (workflowDiff > 0)
+        changes.push(`+${workflowDiff} workflows`);
+    return changes.length > 0 ? changes.join(", ") : "Profile refinement";
+}
+function buildUserAnalysisContext(prompts, existingProfile) {
+    const existingProfileSection = existingProfile
+        ? `
+## Existing User Profile
+
+${existingProfile.profileData}
 
-Analyze the following ${prompts.length} user prompts to identify patterns, preferences, and workflows.
+**Instructions**: Merge new insights with the existing profile. Update confidence scores for reinforced patterns, add new patterns, and refine existing ones.`
+        : `
+**Instructions**: Create a new user profile from scratch based on the prompts below.`;
+    return `# User Profile Analysis
 
-## Prompts
+Analyze ${prompts.length} user prompts to ${existingProfile ? "update" : "create"} the user profile.
+
+${existingProfileSection}
+
+## Recent Prompts
 
 ${prompts.map((p, i) => `${i + 1}. ${p.content}`).join("\n\n")}
 
-## Analysis Instructions
+## Analysis Guidelines
 
-Identify user patterns and preferences from these prompts. Look for:
+Identify and ${existingProfile ? "update" : "create"}:
 
-1. **Preferences**: How the user likes things done
-   - Code style preferences (e.g., "prefers code without comments")
-   - Communication preferences (e.g., "likes concise responses")
-   - Tool preferences (e.g., "prefers TypeScript over JavaScript")
+1. **Preferences** (max ${CONFIG.userProfileMaxPreferences})
+   - Code style, communication style, tool preferences
+   - Assign confidence 0.5-1.0 based on evidence strength
+   - Include 1-3 example prompts as evidence
 
-2. **Patterns**: Recurring topics or requests
-   - Technical topics (e.g., "often asks about database optimization")
-   - Problem domains (e.g., "frequently works on authentication")
-   - Skill level indicators (e.g., "asks detailed questions about async patterns")
+2. **Patterns** (max ${CONFIG.userProfileMaxPatterns})
+   - Recurring topics, problem domains, technical interests
+   - Track frequency of occurrence
 
-3. **Workflows**n sequences or habits
-   - Development flow (e.g., "usually asks for tests after implementation")
-   - Review habits (e.g., "always requests code review before committing")
-   - Learning style (e.g., "prefers examples over explanations")
+3. **Workflows** (max ${CONFIG.userProfileMaxWorkflows})
+   - Development sequences, habits, learning style
+   - Break down into steps if applicable
 
-Generate 1-5 key insights as memories. Only include patterns that are clearly evident from multiple prompts.`;
+4. **Skill Level**
+   - Overall: beginner/intermediate/advanced
+   - Per-domain assessment (e.g., typescript: advanced, docker: beginner)
+
+${existingProfile ? "Merge with existing profile, incrementing frequencies and updating confidence scores." : "Create initial profile with conservative confidence scores."}`;
 }
-async function analyzeUserPatterns(ctx, context) {
+async function analyzeUserProfile(context, existingProfile) {
     if (!CONFIG.memoryModel || !CONFIG.memoryApiUrl || !CONFIG.memoryApiKey) {
         throw new Error("External API not configured for user memory learning");
     }
@@ -111,54 +128,73 @@ async function analyzeUserPatterns(ctx, context) {
     const provider = AIProviderFactory.createProvider(CONFIG.memoryProvider, providerConfig);
     const systemPrompt = `You are a user behavior analyst for a coding assistant.
 
-Your task is to analyze user prompts fy patterns, preferences, and workflows.
-
-Use the save_user_memories tool to save identified patterns. Only save patterns that are clearly evident from the prompts.
+Your task is to analyze user prompts and ${existingProfile ? "update" : "create"} a comprehensive user profile.
 
-IMPORTANT: All memories must have scope set to "user".`;
+Use the update_user_profile tool to save the ${existingProfile ? "updated" : "new"} profile.`;
     const toolSchema = {
         type: "function",
         function: {
-            name: "save_user_memories",
-            description: "Save identified user patterns and preferences",
+            name: "update_user_profile",
+            description: existingProfile ? "Update existing user profile with new insights" : "Create new user profile",
             parameters: {
                 type: "object",
                 properties: {
-                    memories: {
+                    preferences: {
                         type: "array",
-                        description: "Array of identified patterns (1-5 memories)",
                         items: {
                             type: "object",
                             properties: {
-                                summary: {
-                                    type: "string",
-                                    description: "Clear description of the pattern or preference",
-                                },
-                                scope: {
-                                    type: "string",
-                                    enum: ["user"],
-                                    description: "Memory scope (must be 'user' for user learning)",
-                                },
-                                type: {
-                                    type: "string",
-                                    description: "Type of insight (e.g., preference, pattern, workflow, skill-level, communication-style)",
-                                },
-                                reasoning: {
-                                    type: "string",
-                                    description: "Why this pattern is significant (optial)",
-                                },
+                                category: { type: "string" },
+                                description: { type: "string" },
+                                confidence: { type: "number", minimum: 0, maximum: 1 },
+                                evidence: { type: "array", items: { type: "string" }, maxItems: 3 },
                             },
-                            required: ["summary", "scope", "type"],
+                            required: ["category", "description", "confidence", "evidence"],
                         },
                     },
+                    patterns: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                category: { type: "string" },
+                                description: { type: "string" },
+                            },
+                            required: ["category", "description"],
+                        },
+                    },
+                    workflows: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                description: { type: "string" },
+                                steps: { type: "array", items: { type: "string" } },
+                            },
+                            required: ["description", "steps"],
+                        },
+                    },
+                    skillLevel: {
+                        type: "object",
+                        properties: {
+                            overall: { type: "string", enum: ["beginner", "intermediate", "advanced"] },
+                            domains: { type: "object", additionalProperties: { type: "string" } },
+                        },
+                        required: ["overall", "domains"],
+                    },
                 },
-                required: ["memories"],
+                required: ["preferences", "patterns", "workflows", "skillLevel"],
             },
         },
     };
-    const result = await provider.executeToolCall(systemPrompt, context, toolSchema, "user-learning");
+    const result = await provider.executeToolCall(systemPrompt, context, toolSchema, "user-profile");
     if (!result.success || !result.data) {
-        throw new Error(result.error || "Failed to analyze user patterns");
+        throw new Error(result.error || "Failed to analyze user profile");
+    }
+    const rawData = result.data;
+    if (existingProfile) {
+        const existingData = JSON.parse(existingProfile.profileData);
+        return userProfileManager.mergeProfileData(existingData, rawData);
     }
-    return result.data.memories || [];
+    return rawData;
 }

package/dist/services/user-profile/profile-context.d.ts

@@ -0,0 +1,2 @@
+export declare function getUserProfileContext(userId: string): string | null;
+//# sourceMappingURL=profile-context.d.ts.map

package/dist/services/user-profile/profile-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile-context.d.ts","sourceRoot":"","sources":["../../../src/services/user-profile/profile-context.ts"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA6CnE"}

package/dist/services/user-profile/profile-context.js

@@ -0,0 +1,40 @@
+import { userProfileManager } from "./user-profile-manager.js";
+export function getUserProfileContext(userId) {
+    const profile = userProfileManager.getActiveProfile(userId);
+    if (!profile) {
+        return null;
+    }
+    const profileData = JSON.parse(profile.profileData);
+    const parts = [];
+    if (profileData.preferences.length > 0) {
+        parts.push("User Preferences:");
+        profileData.preferences
+            .sort((a, b) => b.confidence - a.confidence)
+            .slice(0, 5)
+            .forEach((pref) => {
+            parts.push(`- [${pref.category}] ${pref.description}`);
+        });
+    }
+    if (profileData.patterns.length > 0) {
+        parts.push("\nUser Patterns:");
+        profileData.patterns
+            .sort((a, b) => b.frequency - a.frequency)
+            .slice(0, 5)
+            .forEach((pattern) => {
+            parts.push(`- [${pattern.category}] ${pattern.description}`);
+        });
+    }
+    if (profileData.workflows.length > 0) {
+        parts.push("\nUser Workflows:");
+        profileData.workflows
+            .sort((a, b) => b.frequency - a.frequency)
+            .slice(0, 3)
+            .forEach((workflow) => {
+            parts.push(`- ${workflow.description}`);
+        });
+    }
+    if (parts.length === 0) {
+        return null;
+    }
+    return parts.join("\n");
+}

package/dist/services/user-profile/types.d.ts

@@ -0,0 +1,51 @@
+export interface UserProfilePreference {
+    category: string;
+    description: string;
+    confidence: number;
+    evidence: string[];
+    lastUpdated: number;
+}
+export interface UserProfilePattern {
+    category: string;
+    description: string;
+    frequency: number;
+    lastSeen: number;
+}
+export interface UserProfileWorkflow {
+    description: string;
+    steps: string[];
+    frequency: number;
+}
+export interface UserProfileSkillLevel {
+    overall: string;
+    domains: Record<string, string>;
+}
+export interface UserProfileData {
+    preferences: UserProfilePreference[];
+    patterns: UserProfilePattern[];
+    workflows: UserProfileWorkflow[];
+    skillLevel: UserProfileSkillLevel;
+}
+export interface UserProfile {
+    id: string;
+    userId: string;
+    displayName: string;
+    userName: string;
+    userEmail: string;
+    profileData: string;
+    version: number;
+    createdAt: number;
+    lastAnalyzedAt: number;
+    totalPromptsAnalyzed: number;
+    isActive: boolean;
+}
+export interface UserProfileChangelog {
+    id: string;
+    profileId: string;
+    version: number;
+    changeType: string;
+    changeSummary: string;
+    profileDataSnapshot: string;
+    createdAt: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/services/user-profile/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/services/user-profile/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,qBAAqB,EAAE,CAAC;IACrC,QAAQ,EAAE,kBAAkB,EAAE,CAAC;IAC/B,SAAS,EAAE,mBAAmB,EAAE,CAAC;IACjC,UAAU,EAAE,qBAAqB,CAAC;CACnC;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/services/user-profile/types.js

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

package/dist/services/user-profile/user-profile-manager.d.ts

@@ -0,0 +1,22 @@
+import type { UserProfile, UserProfileChangelog, UserProfileData } from "./types.js";
+export declare class UserProfileManager {
+    private db;
+    private readonly dbPath;
+    constructor();
+    private initDatabase;
+    getActiveProfile(userId: string): UserProfile | null;
+    createProfile(userId: string, displayName: string, userName: string, userEmail: string, profileData: UserProfileData, promptsAnalyzed: number): string;
+    updateProfile(profileId: string, profileData: UserProfileData, additionalPromptsAnalyzed: number, changeSummary: string): void;
+    private addChangelog;
+    private cleanupOldChangelogs;
+    getProfileChangelogs(profileId: string, limit?: number): UserProfileChangelog[];
+    applyConfidenceDecay(profileId: string): void;
+    deleteProfile(profileId: string): void;
+    getProfileById(profileId: string): UserProfile | null;
+    getAllActiveProfiles(): UserProfile[];
+    private rowToProfile;
+    private rowToChangelog;
+    mergeProfileData(existing: UserProfileData, updates: Partial<UserProfileData>): UserProfileData;
+}
+export declare const userProfileManager: UserProfileManager;
+//# sourceMappingURL=user-profile-manager.d.ts.map

package/dist/services/user-profile/user-profile-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-profile-manager.d.ts","sourceRoot":"","sources":["../../../src/services/user-profile/user-profile-manager.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,WAAW,EACX,oBAAoB,EACpB,eAAe,EAChB,MAAM,YAAY,CAAC;AAIpB,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,EAAE,CAAW;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;;IAQhC,OAAO,CAAC,YAAY;IA0CpB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAapD,aAAa,CACX,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,eAAe,EAC5B,eAAe,EAAE,MAAM,GACtB,MAAM;IA8BT,aAAa,CACX,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,eAAe,EAC5B,yBAAyB,EAAE,MAAM,EACjC,aAAa,EAAE,MAAM,GACpB,IAAI;IAuBP,OAAO,CAAC,YAAY;IAqBpB,OAAO,CAAC,oBAAoB;IAiB5B,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW,GAAG,oBAAoB,EAAE;IAYnF,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IA2B7C,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAKtC,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAOrD,oBAAoB,IAAI,WAAW,EAAE;IAMrC,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,cAAc;IAYtB,gBAAgB,CACd,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,GAChC,eAAe;CAyFnB;AAED,eAAO,MAAM,kBAAkB,oBAA2B,CAAC"}

package/dist/services/user-profile/user-profile-manager.js

@@ -0,0 +1,267 @@
+import { Database } from "bun:sqlite";
+import { join } from "node:path";
+import { connectionManager } from "../sqlite/connection-manager.js";
+import { CONFIG } from "../../config.js";
+const USER_PROFILES_DB_NAME = "user-profiles.db";
+export class UserProfileManager {
+    db;
+    dbPath;
+    constructor() {
+        this.dbPath = join(CONFIG.storagePath, USER_PROFILES_DB_NAME);
+        this.db = connectionManager.getConnection(this.dbPath);
+        this.initDatabase();
+    }
+    initDatabase() {
+        this.db.run(`
+      CREATE TABLE IF NOT EXISTS user_profiles (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL UNIQUE,
+        display_name TEXT NOT NULL,
+        user_name TEXT NOT NULL,
+        user_email TEXT NOT NULL,
+        profile_data TEXT NOT NULL,
+        version INTEGER NOT NULL DEFAULT 1,
+        created_at INTEGER NOT NULL,
+        last_analyzed_at INTEGER NOT NULL,
+        total_prompts_analyzed INTEGER NOT NULL DEFAULT 0,
+        is_active BOOLEAN NOT NULL DEFAULT 1
+      )
+    `);
+        this.db.run(`
+      CREATE TABLE IF NOT EXISTS user_profile_changelogs (
+        id TEXT PRIMARY KEY,
+        profile_id TEXT NOT NULL,
+        version INTEGER NOT NULL,
+        change_type TEXT NOT NULL,
+        change_summary TEXT NOT NULL,
+        profile_data_snapshot TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        FOREIGN KEY (profile_id) REFERENCES user_profiles(id) ON DELETE CASCADE
+      )
+    `);
+        this.db.run("CREATE INDEX IF NOT EXISTS idx_user_profiles_user_id ON user_profiles(user_id)");
+        this.db.run("CREATE INDEX IF NOT EXISTS idx_user_profiles_is_active ON user_profiles(is_active)");
+        this.db.run("CREATE INDEX IF NOT EXISTS idx_user_profile_changelogs_profile_id ON user_profile_changelogs(profile_id)");
+        this.db.run("CREATE INDEX IF NOT EXISTS idx_user_profile_changelogs_version ON user_profile_changelogs(version DESC)");
+    }
+    getActiveProfile(userId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM user_profiles 
+      WHERE user_id = ? AND is_active = 1
+      LIMIT 1
+    `);
+        const row = stmt.get(userId);
+        if (!row)
+            return null;
+        return this.rowToProfile(row);
+    }
+    createProfile(userId, displayName, userName, userEmail, profileData, promptsAnalyzed) {
+        const id = `profile_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      INSERT INTO user_profiles (
+        id, user_id, display_name, user_name, user_email, 
+        profile_data, version, created_at, last_analyzed_at, 
+        total_prompts_analyzed, is_active
+      )
+      VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?, ?, 1)
+    `);
+        stmt.run(id, userId, displayName, userName, userEmail, JSON.stringify(profileData), now, now, promptsAnalyzed);
+        this.addChangelog(id, 1, "create", "Initial profile creation", profileData);
+        return id;
+    }
+    updateProfile(profileId, profileData, additionalPromptsAnalyzed, changeSummary) {
+        const now = Date.now();
+        const getVersionStmt = this.db.prepare(`SELECT version FROM user_profiles WHERE id = ?`);
+        const versionRow = getVersionStmt.get(profileId);
+        const newVersion = (versionRow?.version || 0) + 1;
+        const updateStmt = this.db.prepare(`
+      UPDATE user_profiles 
+      SET profile_data = ?, 
+          version = ?, 
+          last_analyzed_at = ?, 
+          total_prompts_analyzed = total_prompts_analyzed + ?
+      WHERE id = ?
+    `);
+        updateStmt.run(JSON.stringify(profileData), newVersion, now, additionalPromptsAnalyzed, profileId);
+        this.addChangelog(profileId, newVersion, "update", changeSummary, profileData);
+        this.cleanupOldChangelogs(profileId);
+    }
+    addChangelog(profileId, version, changeType, changeSummary, profileData) {
+        const id = `changelog_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      INSERT INTO user_profile_changelogs (
+        id, profile_id, version, change_type, change_summary, 
+        profile_data_snapshot, created_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(id, profileId, version, changeType, changeSummary, JSON.stringify(profileData), now);
+    }
+    cleanupOldChangelogs(profileId) {
+        const retentionCount = CONFIG.userProfileChangelogRetentionCount;
+        const stmt = this.db.prepare(`
+      DELETE FROM user_profile_changelogs 
+      WHERE profile_id = ? 
+      AND id NOT IN (
+        SELECT id FROM user_profile_changelogs 
+        WHERE profile_id = ? 
+        ORDER BY version DESC 
+        LIMIT ?
+      )
+    `);
+        stmt.run(profileId, profileId, retentionCount);
+    }
+    getProfileChangelogs(profileId, limit = 10) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM user_profile_changelogs 
+      WHERE profile_id = ? 
+      ORDER BY version DESC 
+      LIMIT ?
+    `);
+        const rows = stmt.all(profileId, limit);
+        return rows.map((row) => this.rowToChangelog(row));
+    }
+    applyConfidenceDecay(profileId) {
+        const profile = this.getProfileById(profileId);
+        if (!profile)
+            return;
+        const profileData = JSON.parse(profile.profileData);
+        const now = Date.now();
+        const decayThreshold = CONFIG.userProfileConfidenceDecayDays * 24 * 60 * 60 * 1000;
+        let hasChanges = false;
+        profileData.preferences = profileData.preferences
+            .map((pref) => {
+            const age = now - pref.lastUpdated;
+            if (age > decayThreshold) {
+                hasChanges = true;
+                const decayFactor = Math.max(0.5, 1 - (age - decayThreshold) / decayThreshold);
+                return { ...pref, confidence: pref.confidence * decayFactor };
+            }
+            return pref;
+        })
+            .filter((pref) => pref.confidence >= 0.3);
+        if (hasChanges) {
+            this.updateProfile(profileId, profileData, 0, "Applied confidence decay to preferences");
+        }
+    }
+    deleteProfile(profileId) {
+        const stmt = this.db.prepare(`DELETE FROM user_profiles WHERE id = ?`);
+        stmt.run(profileId);
+    }
+    getProfileById(profileId) {
+        const stmt = this.db.prepare(`SELECT * FROM user_profiles WHERE id = ?`);
+        const row = stmt.get(profileId);
+        if (!row)
+            return null;
+        return this.rowToProfile(row);
+    }
+    getAllActiveProfiles() {
+        const stmt = this.db.prepare(`SELECT * FROM user_profiles WHERE is_active = 1`);
+        const rows = stmt.all();
+        return rows.map((row) => this.rowToProfile(row));
+    }
+    rowToProfile(row) {
+        return {
+            id: row.id,
+            userId: row.user_id,
+            displayName: row.display_name,
+            userName: row.user_name,
+            userEmail: row.user_email,
+            profileData: row.profile_data,
+            version: row.version,
+            createdAt: row.created_at,
+            lastAnalyzedAt: row.last_analyzed_at,
+            totalPromptsAnalyzed: row.total_prompts_analyzed,
+            isActive: row.is_active === 1,
+        };
+    }
+    rowToChangelog(row) {
+        return {
+            id: row.id,
+            profileId: row.profile_id,
+            version: row.version,
+            changeType: row.change_type,
+            changeSummary: row.change_summary,
+            profileDataSnapshot: row.profile_data_snapshot,
+            createdAt: row.created_at,
+        };
+    }
+    mergeProfileData(existing, updates) {
+        const merged = {
+            preferences: [...existing.preferences],
+            patterns: [...existing.patterns],
+            workflows: [...existing.workflows],
+            skillLevel: { ...existing.skillLevel },
+        };
+        if (updates.preferences) {
+            for (const newPref of updates.preferences) {
+                const existingIndex = merged.preferences.findIndex((p) => p.category === newPref.category && p.description === newPref.description);
+                if (existingIndex >= 0) {
+                    const existing = merged.preferences[existingIndex];
+                    if (existing) {
+                        merged.preferences[existingIndex] = {
+                            ...newPref,
+                            confidence: Math.min(1, existing.confidence + 0.1),
+                            evidence: [...new Set([...existing.evidence, ...newPref.evidence])].slice(0, 5),
+                            lastUpdated: Date.now(),
+                        };
+                    }
+                }
+                else {
+                    merged.preferences.push({ ...newPref, lastUpdated: Date.now() });
+                }
+            }
+            merged.preferences.sort((a, b) => b.confidence - a.confidence);
+            merged.preferences = merged.preferences.slice(0, CONFIG.userProfileMaxPreferences);
+        }
+        if (updates.patterns) {
+            for (const newPattern of updates.patterns) {
+                const existingIndex = merged.patterns.findIndex((p) => p.category === newPattern.category && p.description === newPattern.description);
+                if (existingIndex >= 0) {
+                    const existing = merged.patterns[existingIndex];
+                    if (existing) {
+                        merged.patterns[existingIndex] = {
+                            ...newPattern,
+                            frequency: existing.frequency + 1,
+                            lastSeen: Date.now(),
+                        };
+                    }
+                }
+                else {
+                    merged.patterns.push({ ...newPattern, frequency: 1, lastSeen: Date.now() });
+                }
+            }
+            merged.patterns.sort((a, b) => b.frequency - a.frequency);
+            merged.patterns = merged.patterns.slice(0, CONFIG.userProfileMaxPatterns);
+        }
+        if (updates.workflows) {
+            for (const newWorkflow of updates.workflows) {
+                const existingIndex = merged.workflows.findIndex((w) => w.description === newWorkflow.description);
+                if (existingIndex >= 0) {
+                    const existing = merged.workflows[existingIndex];
+                    if (existing) {
+                        merged.workflows[existingIndex] = {
+                            ...newWorkflow,
+                            frequency: existing.frequency + 1,
+                        };
+                    }
+                }
+                else {
+                    merged.workflows.push({ ...newWorkflow, frequency: 1 });
+                }
+            }
+            merged.workflows.sort((a, b) => b.frequency - a.frequency);
+            merged.workflows = merged.workflows.slice(0, CONFIG.userProfileMaxWorkflows);
+        }
+        if (updates.skillLevel) {
+            merged.skillLevel = {
+                overall: updates.skillLevel.overall || merged.skillLevel.overall,
+                domains: { ...merged.skillLevel.domains, ...updates.skillLevel.domains },
+            };
+        }
+        return merged;
+    }
+}
+export const userProfileManager = new UserProfileManager();

package/dist/types/index.d.ts

@@ -32,13 +32,11 @@ export interface ConversationIngestResponse {
 }
 export interface MemoryMetadata {
     type?: MemoryType;
-    source?: "manual" | "auto-capture" | "import" | "api" | "user-learning";
+    source?: "manual" | "auto-capture" | "import" | "api";
     tool?: string;
     sessionID?: string;
     reasoning?: string;
     captureTimestamp?: number;
-    promptCount?: number;
-    analysisTimestamp?: number;
     promptId?: string;
     displayName?: string;
     userName?: string;

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,SAAS,CAAC;AAE7C,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;AAExE,MAAM,MAAM,uBAAuB,GAC/B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAErD,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,MAAM,GAAG,uBAAuB,EAAE,CAAC;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,MAAM,CAAC,EAAE,QAAQ,GAAG,cAAc,GAAG,QAAQ,GAAG,KAAK,GAAG,eAAe,CAAC;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,kBAAkB,GAAG,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,SAAS,CAAC;AAE7C,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;AAExE,MAAM,MAAM,uBAAuB,GAC/B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAErD,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,MAAM,GAAG,uBAAuB,EAAE,CAAC;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,MAAM,CAAC,EAAE,QAAQ,GAAG,cAAc,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,kBAAkB,GAAG,WAAW,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-mem",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "OpenCode plugin that gives coding agents persistent memory using local vector database",
   "type": "module",
   "main": "dist/plugin.js",