kodingo-cli 1.0.31 → 1.0.33

package/dist/commands/context.js

@@ -73,6 +73,16 @@ async function contextCommand(filePath, options) {
         }
         const data = await res.json();
         const memories = data.memories ?? [];
+        // Send metadata signal for each memory — agent queried it, that is weak evidence of relevance
+        for (const m of memories) {
+            if (m.id) {
+                fetch(`${apiUrl}/memory/${m.id}/evidence`, {
+                    method: "PATCH",
+                    headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+                    body: JSON.stringify({ weightClass: "metadata" }),
+                }).catch(() => { });
+            }
+        }
         if (!options.prompt) {
             console.log(JSON.stringify({ file: relFile, repo: repoName, count: memories.length, memories }, null, 2));
             return;

package/dist/commands/scan-git.js

@@ -104,6 +104,37 @@ async function scanGitCommand(options) {
     const adapter = new git_listener_1.GitListenerAdapter(repoRoot, eventPort, 5000);
     await adapter.runOnceLatest();
     console.log(`Git scan complete (latest commit) for repo: ${repoRoot} commit: ${commitHash.slice(0, 8)}`);
+    // Send code_change signals for functions touched in this commit that already have memory
+    try {
+        const { token, apiUrl } = getCredentials(repoRoot);
+        const diffOutput = await git.diff([`${commitHash}^`, commitHash, '--name-only']).catch(() => '');
+        const commitChangedFiles = diffOutput.split('\n').filter(Boolean).map((f) => path_1.default.join(repoRoot, f)).filter((f) => /\.(ts|tsx|js|jsx|py|go|rs|php|java|kt|rb)$/.test(f));
+        if (token && commitChangedFiles.length > 0) {
+            const repoName = path_1.default.basename(repoRoot);
+            for (const filePath of commitChangedFiles) {
+                if (!fs_1.default.existsSync(filePath))
+                    continue;
+                const source = fs_1.default.readFileSync(filePath, "utf-8");
+                const nodes = await (0, ast_parser_1.parseFile)(filePath, source);
+                for (const node of nodes) {
+                    // Check if memory exists for this symbol
+                    const res = await fetch(`${apiUrl}/memory?symbol=${encodeURIComponent(node.name)}&repo=${encodeURIComponent(repoName)}&limit=1`, { headers: { "X-Kodingo-Token": token } });
+                    if (!res.ok)
+                        continue;
+                    const data = await res.json();
+                    const existing = data.data?.[0];
+                    if (existing?.id) {
+                        await fetch(`${apiUrl}/memory/${existing.id}/evidence`, {
+                            method: "PATCH",
+                            headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+                            body: JSON.stringify({ weightClass: "code_change" }),
+                        }).catch(() => { });
+                    }
+                }
+            }
+        }
+    }
+    catch { }
     // Write flag file so VS Code extension knows to surface proposed memories
     writePendingReviewFlag(repoRoot, commitHash);
 }

package/dist/commands/scan-repo.js

@@ -113,8 +113,9 @@ async function extractSymbols(filePath) {
         return [];
     }
 }
-async function fetchExistingSymbols(token, repo) {
+async function fetchExistingSymbols(token, repo, apiUrl) {
     const known = new Set();
+    const idMap = new Map(); // symbol::repo -> memory id
     let offset = 0;
     const limit = 200;
     try {
@@ -137,7 +138,17 @@ async function fetchExistingSymbols(token, repo) {
         }
     }
     catch { }
-    return known;
+    return { known, idMap };
+}
+async function sendSignal(token, apiUrl, memoryId, weightClass) {
+    try {
+        await fetch(`${apiUrl}/memory/${memoryId}/evidence`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+            body: JSON.stringify({ weightClass }),
+        });
+    }
+    catch { }
 }
 async function inferAndCapture(token, symbol, repo) {
     try {
@@ -206,7 +217,7 @@ async function scanRepoCommand(options = {}) {
         console.log(`  Checking which ones need memory...\n`);
     }
     // Fetch all existing memory symbols in one bulk call
-    const existingSymbols = await fetchExistingSymbols(token, repoName);
+    const { known: existingSymbols, idMap: existingIds } = await fetchExistingSymbols(token, repoName, apiUrl);
     // Shuffle so repeated runs cover different parts of the codebase
     const shuffled = [...allSymbols].sort(() => Math.random() - 0.5);
     // Filter locally — no per-symbol API calls needed
@@ -221,8 +232,15 @@ async function scanRepoCommand(options = {}) {
         seen.add(key);
         const symRepoKey = `${sym.name}::${repoName}`;
         const hasMemory = existingSymbols.has(symRepoKey) || existingSymbols.has(sym.name);
-        if (!hasMemory)
+        if (!hasMemory) {
             toCapture.push(sym);
+        }
+        else {
+            // Send structural signal — this function was seen again during a repo scan
+            const memId = existingIds.get(symRepoKey);
+            if (memId)
+                sendSignal(token, apiUrl, memId, "structural");
+        }
     }
     if (toCapture.length === 0) {
         if (!options.silent)

package/dist/commands/session-brief.js

@@ -72,6 +72,16 @@ async function sessionBriefCommand(options) {
         }
         const data = await res.json();
         const memories = (data.memories ?? []).sort((a, b) => b.confidence - a.confidence);
+        // Send metadata signal for each memory surfaced in session brief
+        for (const m of memories) {
+            if (m.id) {
+                fetch(`${apiUrl}/memory/${m.id}/evidence`, {
+                    method: "PATCH",
+                    headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+                    body: JSON.stringify({ weightClass: "metadata" }),
+                }).catch(() => { });
+            }
+        }
         if (!options.prompt) {
             console.log(JSON.stringify({
                 repo: repoName,

package/dist/ports/cloud-event-port.js

@@ -60,13 +60,22 @@ class CloudEventPort {
                 return;
             }
         }
-        // No existing proposed/ignored record — insert new
+        // No existing proposed/ignored record — validate invariants via core then insert
+        try {
+            (0, kodingo_core_1.enforceDecisionInvariants)(decision, _context);
+        }
+        catch (e) {
+            console.warn(`[core] Decision invariant failed: ${e.message} — skipping`);
+            return;
+        }
+        // Apply lifecycle — produces events and new memory state
+        const outcome = (0, kodingo_core_1.applyDecisionLifecycle)(decision, _context);
         const input = {
             type: "decision",
             content,
             repoPath: this.repoPath,
             status: "proposed",
-            confidence: 0.3,
+            confidence: decision.confidence ?? 0.3,
             externalId,
             tags: ["signal:git", "kind:decision"],
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodingo-cli",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "Kodingo CLI",
   "license": "MIT",
   "private": false,