opencode-mem 2.0.1 → 2.2.0

package/dist/services/api-handlers.js

@@ -149,7 +149,40 @@ export async function handleListMemories(tag, page = 1, pageSize = 20, scope, in
             }));
             timeline = [...memoriesWithType, ...promptsWithType];
         }
-        timeline.sort((a, b) => b.createdAt - a.createdAt);
+        const linkedPairs = new Map();
+        const standalone = [];
+        for (const item of timeline) {
+            if (item.type === "memory" && item.linkedPromptId) {
+                if (!linkedPairs.has(item.linkedPromptId)) {
+                    linkedPairs.set(item.linkedPromptId, { memory: item, prompt: null });
+                }
+                else {
+                    linkedPairs.get(item.linkedPromptId).memory = item;
+                }
+            }
+            else if (item.type === "prompt" && item.linkedMemoryId) {
+                if (!linkedPairs.has(item.id)) {
+                    linkedPairs.set(item.id, { memory: null, prompt: item });
+                }
+                else {
+                    linkedPairs.get(item.id).prompt = item;
+                }
+            }
+            else {
+                standalone.push(item);
+            }
+        }
+        const sortedTimeline = [];
+        const pairs = Array.from(linkedPairs.values())
+            .filter((p) => p.memory && p.prompt)
+            .sort((a, b) => b.memory.createdAt - a.memory.createdAt);
+        for (const pair of pairs) {
+            sortedTimeline.push(pair.memory);
+            sortedTimeline.push(pair.prompt);
+        }
+        standalone.sort((a, b) => b.createdAt - a.createdAt);
+        sortedTimeline.push(...standalone);
+        timeline = sortedTimeline;
         const total = timeline.length;
         const totalPages = Math.ceil(total / pageSize);
         const offset = (page - 1) * pageSize;
@@ -211,6 +244,12 @@ export async function handleAddMemory(data) {
         await embeddingService.warmup();
         const vector = await embeddingService.embedWithTimeout(data.content);
         const { scope, hash } = extractScopeFromTag(data.containerTag);
+        if (scope === "user") {
+            return {
+                success: false,
+                error: "User-scoped memories are deprecated. Use user profile system instead.",
+            };
+        }
         const shard = shardManager.getWriteShard(scope, hash);
         const id = `mem_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
         const now = Date.now();
@@ -605,3 +644,118 @@ export async function handleBulkDeletePrompts(ids, cascade = false) {
         return { success: false, error: String(error) };
     }
 }
+export async function handleGetUserProfile(userId) {
+    try {
+        const { userProfileManager } = await import("./user-profile/user-profile-manager.js");
+        const { getTags } = await import("./tags.js");
+        let targetUserId = userId;
+        if (!targetUserId) {
+            const tags = getTags(process.cwd());
+            targetUserId = tags.user.userEmail || "unknown";
+        }
+        const profile = userProfileManager.getActiveProfile(targetUserId);
+        if (!profile) {
+            return {
+                success: true,
+                data: {
+                    exists: false,
+                    userId: targetUserId,
+                    message: "No profile found. Keep chatting to build your profile.",
+                },
+            };
+        }
+        const profileData = JSON.parse(profile.profileData);
+        return {
+            success: true,
+            data: {
+                exists: true,
+                id: profile.id,
+                userId: profile.userId,
+                displayName: profile.displayName,
+                userName: profile.userName,
+                userEmail: profile.userEmail,
+                version: profile.version,
+                createdAt: safeToISOString(profile.createdAt),
+                lastAnalyzedAt: safeToISOString(profile.lastAnalyzedAt),
+                totalPromptsAnalyzed: profile.totalPromptsAnalyzed,
+                profileData,
+            },
+        };
+    }
+    catch (error) {
+        log("handleGetUserProfile: error", { error: String(error) });
+        return { success: false, error: String(error) };
+    }
+}
+export async function handleGetProfileChangelog(profileId, limit = 5) {
+    try {
+        if (!profileId) {
+            return { success: false, error: "profileId is required" };
+        }
+        const { userProfileManager } = await import("./user-profile/user-profile-manager.js");
+        const changelogs = userProfileManager.getProfileChangelogs(profileId, limit);
+        const formattedChangelogs = changelogs.map((c) => ({
+            id: c.id,
+            profileId: c.profileId,
+            version: c.version,
+            changeType: c.changeType,
+            changeSummary: c.changeSummary,
+            createdAt: safeToISOString(c.createdAt),
+        }));
+        return { success: true, data: formattedChangelogs };
+    }
+    catch (error) {
+        log("handleGetProfileChangelog: error", { error: String(error) });
+        return { success: false, error: String(error) };
+    }
+}
+export async function handleGetProfileSnapshot(changelogId) {
+    try {
+        if (!changelogId) {
+            return { success: false, error: "changelogId is required" };
+        }
+        const { userProfileManager } = await import("./user-profile/user-profile-manager.js");
+        const changelogs = userProfileManager.getProfileChangelogs("", 1000);
+        const changelog = changelogs.find((c) => c.id === changelogId);
+        if (!changelog) {
+            return { success: false, error: "Changelog not found" };
+        }
+        const profileData = JSON.parse(changelog.profileDataSnapshot);
+        return {
+            success: true,
+            data: {
+                version: changelog.version,
+                createdAt: safeToISOString(changelog.createdAt),
+                profileData,
+            },
+        };
+    }
+    catch (error) {
+        log("handleGetProfileSnapshot: error", { error: String(error) });
+        return { success: false, error: String(error) };
+    }
+}
+export async function handleRefreshProfile(userId) {
+    try {
+        const { getTags } = await import("./tags.js");
+        const { userPromptManager } = await import("./user-prompt/user-prompt-manager.js");
+        let targetUserId = userId;
+        if (!targetUserId) {
+            const tags = getTags(process.cwd());
+            targetUserId = tags.user.userEmail || "unknown";
+        }
+        const unanalyzedCount = userPromptManager.countUnanalyzedForUserLearning();
+        return {
+            success: true,
+            data: {
+                message: "Profile refresh queued",
+                unanalyzedPrompts: unanalyzedCount,
+                note: "Profile will be updated when threshold is reached",
+            },
+        };
+    }
+    catch (error) {
+        log("handleRefreshProfile: error", { error: String(error) });
+        return { success: false, error: String(error) };
+    }
+}

package/dist/services/auto-capture.js

@@ -37,7 +37,7 @@ export async function performAutoCapture(ctx, sessionID, directory) {
         const tags = getTags(directory);
         const latestMemory = await getLatestProjectMemory(tags.project.tag);
         const context = buildMarkdownContext(prompt.content, textResponses, toolCalls, latestMemory);
-        const summaryResult = await generateSummary(ctx, context, sessionID);
+        const summaryResult = await generateSummary(context, sessionID);
         if (!summaryResult || summaryResult.type === "skip") {
             log("Auto-capture: skipped non-technical conversation", { sessionID });
             userPromptManager.deletePrompt(prompt.id);
@@ -179,7 +179,7 @@ function buildMarkdownContext(userPrompt, textResponses, toolCalls, latestMemory
     }
     return sections.join("\n");
 }
-async function generateSummary(ctx, context, sessionID) {
+async function generateSummary(context, sessionID) {
     if (!CONFIG.memoryModel || !CONFIG.memoryApiUrl || !CONFIG.memoryApiKey) {
         throw new Error("External API not configured for auto-capture");
     }

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/deduplication-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deduplication-service.d.ts","sourceRoot":"","sources":["../../src/services/deduplication-service.ts"],"names":[],"mappings":"AAOA,UAAU,cAAc;IACtB,cAAc,EAAE;QACd,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,UAAU,EAAE,KAAK,CAAC;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;CACJ;AAED,UAAU,mBAAmB;IAC3B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,mBAAmB,EAAE,cAAc,EAAE,CAAC;CACvC;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,SAAS,CAAkB;IAE7B,yBAAyB,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAgH/D,OAAO,CAAC,gBAAgB;IAoBxB,SAAS;;;;;CAOV;AAED,eAAO,MAAM,oBAAoB,sBAA6B,CAAC"}
+{"version":3,"file":"deduplication-service.d.ts","sourceRoot":"","sources":["../../src/services/deduplication-service.ts"],"names":[],"mappings":"AAMA,UAAU,cAAc;IACtB,cAAc,EAAE;QACd,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,UAAU,EAAE,KAAK,CAAC;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;CACJ;AAED,UAAU,mBAAmB;IAC3B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,mBAAmB,EAAE,cAAc,EAAE,CAAC;CACvC;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,SAAS,CAAkB;IAE7B,yBAAyB,IAAI,OAAO,CAAC,mBAAmB,CAAC;IA+G/D,OAAO,CAAC,gBAAgB;IAoBxB,SAAS;;;;;CAOV;AAED,eAAO,MAAM,oBAAoB,sBAA6B,CAAC"}

package/dist/services/deduplication-service.js

@@ -1,4 +1,3 @@
-import { embeddingService } from "./embedding.js";
 import { shardManager } from "./sqlite/shard-manager.js";
 import { vectorSearch } from "./sqlite/vector-search.js";
 import { connectionManager } from "./sqlite/connection-manager.js";
@@ -34,10 +33,9 @@ export class DeduplicationService {
                     }
                     contentMap.get(key).push(memory);
                 }
-                for (const [key, duplicates] of contentMap) {
+                for (const [, duplicates] of contentMap) {
                     if (duplicates.length > 1) {
                         duplicates.sort((a, b) => Number(b.created_at) - Number(a.created_at));
-                        const keep = duplicates[0];
                         const toDelete = duplicates.slice(1);
                         for (const dup of toDelete) {
                             try {

package/dist/services/logger.js

@@ -1,6 +1,6 @@
 import { appendFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { homedir } from "os";
-import { join, dirname } from "path";
+import { join } from "path";
 const LOG_DIR = join(homedir(), ".opencode-mem");
 const LOG_FILE = join(LOG_DIR, "opencode-mem.log");
 if (!existsSync(LOG_DIR)) {

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,75 @@ 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"}