@cjhyy/code-shell-core 0.6.0-rc.8 → 0.7.0-beta.1

package/dist/services/global-dream-promotion.js

@@ -0,0 +1,112 @@
+import { MemoryManager, resolveMemoryBaseDir } from "../session/memory.js";
+export function detectUserDirectGlobalPreference(transcript) {
+    const userText = transcript
+        .filter((m) => m.role === "user")
+        .map((m) => m.content)
+        .join("\n")
+        .toLowerCase();
+    return (/(?:全局记住|全局保存|所有项目|全部项目|以后所有项目|今后所有项目|以后都|以后默认|我偏好|我的偏好)/u.test(userText) ||
+        /(?:remember globally|global memory|all projects|every project|my preference|i prefer|always remember)/i.test(userText));
+}
+export function applyGlobalDreamPromotionGate(input) {
+    const baseDir = resolveMemoryBaseDir(input.baseDir);
+    const now = input.now ?? new Date();
+    const nowIso = now.toISOString();
+    const promotionReason = input.userDirectGlobal
+        ? "user-direct global preference suggested global dream approval"
+        : "candidate suggested global dream approval";
+    const projectEvidence = input.projectDir
+        ? saveProjectDreamCandidate({
+            baseDir,
+            projectDir: input.projectDir,
+            candidate: input.candidate,
+            nowIso,
+            promotionReason,
+        })
+        : undefined;
+    const originProjects = projectEvidence?.originProjects ?? (input.projectDir ? [input.projectDir] : []);
+    const rejected = projectEvidence?.promotionStatus === "rejected";
+    const pendingSuggested = !rejected &&
+        savePendingGlobalSuggestion({
+            baseDir,
+            projectDir: input.projectDir,
+            candidate: input.candidate,
+            source: projectEvidence,
+            originProjects,
+            nowIso,
+            promotionReason,
+        });
+    return {
+        promoted: false,
+        pendingSuggested,
+        originProjects,
+        evidenceCount: originProjects.length,
+        projectEvidenceSaved: Boolean(projectEvidence),
+        promotionReason,
+    };
+}
+function saveProjectDreamCandidate(input) {
+    const mm = new MemoryManager({
+        baseDir: input.baseDir,
+        projectDir: input.projectDir,
+        scope: "dream",
+    });
+    const existing = mm
+        .loadAll()
+        .find((entry) => entry.name === input.candidate.name &&
+        (entry.origin === "auto" || entry.origin === "dream"));
+    const originProjects = unique([...(existing?.originProjects ?? []), input.projectDir]);
+    const promotionStatus = existing?.promotionStatus === "rejected" ? "rejected" : "pending";
+    const fileName = mm.save({
+        id: existing?.id,
+        name: input.candidate.name,
+        description: input.candidate.description,
+        type: input.candidate.type,
+        content: input.candidate.content,
+        origin: existing?.origin ?? "auto",
+        pinned: existing?.pinned,
+        createdAt: existing?.createdAt,
+        useCount: existing?.useCount,
+        updateCount: existing?.updateCount,
+        lastUsedAt: existing?.lastUsedAt,
+        originProject: input.projectDir,
+        originProjects,
+        evidenceCount: originProjects.length,
+        firstSeenAt: existing?.firstSeenAt ?? existing?.createdAt ?? input.nowIso,
+        lastSeenAt: input.nowIso,
+        promotionReason: input.promotionReason,
+        promotionStatus,
+    }, { forceOrigin: existing?.origin ?? "auto" });
+    return mm.find(fileName);
+}
+function savePendingGlobalSuggestion(input) {
+    const globalDream = new MemoryManager({ baseDir: input.baseDir, scope: "dream" });
+    if (globalDream.loadAll().some((entry) => entry.name === input.candidate.name))
+        return false;
+    const pending = new MemoryManager({ baseDir: input.baseDir, scope: "pending" });
+    const duplicate = pending
+        .loadAll()
+        .some((entry) => entry.name === input.candidate.name &&
+        (entry.originProject ?? "") === (input.projectDir ?? ""));
+    if (duplicate)
+        return false;
+    pending.save({
+        name: input.candidate.name,
+        description: input.candidate.description,
+        type: input.candidate.type,
+        content: input.candidate.content,
+        origin: "dream",
+        originProject: input.projectDir,
+        originProjects: input.originProjects,
+        evidenceCount: input.originProjects.length,
+        firstSeenAt: input.source?.firstSeenAt ?? input.source?.createdAt ?? input.nowIso,
+        lastSeenAt: input.nowIso,
+        promotionReason: input.promotionReason,
+        promotionStatus: "pending",
+        promotionSourceId: input.source?.id,
+    }, { forceOrigin: "dream" });
+    return true;
+}
+function unique(values) {
+    return [...new Set(values.filter((value) => Boolean(value)))];
+}

package/dist/services/memory-orchestrator.js

@@ -12,12 +12,13 @@
  * The caller supplies `runDream`, which owns the LLM client and tool registry
  * — orchestrator just decides WHEN to trigger.
  */
-import { MemoryManager } from "../session/memory.js";
-import { buildExtractionPrompt, parseExtractionResponse } from "./extract-memories.js";
+import { MemoryManager, } from "../session/memory.js";
+import { buildExtractionPrompt, parseExtractionResponse, } from "./extract-memories.js";
 import { saveSessionMemory, buildSessionMemoryPrompt } from "./session-memory.js";
 import { extractJSON } from "../utils/json.js";
 import { redactSecrets } from "../logging/sanitize-messages.js";
-import { shouldAutoDream, recordSession, recordDreamComplete, buildDreamSystemPrompt, buildDreamUserPrompt } from "./auto-dream.js";
+import { shouldAutoDream, recordSession, recordDreamComplete, buildDreamSystemPrompt, buildDreamUserPrompt, } from "./auto-dream.js";
+import { applyGlobalDreamPromotionGate, detectUserDirectGlobalPreference, } from "./global-dream-promotion.js";
 import { logger } from "../logging/logger.js";
 export class MemoryOrchestrator {
     options;
@@ -45,7 +46,7 @@ export class MemoryOrchestrator {
         else
             try {
                 let t = Date.now();
-                const existing = mm.loadAll();
+                const existing = collectExistingMemorySummaries(mm, this.options.projectDir);
                 const loadMs = Date.now() - t;
                 t = Date.now();
                 const extractionPrompt = buildExtractionPrompt(transcript, existing);
@@ -57,45 +58,130 @@ export class MemoryOrchestrator {
                 const entries = parseExtractionResponse(response, this.options.maxCount);
                 const parseMs = Date.now() - t;
                 t = Date.now();
-                // Route by scope (用户拍板 审批门): "project" memories auto-land in the
-                // per-project store (`mm`). "global" memories do NOT auto-land global —
-                // they go to the GLOBAL pending scope and wait for the user to approve in
-                // the settings panel. Nothing auto-writes the injected global store.
-                let pendingMm = null;
-                let globalCount = 0;
+                let globalDreamCount = 0;
+                let pendingGlobalCount = 0;
+                let projectDreamCount = 0;
+                let addCount = 0;
+                let updateCount = 0;
+                let noopCount = 0;
+                let deleteCount = 0;
+                let guardedManualCount = 0;
+                const userDirectGlobal = detectUserDirectGlobalPreference(transcript);
                 for (const entry of entries) {
-                    const isGlobal = entry.scope === "global";
-                    const target = isGlobal
-                        ? (pendingMm ??= new MemoryManager({ scope: "pending" }))
-                        : mm;
-                    target.save({
-                        type: entry.type,
-                        name: entry.name,
-                        // Defense-in-depth: the extraction prompt forbids secrets, but a prompt
-                        // is not a guarantee. An auto-extracted memory is persisted with no user
-                        // review, so run the model-authored strings through the same
-                        // redactSecrets the logging path uses — a leaked key never lands on disk.
+                    const redactedEntry = {
+                        ...entry,
                         description: redactSecrets(entry.description),
                         content: redactSecrets(entry.content),
-                        // Provenance mark (feedback#18 方案 C): extractor writes are "auto"
-                        // so the UI can tell curated memories from extractor noise.
-                        origin: "auto",
-                        // 审批门: stamp the source project on pending entries so "不批准/降级"
-                        // can fall them back to the project they were extracted in.
-                        ...(isGlobal && this.options.projectDir
-                            ? { originProject: this.options.projectDir }
-                            : {}),
-                    });
-                    if (isGlobal)
-                        globalCount++;
+                    };
+                    const decision = await decideWriteAction(redactedEntry, existing, this.options.callLLM);
+                    switch (decision.action) {
+                        case "ADD": {
+                            const isGlobal = redactedEntry.scope === "global";
+                            if (isGlobal) {
+                                const promotion = applyGlobalDreamPromotionGate({
+                                    projectDir: this.options.projectDir,
+                                    candidate: redactedEntry,
+                                    userDirectGlobal,
+                                });
+                                if (promotion.projectEvidenceSaved)
+                                    projectDreamCount++;
+                                if (promotion.pendingSuggested)
+                                    pendingGlobalCount++;
+                                if (promotion.promoted)
+                                    globalDreamCount++;
+                                addCount++;
+                                break;
+                            }
+                            const target = memoryManagerForDecision("project", "dream", this.options.projectDir);
+                            target.save({
+                                type: redactedEntry.type,
+                                name: redactedEntry.name,
+                                description: redactedEntry.description,
+                                content: redactedEntry.content,
+                                origin: "auto",
+                                ...(isGlobal && this.options.projectDir
+                                    ? { originProject: this.options.projectDir }
+                                    : {}),
+                            }, { forceOrigin: "auto" });
+                            if (isGlobal)
+                                globalDreamCount++;
+                            else
+                                projectDreamCount++;
+                            addCount++;
+                            break;
+                        }
+                        case "UPDATE": {
+                            const targetId = decision.target?.id;
+                            if (!targetId) {
+                                noopCount++;
+                                break;
+                            }
+                            const location = decision.target?.location ?? redactedEntry.scope;
+                            const target = memoryManagerForDecision(location, "dream", this.options.projectDir);
+                            const existingTarget = target.findById(targetId);
+                            if (!existingTarget || !target.isOwnedBy(existingTarget, ["auto", "dream"])) {
+                                noopCount++;
+                                guardedManualCount += existingTarget?.origin === "manual" ? 1 : 0;
+                                break;
+                            }
+                            target.save({
+                                id: targetId,
+                                type: redactedEntry.type,
+                                name: redactedEntry.name,
+                                description: redactedEntry.description,
+                                content: redactedEntry.content,
+                                origin: existingTarget.origin ?? "auto",
+                                pinned: existingTarget.pinned,
+                                createdAt: existingTarget.createdAt,
+                                useCount: existingTarget.useCount,
+                                lastUsedAt: existingTarget.lastUsedAt,
+                                originProject: existingTarget.originProject,
+                            }, { forceOrigin: existingTarget.origin ?? "auto" });
+                            if (location === "global")
+                                globalDreamCount++;
+                            else
+                                projectDreamCount++;
+                            updateCount++;
+                            break;
+                        }
+                        case "DELETE": {
+                            const targetId = decision.target?.id;
+                            const location = decision.target?.location ?? redactedEntry.scope;
+                            const target = memoryManagerForDecision(location, "dream", this.options.projectDir);
+                            if (!targetId) {
+                                noopCount++;
+                                break;
+                            }
+                            const deleteResult = target.deleteIfOwned(targetId, ["auto", "dream"]);
+                            if (deleteResult === "deleted")
+                                deleteCount++;
+                            else {
+                                noopCount++;
+                                if (deleteResult === "protected")
+                                    guardedManualCount++;
+                            }
+                            break;
+                        }
+                        case "NOOP":
+                            noopCount++;
+                            if (decision.guardedManual)
+                                guardedManualCount++;
+                            break;
+                    }
                 }
                 const saveMs = Date.now() - t;
                 extracted = entries.length;
                 logger.info("memory.extraction_done", {
                     sessionId,
                     extracted,
-                    pendingGlobalCount: globalCount, // global candidates queued for approval
-                    projectCount: extracted - globalCount,
+                    globalDreamCount,
+                    pendingGlobalCount,
+                    projectDreamCount,
+                    addCount,
+                    updateCount,
+                    noopCount,
+                    deleteCount,
+                    guardedManualCount,
                     elapsedMs: Date.now() - startTime,
                     loadMs,
                     promptMs,
@@ -224,3 +310,230 @@ export class MemoryOrchestrator {
         return { extracted, dreamTriggered, pruned };
     }
 }
+function memoryManagerForDecision(location, scope, projectDir) {
+    return new MemoryManager({
+        projectDir: location === "project" ? projectDir : undefined,
+        scope,
+    });
+}
+function collectExistingMemorySummaries(projectUserManager, projectDir) {
+    const seen = new Set();
+    const out = [];
+    const add = (entries, location, memoryScope) => {
+        for (const entry of entries) {
+            const key = `${location}:${memoryScope}:${entry.fileName}:${entry.id ?? ""}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({
+                id: entry.id,
+                name: entry.name,
+                type: entry.type,
+                description: entry.description,
+                location,
+                memoryScope,
+                origin: entry.origin ?? "manual",
+                pinned: entry.pinned,
+                useCount: entry.useCount,
+                updateCount: entry.updateCount,
+                updatedAt: entry.updatedAt,
+                entry,
+            });
+        }
+    };
+    add(projectUserManager.loadScope("user"), "project", "user");
+    add(memoryManagerForDecision("project", "dream", projectDir).loadAll(), "project", "dream");
+    add(memoryManagerForDecision("global", "dream", projectDir).loadAll(), "global", "dream");
+    add(memoryManagerForDecision("global", "user", projectDir).loadAll(), "global", "user");
+    return out
+        .sort((a, b) => {
+        const aTime = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
+        const bTime = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
+        return bTime - aTime;
+    })
+        .slice(0, 120);
+}
+async function decideWriteAction(candidate, existing, callLLM) {
+    const fallback = fallbackWriteDecision(candidate, existing);
+    const related = rankRelated(candidate, existing).slice(0, 40);
+    const llmDecision = await askLLMForWriteDecision(candidate, related.map((r) => r.summary), callLLM);
+    if (!llmDecision)
+        return fallback;
+    const target = llmDecision.target?.id
+        ? existing.find((m) => m.id === llmDecision.target?.id)
+        : undefined;
+    if ((llmDecision.action === "UPDATE" || llmDecision.action === "DELETE") && target) {
+        if (target.origin === "manual") {
+            return {
+                action: "NOOP",
+                memory: candidate,
+                reason: "manual memory is protected",
+                guardedManual: true,
+            };
+        }
+        if (target.memoryScope === "dream" && (target.origin === "auto" || target.origin === "dream")) {
+            return {
+                ...llmDecision,
+                memory: candidate,
+                target: {
+                    id: target.id,
+                    location: target.location,
+                    scope: "dream",
+                },
+            };
+        }
+    }
+    // Downgrade unsafe or duplicate ADDs using the deterministic guard.
+    if (llmDecision.action === "ADD" && fallback.action !== "ADD")
+        return fallback;
+    if (llmDecision.action === "NOOP")
+        return { ...llmDecision, memory: candidate };
+    if (llmDecision.action === "ADD")
+        return { ...llmDecision, memory: candidate };
+    return fallback;
+}
+async function askLLMForWriteDecision(candidate, related, callLLM) {
+    if (related.length === 0)
+        return null;
+    try {
+        const relatedText = related
+            .map((m) => `- id:${m.id ?? "(none)"} location:${m.location} scope:${m.memoryScope} origin:${m.origin} ` +
+            `[${m.type}] ${m.name}: ${m.description}`)
+            .join("\n");
+        const response = await callLLM("You are a memory write decision assistant. Output only one JSON object.", [
+            "Decide whether this automatic memory candidate should ADD, UPDATE, NOOP, or DELETE.",
+            "Manual memories are protected: if the target is origin:manual, choose NOOP.",
+            "Automatic extraction writes new entries only to dream. Reuse an existing auto/dream dream id for same-topic updates.",
+            "",
+            "Candidate:",
+            JSON.stringify(candidate),
+            "",
+            "Related existing memories:",
+            relatedText,
+            "",
+            'Respond with JSON: {"action":"ADD|UPDATE|DELETE|NOOP","target":{"id":"...","location":"project|global","scope":"dream|user"},"reason":"short","confidence":"high|medium|low"}',
+        ].join("\n"));
+        const parsed = JSON.parse(extractJSON(response));
+        const action = typeof parsed.action === "string" ? parsed.action.toUpperCase() : "";
+        if (!["ADD", "UPDATE", "DELETE", "NOOP"].includes(action))
+            return null;
+        const location = parsed.target?.location === "global" || parsed.target?.location === "project"
+            ? parsed.target.location
+            : candidate.scope;
+        const scope = parsed.target?.scope === "user" ? "user" : "dream";
+        return {
+            action: action,
+            target: parsed.target?.id ? { id: String(parsed.target.id), location, scope } : undefined,
+            memory: candidate,
+            reason: typeof parsed.reason === "string" ? parsed.reason : "llm decision",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function fallbackWriteDecision(candidate, existing) {
+    const ranked = rankRelated(candidate, existing);
+    const strong = ranked.filter((m) => m.score >= 0.55 || m.canonicalMatch);
+    const manual = strong.find((m) => m.summary.origin === "manual");
+    if (manual) {
+        return {
+            action: "NOOP",
+            memory: candidate,
+            reason: `same topic as manual memory ${manual.summary.id ?? manual.summary.name}`,
+            guardedManual: true,
+        };
+    }
+    const ownedDream = strong.find((m) => m.summary.location === candidate.scope &&
+        m.summary.memoryScope === "dream" &&
+        (m.summary.origin === "auto" || m.summary.origin === "dream") &&
+        m.summary.id &&
+        !m.summary.id.startsWith("legacy:"));
+    if (ownedDream?.summary.id) {
+        return {
+            action: "UPDATE",
+            target: {
+                id: ownedDream.summary.id,
+                location: ownedDream.summary.location,
+                scope: "dream",
+            },
+            memory: candidate,
+            reason: `same topic as auto/dream memory ${ownedDream.summary.id}`,
+        };
+    }
+    return { action: "ADD", memory: candidate, reason: "new automatic candidate" };
+}
+function rankRelated(candidate, existing) {
+    const candidateText = `${candidate.name} ${candidate.description}`;
+    const candidateKey = canonicalKey(candidateText);
+    const candidateTokens = tokenSet(candidateText);
+    return existing
+        .map((summary) => {
+        const existingText = `${summary.name} ${summary.description}`;
+        const existingKey = canonicalKey(existingText);
+        const existingTokens = tokenSet(existingText);
+        return {
+            summary,
+            score: tokenOverlap(candidateTokens, existingTokens),
+            canonicalMatch: candidateKey.length > 0 && candidateKey === existingKey,
+        };
+    })
+        .sort((a, b) => {
+        if (a.canonicalMatch !== b.canonicalMatch)
+            return a.canonicalMatch ? -1 : 1;
+        if (a.score !== b.score)
+            return b.score - a.score;
+        const aOwned = a.summary.origin === "auto" || a.summary.origin === "dream" ? 1 : 0;
+        const bOwned = b.summary.origin === "auto" || b.summary.origin === "dream" ? 1 : 0;
+        if (aOwned !== bOwned)
+            return bOwned - aOwned;
+        const aTime = a.summary.updatedAt ? new Date(a.summary.updatedAt).getTime() : 0;
+        const bTime = b.summary.updatedAt ? new Date(b.summary.updatedAt).getTime() : 0;
+        return bTime - aTime;
+    });
+}
+function canonicalKey(text) {
+    return [...tokenSet(text)].sort().join(" ");
+}
+function tokenSet(text) {
+    const normalized = text
+        .toLowerCase()
+        .replace(/\b\d{4}-\d{2}-\d{2}\b/g, " ")
+        .replace(/\b\d{8}\b/g, " ")
+        .replace(/\b(today|yesterday|tomorrow|本轮|今天|昨天|明天)\b/g, " ")
+        .replace(/\bv\d+\b/g, " ")
+        .replace(/\b(batch|fix-batch)-\d+\b/g, " ")
+        .replace(/\b[a-f0-9]{7,}\b/g, " ")
+        .replace(/[\d]+/g, " ")
+        .replace(/[^a-z0-9\u4e00-\u9fff]+/g, " ");
+    const stop = new Set([
+        "the",
+        "and",
+        "for",
+        "with",
+        "that",
+        "this",
+        "from",
+        "memory",
+        "memories",
+        "should",
+        "must",
+        "不要",
+        "需要",
+        "已经",
+    ]);
+    return new Set(normalized
+        .split(/\s+/)
+        .map((t) => t.trim())
+        .filter((t) => t.length > 2 && !stop.has(t)));
+}
+function tokenOverlap(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let shared = 0;
+    for (const token of a) {
+        if (b.has(token))
+            shared++;
+    }
+    return shared / Math.min(a.size, b.size);
+}