agentlas 0.9.10 → 1.0.2

package/engine/project/memory-context.cjs

@@ -0,0 +1,453 @@
+"use strict";
+/*
+ * project/memory-context — 프로젝트 메모리 주입/큐레이션 (v1 monolith 8285–8330,
+ * 8691–8925, 9044–9054, 9446–9495 포팅).
+ *
+ * 계약:
+ *  - read 권한 실행은 어떤 durable 메모리도 쓰지 않는다: Memory Events 블록은
+ *    사용자 출력에서 제거만 하고 버린다 (curateCliReply), emitter 프롬프트도
+ *    durable write를 요청하지 않는다 (augmentSystem withEmitter의 receipt-only).
+ *  - 비밀(SECRET_RE 매치)은 메모리/로그에 절대 저장하지 않는다.
+ *  - 컨텍스트 슬라이스는 Core 런타임이 있을 때만 붙는다 — 없으면 조용히 생략
+ *    (시스템 프롬프트 보강은 best-effort). 명시적 `agentlas context` 명령의
+ *    정직 정지는 commands/context.cjs 가 소유한다.
+ */
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+const { userDataDir } = require("../core/paths.cjs");
+const { loadArch, tableExists, columnExists } = require("../core/db.cjs");
+const { captureCoreJsonSync, resolveCoreRuntimeRoot } = require("../agentlas-core-harness.cjs");
+const terminalMemoryGovernance = require("../agentlas-memory-governance.cjs");
+const terminalExperienceIntake = require("../agentlas-experience-intake.cjs");
+const terminalExperienceExchange = require("../agentlas-experience-exchange.cjs");
+const { routesMap } = require("../agents/routes.cjs");
+const { agentFolder } = require("../agents/files.cjs");
+const { ensureProjectMemoryCli } = require("./seed.cjs");
+const { projectCwd } = require("./paths.cjs");
+
+const SECRET_RE = [/\b(?:sk|pk|rk)-[A-Za-z0-9]{16,}/, /AKIA[0-9A-Z]{16}/, /ghp_[A-Za-z0-9]{20,}/, /xox[baprs]-[A-Za-z0-9-]{10,}/, /-----BEGIN [A-Z ]*PRIVATE KEY-----/, /\b(?:password|passwd|secret|api[_-]?key|access[_-]?token|bearer)\b\s*[:=]\s*\S+/i];
+
+function sha(value) {
+  return crypto.createHash("sha256").update(value).digest("hex");
+}
+
+function ensureMemoryContextColumn(db) {
+  try {
+    if (tableExists(db, "memory_entries") && !columnExists(db, "memory_entries", "context_json")) {
+      db.exec("ALTER TABLE memory_entries ADD COLUMN context_json TEXT NOT NULL DEFAULT '{}'");
+    }
+  } catch { /* ignore */ }
+}
+
+function prefsLangCli() {
+  try {
+    const prefs = require("../agentlas-config.cjs").loadPrefs(userDataDir());
+    return prefs.lang || prefs.language || "en";
+  } catch {
+    return "en";
+  }
+}
+
+function langDirective(lang) {
+  return require("../agentlas-style.cjs").responseDirective(lang);
+}
+
+function logCli(projectPath, rec) {
+  if (!projectPath) return;
+  try {
+    // 0.9.10 경계: 초기화되지 않은 프로젝트에 시드를 만들지 않는다. 로그는
+    // 이미 존재하는 .agentlas/ 에만 덧붙인다 (seed는 project init 전용).
+    const { initializedAgentlasProjectPathCli } = require("./state.cjs");
+    if (!initializedAgentlasProjectPathCli(projectPath)) return;
+    const dir = ensureProjectMemoryCli(projectPath);
+    if (!dir) return;
+    fs.appendFileSync(path.join(dir, loadArch().logFile || "memory-log.jsonl"), JSON.stringify(rec) + "\n", "utf8");
+  } catch { /* ignore */ }
+}
+
+function coerceText(v, max) {
+  if (typeof v !== "string") return undefined;
+  const s = v.trim();
+  return s ? s.slice(0, max) : undefined;
+}
+function coerceNullableText(v, max) {
+  if (v === null) return null;
+  return coerceText(v, max);
+}
+function normalizeRequestContext(ev, ctx, projectPath) {
+  const raw = ev && ev.request_context && typeof ev.request_context === "object" ? ev.request_context : {};
+  const triggerTerms = Array.isArray(raw.trigger_terms)
+    ? [...new Set(raw.trigger_terms.filter((x) => typeof x === "string").map((x) => x.trim()).filter(Boolean))]
+        .slice(0, 12)
+        .map((x) => x.slice(0, 40))
+    : undefined;
+  const cwd = coerceNullableText(raw.cwd_at_request, 500) ?? ctx.cwdAtRequest ?? ctx.cwd ?? ctx.projectPath ?? null;
+  const targetProject = coerceNullableText(raw.target_project, 120) ?? ctx.projectId ?? null;
+  const targetPath = coerceNullableText(raw.target_path, 500) ?? projectPath ?? null;
+  const out = {};
+  const userIntent = coerceText(raw.user_intent, 240);
+  const outcome = coerceNullableText(raw.outcome, 240);
+  if (userIntent) out.user_intent = userIntent;
+  if (triggerTerms && triggerTerms.length) out.trigger_terms = triggerTerms;
+  if (cwd !== undefined) out.cwd_at_request = cwd;
+  if (targetProject !== undefined) out.target_project = targetProject;
+  if (targetPath !== undefined) out.target_path = targetPath;
+  out.cross_context = typeof raw.cross_context === "boolean" ? raw.cross_context : !!(cwd && targetPath && cwd !== targetPath);
+  if (outcome !== undefined) out.outcome = outcome;
+  if (SECRET_RE.some((re) => re.test(JSON.stringify(out)))) return {};
+  return Object.keys(out).length ? out : {};
+}
+function contextLine(json) {
+  try {
+    const ctx = JSON.parse(json || "{}");
+    const parts = [
+      ctx.user_intent || ctx.userIntent,
+      (ctx.target_project || ctx.targetProject) ? `target:${ctx.target_project || ctx.targetProject}` : null,
+      Array.isArray(ctx.trigger_terms || ctx.triggerTerms) && (ctx.trigger_terms || ctx.triggerTerms).length
+        ? `terms:${(ctx.trigger_terms || ctx.triggerTerms).join(",")}`
+        : null,
+    ].filter(Boolean);
+    return parts.length ? ` (context: ${parts.join("; ").slice(0, 180)})` : "";
+  } catch {
+    return "";
+  }
+}
+
+function cliProjectContextSlice(projectPath, task) {
+  if (!projectPath || !String(task || "").trim()) return "";
+  try {
+    const coreRoot = resolveCoreRuntimeRoot();
+    if (!coreRoot) return "";
+    const result = captureCoreJsonSync(
+      "agentlas_cloud",
+      [
+        "context", "slice",
+        "--project", projectPath,
+        "--task-stdin",
+        "--no-refresh",
+        "--render",
+      ],
+      {
+        cwd: projectPath,
+        input: String(task || "").slice(0, 12_000),
+        timeout: 4_000,
+      },
+      coreRoot,
+    );
+    return result
+      && result.schemaVersion === "agentlas.context-slice.v1"
+      && typeof result.rendered === "string"
+      ? result.rendered.trim()
+      : "";
+  } catch {
+    return "";
+  }
+}
+
+function cliMemoryContext(db, projectPath, agentId = null, task = "") {
+  const sections = [];
+  const arch = loadArch();
+  ensureMemoryContextColumn(db);
+  if (projectPath) {
+    try {
+      const soulPath = path.join(projectPath, arch.memoryDir || ".agentlas", arch.soulFile || "project-soul-memory.md");
+      if (fs.existsSync(soulPath)) {
+        let s = fs.readFileSync(soulPath, "utf8");
+        if (s.length > 1800) s = s.slice(0, 1800) + "\n…(truncated)";
+        if (s.trim()) sections.push(`### Project memory (${projectPath})\n${s.trim()}`);
+      }
+    } catch { /* ignore */ }
+    const contextSlice = cliProjectContextSlice(projectPath, task);
+    if (contextSlice) sections.push(contextSlice);
+  }
+  if (tableExists(db, "memory_entries")) {
+    try {
+      // New writes are read through a scoped global<->project timeline. The
+      // project key is a digest, and team/agent lanes additionally require the
+      // current owner id, so project B cannot recall project A's local memory.
+      const governed = terminalMemoryGovernance.listScopedTimeline(db, {
+        projectPath,
+        agentId,
+        limit: 16,
+      });
+      const seen = new Set(governed.map((row) => row.id));
+      // Legacy rows predate the timeline. Keep only intentional user-global
+      // rows, this exact project, and this exact agent/team owner. In
+      // particular, do not revive the old global team-memory leakage query.
+      const legacy = projectPath
+        ? db.prepare(`
+            SELECT id,kind,content,context_json,created_at
+            FROM memory_entries
+            WHERE superseded_at IS NULL AND (
+              (scope='user_identity' AND project_path IS NULL)
+              OR (scope='project' AND project_path=?)
+              OR (scope IN ('team_memory','agent_team','agent_repo') AND agent_id=? AND (project_path IS NULL OR project_path=?))
+            )
+            ORDER BY created_at DESC LIMIT 16
+          `).all(projectPath, agentId, projectPath)
+        : db.prepare(`
+            SELECT id,kind,content,context_json,created_at
+            FROM memory_entries
+            WHERE superseded_at IS NULL AND (
+              (scope='user_identity' AND project_path IS NULL)
+              OR (scope IN ('team_memory','agent_team','agent_repo') AND agent_id=? AND project_path IS NULL)
+            )
+            ORDER BY created_at DESC LIMIT 16
+          `).all(agentId);
+      const rows = [...governed, ...legacy.filter((row) => !seen.has(row.id))].slice(0, 16);
+      if (rows.length) {
+        sections.push(
+          (projectPath ? "### Scoped global + current-project memory timeline\n" : "### Curated user-global memory\n") +
+          rows.map((r) => `- [${r.kind}] ${r.content}${contextLine(r.context_json)}`).join("\n"),
+        );
+      }
+    } catch { /* ignore */ }
+  }
+  if (!sections.length) return "";
+  return "## Agentlas memory (read before answering; governed scope recall)\n\n" + sections.join("\n\n");
+}
+
+function parseMemoryEventsCli(text) {
+  const heading = loadArch().eventsHeading || "## Memory Events";
+  const idx = text.lastIndexOf(heading);
+  if (idx < 0) return { events: [], cleaned: text.trim() };
+  const after = text.slice(idx + heading.length);
+  const fence = after.match(/```(?:json)?\s*([\s\S]*?)```/);
+  let events = [];
+  if (fence) { try { const d = JSON.parse(fence[1].trim()); if (Array.isArray(d)) events = d; } catch { /* ignore */ } }
+  let cut = text.length;
+  if (fence && fence.index != null) cut = idx + heading.length + fence.index + fence[0].length;
+  const before = text.slice(0, idx).replace(/<!--\s*$/u, "");
+  const remainder = text.slice(cut).replace(/^\s*-->/u, "");
+  return { events, cleaned: (before + remainder).trim() };
+}
+
+function curateCliReply(db, text, ctx) {
+  const { events, cleaned } = parseMemoryEventsCli(text);
+  const style = require("../agentlas-style.cjs");
+  // read 권한: 어떤 durable write도 없이 숨김 메타데이터만 제거해 돌려준다.
+  if (ctx && ctx.permission === "read") return style.sanitizeAssistantText(cleaned);
+  if (!events.length || !tableExists(db, "memory_entries")) return style.sanitizeAssistantText(cleaned);
+  ensureMemoryContextColumn(db);
+  const arch = loadArch();
+  const { randomUUID } = require("node:crypto");
+  const now = new Date().toISOString();
+  const rememberCurated = (memory) => {
+    if (!ctx || !Array.isArray(ctx.curatedMemories) || !memory) return;
+    if (!ctx.curatedMemories.some((item) => item.id === memory.id)) ctx.curatedMemories.push(memory);
+  };
+  const kinds = Array.isArray(arch.kinds) ? arch.kinds : [];
+  const scopes = Array.isArray(arch.scopes) ? arch.scopes : [];
+  for (const ev of events) {
+    const content = ev && typeof ev.content === "string" ? ev.content.trim() : "";
+    if (!content) continue;
+    if (ev.sensitivity === "secret" || SECRET_RE.some((re) => re.test(content))) continue;
+    const kind = kinds.includes(ev.memory_kind) ? ev.memory_kind : "fact";
+    let scope = ev.suggested_scope === "agent_team"
+      ? "team_memory"
+      : scopes.includes(ev.suggested_scope) ? ev.suggested_scope : "session";
+    const kindAllowsUserIdentity = ["fact", "decision", "preference", "procedure"].includes(kind);
+    if (scope === "user_identity" && (ev.confidence !== "high" || !kindAllowsUserIdentity)) scope = "session";
+    if (scope === "discard" || scope === "session") { logCli(ctx.projectPath, { action: scope, kind, content, at: now }); continue; }
+    if (scope === "project" && !ctx.projectPath) scope = "team_memory";
+    const ppath = scope === "project" ? ctx.projectPath : null;
+    const requestContext = normalizeRequestContext(ev, ctx, ppath);
+    try {
+      const dup = db.prepare("SELECT id,scope,kind,content,confidence,sensitivity,context_json FROM memory_entries WHERE scope=? AND kind=? AND lower(trim(content))=? AND superseded_at IS NULL AND (project_path IS ? OR project_path=?) LIMIT 1").get(scope, kind, content.toLowerCase(), ppath, ppath);
+      if (dup) {
+        rememberCurated({ ...dup, requestContext });
+        continue;
+      }
+      const memoryId = randomUUID();
+      const confidence = ev.confidence || "medium";
+      const sensitivity = ev.sensitivity || "internal";
+      db.prepare("INSERT INTO memory_entries (id,scope,kind,content,project_id,project_path,agent_id,chat_id,confidence,sensitivity,evidence_json,context_json,superseded_at,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,NULL,?)").run(memoryId, scope, kind, content, ctx.projectId || null, ppath, ctx.agentId || null, null, confidence, sensitivity, JSON.stringify(Array.isArray(ev.evidence_refs) ? ev.evidence_refs : []), JSON.stringify(requestContext), now);
+      rememberCurated({ id: memoryId, scope, kind, content, confidence, sensitivity, requestContext });
+      logCli(ctx.projectPath, { action: "written", scope, kind, content, request_context: requestContext, at: now });
+    } catch { /* ignore */ }
+  }
+  return style.sanitizeAssistantText(cleaned);
+}
+
+const TERMINAL_MEMORY_CORE_MAX_TOKENS = 150;
+const TERMINAL_MEMORY_CORE = [
+  "## Memory governance",
+  "End every completed reply with hidden `## Memory Events` plus fenced JSON:",
+  '{"turn_id":"<stable-id>","observation":{"outcome":"completed","summary":"safe short outcome"},"candidates":[]}',
+  "Candidates 0..N: memory_kind,content,suggested_scope,confidence.",
+  "Scopes: user_global|team|agent|project|session|discard.",
+  "No raw prompts/transcripts, secrets, logs, or absolute paths. Curator suggests; deterministic gates decide writes.",
+].join("\n");
+const MEMORY_DETAIL_RE = /\b(?:remember|memory|save this|record this|memory event)\b|기억|메모리|저장해|기록해|남겨/i;
+const CREDENTIAL_INDEX_RE = /\b(?:deploy|release|billing|auth|oauth|credential|api key|secret key|cloud)\b|배포|릴리스|출시|결제|인증|자격 증명|API\s*키|시크릿|클라우드/i;
+
+function approximatePromptTokens(text) {
+  return Math.ceil(Buffer.byteLength(String(text || ""), "utf8") / 3);
+}
+if (approximatePromptTokens(TERMINAL_MEMORY_CORE) > TERMINAL_MEMORY_CORE_MAX_TOKENS) {
+  throw new Error("Terminal always-on memory core exceeds 150 tokens");
+}
+
+function memoryEmitterPromptFor(request, arch = loadArch(), turnId = null, permission = "write") {
+  const stableId = String(turnId || "").replace(/[^A-Za-z0-9:._-]/g, "").slice(0, 160);
+  let prompt = TERMINAL_MEMORY_CORE;
+  if (stableId) prompt += `\nUse turn_id=${stableId}. permission=${permission === "read" ? "receipt-only" : "curated-write"}.`;
+  if (!MEMORY_DETAIL_RE.test(String(request || ""))) return prompt;
+  const kinds = Array.isArray(arch?.kinds) && arch.kinds.length ? arch.kinds.join("|") : "fact|decision|preference|risk|procedure";
+  prompt += [
+    "",
+    `Allowed memory_kind: ${kinds}.`,
+    "Global requires explicit owner authorization; suggest only, never promote.",
+    "Do not emit request_context; put only a safe, short outcome in observation.",
+  ].join("\n");
+  return prompt;
+}
+
+function credentialIndexReminderFor(request) {
+  if (!CREDENTIAL_INDEX_RE.test(String(request || ""))) return "";
+  return [
+    "## Local credential lookup (triggered)",
+    "Before saying a deploy, release, billing, auth, API, or cloud credential is missing, read `.agentlas/local-credentials.map.json` and the Local Credential Index in `.agentlas/project-soul-memory.md`.",
+    "Use only env names and local relative references; never copy credential values into memory or output.",
+  ].join("\n");
+}
+
+function loadGlobalConnectionSkill() {
+  try {
+    return require("../dist/electron/runtime/global-skill.js").GLOBAL_CONNECTION_SKILL || "";
+  } catch {
+    return [
+      "## Connecting accounts for the user (always-on background skill)",
+      "When the task needs Slack, Gmail, Google Cloud, Firebase, a database, store release access, or another third-party service, open the provider website with the browser tool when available, guide the user one tiny step at a time, and save the issued credential with `agentlas creds save --provider <name> --key <ENV_NAME> --value \"<value>\" --project \"<cwd>\"` or `agentlas creds file --source <path> --provider <name> --env <ENV_NAME> --project \"<cwd>\"`.",
+      "Do not lecture the user about security in this local single-user setup; make the connection effortless.",
+    ].join("\n\n");
+  }
+}
+
+function augmentSystem(db, baseSystem, ctx, withEmitter, request = "") {
+  const arch = loadArch();
+  let sys = baseSystem || "";
+  // 언어/말투 지시를 맨 앞에 둔다. imported/cloud/company agents도 같은 전역 계약을 따른다.
+  const lang = (ctx && ctx.lang) || prefsLangCli();
+  sys = langDirective(lang) + (sys ? "\n\n" + sys : "");
+  const connectionSkill = loadGlobalConnectionSkill();
+  if (connectionSkill) sys += "\n\n" + connectionSkill;
+  const mem = cliMemoryContext(db, ctx && ctx.projectPath, ctx && ctx.agentId, request);
+  if (mem) sys += "\n\n" + mem;
+  if (withEmitter) {
+    sys += "\n\n" + memoryEmitterPromptFor(request, arch, ctx && ctx.turnId, ctx && ctx.permission);
+    const credentialReminder = credentialIndexReminderFor(request);
+    if (credentialReminder) sys += "\n\n" + credentialReminder;
+  }
+  return sys;
+}
+
+function exactAgentBaseForExecution(db, agent, runtimeExperience = null) {
+  if (!agent || agent.builtin) return null;
+  const portableId = /^[A-Za-z0-9][A-Za-z0-9._:/@-]{2,255}$/;
+  let binding = null;
+  try {
+    if (tableExists(db, "installed_agent_hub_bindings")) {
+      binding = db.prepare(
+        "SELECT agent_definition_id,agent_release_id FROM installed_agent_hub_bindings WHERE installed_agent_id=?",
+      ).get(agent.id) || null;
+    }
+  } catch { binding = null; }
+  const route = routesMap()[agent.id] || {};
+  const markerResult = terminalExperienceExchange.readExactLocalBaseMarker(agentFolder(agent), agent.slug);
+  const marker = markerResult.marker;
+  const rawHash = String(marker?.packageHash || route.packageHash || route.definitionHash || "").replace(/^sha256:/i, "").toLowerCase();
+  const packageHash = /^[a-f0-9]{64}$/.test(rawHash) ? `sha256:${rawHash}` : null;
+  const explicitDefinition = String(runtimeExperience?.agentDefinitionId || "");
+  const explicitRelease = String(runtimeExperience?.baseAgentReleaseId || "");
+  if (portableId.test(explicitDefinition) && portableId.test(explicitRelease)) {
+    return { agentDefinitionId: explicitDefinition, agentReleaseId: explicitRelease, packageHash, authority: "explicit-runtime-binding" };
+  }
+  if (binding && portableId.test(String(binding.agent_definition_id)) && portableId.test(String(binding.agent_release_id))) {
+    return { agentDefinitionId: binding.agent_definition_id, agentReleaseId: binding.agent_release_id, packageHash, authority: "installed-hub-binding" };
+  }
+  if (!packageHash) return null;
+  const definitionDigest = sha(`terminal-local-definition\0${agent.id}\0${agent.slug}`);
+  const releaseDigest = sha(`terminal-local-release\0${definitionDigest}\0${packageHash}`);
+  return {
+    agentDefinitionId: `local-agent-definition:${definitionDigest.slice(0, 32)}`,
+    agentReleaseId: `local-agent-release:${releaseDigest.slice(0, 32)}`,
+    packageHash,
+    authority: "exact-local-package-hash",
+  };
+}
+
+function finalizeExperienceExecutionCli(db, input) {
+  if (input.permission === "read") return null;
+  if (!input.agentId) return null;
+  let agent;
+  try { agent = db.prepare("SELECT * FROM installed_agents WHERE id=?").get(input.agentId); }
+  catch { return null; }
+  if (!agent) return null;
+  const exactBase = exactAgentBaseForExecution(db, agent, input.runtimeExperience);
+  if (!exactBase) return null;
+  const runtime = input.runtime || {};
+  const provider = runtime.mode === "cli" ? runtime.kind : runtime.backend;
+  const modelId = input.model || runtime.model || provider;
+  const usage = input.usage || {};
+  try {
+    return terminalExperienceIntake.finalizeAgentExecution({
+      db,
+      userDataDir: userDataDir(),
+      cwd: input.cwd || input.projectPath || projectCwd(),
+      agent,
+      exactBase,
+      environment: { runtime: provider || "terminal", os: process.platform, arch: process.arch },
+      model: { provider: provider || "terminal-runtime", modelId: modelId || "terminal-runtime" },
+      mcp: (input.mcpServers || []).flatMap((server) => {
+        const catalogId = server.catalog_id || server.catalogId;
+        // A reviewed runtime allowlist proves approval, not that this turn's
+        // child completed an MCP initialize/tool call. Do not inflate it into
+        // connected evidence without an exact runtime signal.
+        return catalogId ? [{ catalogId, status: "approved" }] : [];
+      }),
+      outcome: input.outcome,
+      metrics: {
+        promptTokens: usage.input_tokens || usage.prompt_tokens || 0,
+        completionTokens: usage.output_tokens || usage.completion_tokens || 0,
+        totalTokens: usage.total_tokens || 0,
+        durationMs: input.durationMs || usage.duration_ms || 0,
+        retryCount: 0,
+      },
+      curatedMemories: input.curatedMemories || [],
+      taskHint: input.taskHint,
+      taskSignatures: input.runtimeExperience?.taskSignatures || [],
+      experiencePackReleaseId: input.runtimeExperience?.experiencePackReleaseIds?.[0] || null,
+      locale: input.lang || prefsLangCli(),
+      runId: input.runId,
+      createdAt: input.createdAt,
+    });
+  } catch (error) {
+    process.stderr.write(`▸ local Experience intake skipped · ${String((error && error.message) || error).slice(0, 180)}\n`);
+    return null;
+  }
+}
+
+module.exports = {
+  SECRET_RE,
+  TERMINAL_MEMORY_CORE,
+  TERMINAL_MEMORY_CORE_MAX_TOKENS,
+  ensureMemoryContextColumn,
+  prefsLangCli,
+  langDirective,
+  logCli,
+  normalizeRequestContext,
+  contextLine,
+  cliProjectContextSlice,
+  cliMemoryContext,
+  parseMemoryEventsCli,
+  curateCliReply,
+  approximatePromptTokens,
+  memoryEmitterPromptFor,
+  credentialIndexReminderFor,
+  loadGlobalConnectionSkill,
+  augmentSystem,
+  exactAgentBaseForExecution,
+  finalizeExperienceExecutionCli,
+};