dsh-context-memory 0.7.0 → 0.9.0

package/lib/client/view.js

@@ -10,6 +10,7 @@ const RECALL_PATH = '/api/context-memory.recall';
 const REMEMBER_PATH = '/api/context-memory.remember';
 const FORGET_PATH = '/api/context-memory.forget';
 const PREFS_PATH = '/api/context-memory.prefs';
+const CANDIDATES_PATH = '/api/context-memory.candidates';
 export function checkLabel(memory, t) {
     if (!memory.guard)
         return t('checkNone');
@@ -21,7 +22,14 @@ export function checkLabel(memory, t) {
     }
 }
 export function provenance(memory) {
-    return [memory.source, memory.sessionId !== undefined ? `session ${memory.sessionId}` : null, memory.step !== undefined ? `step ${String(memory.step)}` : null].filter((part) => part !== null).join(' · ');
+    // Scope first: the same sentence can be held in both logs with the same id, so without
+    // it two rows would read identically and the "forget" button beside them would be a
+    // coin flip over which log it retires.
+    return [memory.scope, memory.source, memory.sessionId !== undefined ? `session ${memory.sessionId}` : null, memory.step !== undefined ? `step ${String(memory.step)}` : null].filter((part) => part !== null).join(' · ');
+}
+/** A row key that is unique across scopes, where the id alone is not. */
+export function memoryKey(memory) {
+    return `${memory.scope}:${memory.id}`;
 }
 function AddMemoryModal({ t, onClose, onAdded }) {
     const toast = useToast();
@@ -89,13 +97,20 @@ function ContextMemoryPanelInner({ t }) {
             reload();
         }
     }, [forgetTarget, t, toast, reload]);
+    const decideCandidate = useCallback(async (id, action) => {
+        const r = await fetch(CANDIDATES_PATH, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ id, action }) });
+        if (r.ok) {
+            toast('success', action === 'accept' ? t('candidateAccepted') : t('candidateDismissed'));
+            reload();
+        }
+    }, [t, toast, reload]);
     const header = (_jsxs("header", { style: { display: 'flex', alignItems: 'center', gap: 12, marginBottom: 4 }, children: [_jsxs("strong", { style: { fontSize: 15 }, children: ["\uD83E\uDDE0 ", t('title')] }), _jsx("span", { style: { flex: 1 } }), _jsxs(Button, { variant: "primary", size: "sm", onClick: () => setAddOpen(true), children: ["\u2795 ", t('addMemory')] }), _jsx(Button, { variant: "secondary", size: "sm", onClick: reload, children: t('refresh') })] }));
     if (error !== null)
         return _jsxs("div", { style: { maxWidth: 820 }, children: [header, _jsx(Card, { children: _jsxs("p", { role: "alert", style: { margin: 0, fontSize: 13, color: 'var(--dsw-alias-state-error-primary)' }, children: [t('failed'), ": ", error] }) })] });
     if (payload === null)
         return _jsxs("div", { style: { maxWidth: 820 }, children: [header, _jsx("div", { style: { display: 'flex', justifyContent: 'center', padding: 40 }, children: _jsx(Spinner, { size: 28 }) })] });
-    return (_jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 14, maxWidth: 820 }, children: [header, _jsxs("div", { style: { display: 'flex', gap: 10, flexWrap: 'wrap' }, children: [_jsx(StatCard, { value: payload.totals.active, label: t('active') }), _jsx(StatCard, { value: payload.totals.verified, label: t('checkPassed') }), _jsx(StatCard, { value: payload.totals.unverified, label: t('unverified') }), _jsx(StatCard, { value: payload.totals.superseded, label: t('superseded') })] }), _jsx(Card, { title: t('integration'), icon: "\u2699\uFE0F", children: _jsx("div", { style: { display: 'flex', flexDirection: 'column', gap: 8 }, children: [['autoCapture', 'autoCaptureLabel'], ['recallInject', 'recallInjectLabel']].map(([key, labelKey]) => (_jsxs("label", { style: { display: 'flex', alignItems: 'center', gap: 8, fontSize: 13, cursor: 'pointer' }, children: [_jsx("input", { type: "checkbox", checked: prefs?.[key] ?? true, onChange: () => togglePref(key) }), t(labelKey)] }, key))) }) }), _jsxs(Card, { title: t('search'), icon: "\uD83D\uDD0D", children: [_jsxs("div", { style: { display: 'flex', gap: 8 }, children: [_jsx(Input, { value: searchQuery, onChange: (e) => setSearchQuery(e.target.value), placeholder: t('searchPlaceholder'), onKeyDown: (e) => { if (e.key === 'Enter')
-                                    handleSearch(); } }), _jsxs(Button, { variant: "secondary", onClick: handleSearch, disabled: searching, children: [searching ? _jsx(Spinner, { size: 14 }) : null, " ", t('search')] })] }), searchHits !== null && (_jsx("div", { style: { marginTop: 10 }, children: searchHits.length === 0 ? _jsx(EmptyState, { message: t('noResults') }) : (_jsx("div", { style: { display: 'flex', flexDirection: 'column', gap: 6 }, children: searchHits.map((hit) => (_jsxs("div", { style: { display: 'flex', gap: 8, alignItems: 'baseline' }, children: [_jsx(Badge, { color: "info", children: hit.score.toFixed(2) }), _jsx("span", { style: { fontSize: 12 }, children: hit.memory.text }), _jsxs("span", { style: { fontSize: 10, opacity: 0.5 }, children: ["\u2014 ", hit.why] })] }, hit.memory.id))) })) }))] }), payload.conflicts.length > 0 && (_jsxs(_Fragment, { children: [_jsx(SectionTitle, { icon: "\u26A0\uFE0F", children: t('conflicts') }), payload.conflicts.map((conflict) => (_jsx(Card, { title: conflict.subject, children: conflict.memories.map((memory) => (_jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: 8, marginBottom: 6 }, children: [_jsx("code", { style: { fontSize: 11 }, children: memory.id }), _jsx("span", { style: { fontSize: 12, flex: 1 }, children: memory.text }), _jsx(Button, { variant: "danger", size: "sm", onClick: () => setForgetTarget({ id: memory.id, reason: `conflict resolved: ${conflict.subject}` }), children: t('resolve') })] }, memory.id))) }, conflict.subject)))] })), _jsx(SectionTitle, { icon: "\u2705", children: t('active') }), payload.active.length === 0 ? _jsx(EmptyState, { icon: "\uD83D\uDCED", message: t('empty') }) : (_jsx(Card, { padding: 0, children: _jsxs("table", { style: tableStyles.table, children: [_jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { style: tableStyles.th, children: "Id" }), _jsx("th", { style: tableStyles.th, children: t('memory') }), _jsx("th", { style: tableStyles.th, children: t('kind') }), _jsx("th", { style: tableStyles.th, children: t('status') }), _jsx("th", { style: tableStyles.th, children: t('from') }), _jsx("th", { style: tableStyles.th })] }) }), _jsx("tbody", { children: payload.active.map((memory) => (_jsxs("tr", { children: [_jsx("td", { style: tableStyles.td, children: _jsx("code", { style: { fontSize: 11 }, children: memory.id }) }), _jsx("td", { style: tableStyles.td, children: memory.text }), _jsx("td", { style: tableStyles.td, children: _jsx(Badge, { children: memory.kind }) }), _jsx("td", { style: tableStyles.td, children: checkLabel(memory, t) }), _jsx("td", { style: { ...tableStyles.td, fontSize: 11, opacity: 0.6 }, children: provenance(memory) }), _jsx("td", { style: tableStyles.td, children: _jsx(Button, { variant: "danger", size: "sm", onClick: () => setForgetTarget({ id: memory.id, reason: 'superseded from panel' }), children: "\uD83D\uDDD1" }) })] }, memory.id))) })] }) })), payload.superseded.length > 0 && (_jsxs(_Fragment, { children: [_jsxs(SectionTitle, { icon: "\uD83D\uDCE6", children: [t('superseded'), " (", payload.superseded.length, ")"] }), _jsx(Card, { padding: 0, children: _jsxs("table", { style: tableStyles.table, children: [_jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { style: tableStyles.th, children: "Id" }), _jsx("th", { style: tableStyles.th, children: t('memory') }), _jsx("th", { style: tableStyles.th, children: t('kind') }), _jsx("th", { style: tableStyles.th, children: t('status') })] }) }), _jsx("tbody", { children: payload.superseded.map((memory) => (_jsxs("tr", { children: [_jsx("td", { style: tableStyles.td, children: _jsx("code", { style: { fontSize: 11 }, children: memory.id }) }), _jsx("td", { style: tableStyles.td, children: memory.text }), _jsx("td", { style: tableStyles.td, children: _jsx(Badge, { children: memory.kind }) }), _jsx("td", { style: tableStyles.td, children: checkLabel(memory, t) })] }, memory.id))) })] }) })] })), addOpen && _jsx(AddMemoryModal, { t: t, onClose: () => setAddOpen(false), onAdded: reload }), forgetTarget !== null && _jsx(ConfirmDialog, { title: t('forget'), message: t('confirmForget'), confirmLabel: t('forget'), danger: true, onConfirm: handleForget, onClose: () => setForgetTarget(null) })] }));
+    return (_jsxs("div", { style: { display: 'flex', flexDirection: 'column', gap: 14, maxWidth: 820 }, children: [header, _jsxs("div", { style: { display: 'flex', gap: 10, flexWrap: 'wrap' }, children: [_jsx(StatCard, { value: payload.totals.active, label: t('active') }), _jsx(StatCard, { value: payload.totals.verified, label: t('checkPassed') }), _jsx(StatCard, { value: payload.totals.unverified, label: t('unverified') }), _jsx(StatCard, { value: payload.totals.superseded, label: t('superseded') }), payload.totals.candidates > 0 && _jsx(StatCard, { value: payload.totals.candidates, label: t('candidates') })] }), _jsx(Card, { title: t('integration'), icon: "\u2699\uFE0F", children: _jsx("div", { style: { display: 'flex', flexDirection: 'column', gap: 8 }, children: [['autoCapture', 'autoCaptureLabel'], ['recallInject', 'recallInjectLabel']].map(([key, labelKey]) => (_jsxs("label", { style: { display: 'flex', alignItems: 'center', gap: 8, fontSize: 13, cursor: 'pointer' }, children: [_jsx("input", { type: "checkbox", checked: prefs?.[key] ?? true, onChange: () => togglePref(key) }), t(labelKey)] }, key))) }) }), _jsxs(Card, { title: t('search'), icon: "\uD83D\uDD0D", children: [_jsxs("div", { style: { display: 'flex', gap: 8 }, children: [_jsx(Input, { value: searchQuery, onChange: (e) => setSearchQuery(e.target.value), placeholder: t('searchPlaceholder'), onKeyDown: (e) => { if (e.key === 'Enter')
+                                    handleSearch(); } }), _jsxs(Button, { variant: "secondary", onClick: handleSearch, disabled: searching, children: [searching ? _jsx(Spinner, { size: 14 }) : null, " ", t('search')] })] }), searchHits !== null && (_jsx("div", { style: { marginTop: 10 }, children: searchHits.length === 0 ? _jsx(EmptyState, { message: t('noResults') }) : (_jsx("div", { style: { display: 'flex', flexDirection: 'column', gap: 6 }, children: searchHits.map((hit) => (_jsxs("div", { style: { display: 'flex', gap: 8, alignItems: 'baseline' }, children: [_jsx(Badge, { color: "info", children: hit.score.toFixed(2) }), _jsx("span", { style: { fontSize: 12 }, children: hit.memory.text }), _jsxs("span", { style: { fontSize: 10, opacity: 0.5 }, children: ["\u2014 ", hit.why] })] }, hit.memory.id))) })) }))] }), payload.conflicts.length > 0 && (_jsxs(_Fragment, { children: [_jsx(SectionTitle, { icon: "\u26A0\uFE0F", children: t('conflicts') }), payload.conflicts.map((conflict) => (_jsx(Card, { title: conflict.subject, children: conflict.memories.map((memory) => (_jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: 8, marginBottom: 6 }, children: [_jsx("code", { style: { fontSize: 11 }, children: memory.id }), _jsx("span", { style: { fontSize: 12, flex: 1 }, children: memory.text }), _jsx(Button, { variant: "danger", size: "sm", onClick: () => setForgetTarget({ id: memory.id, reason: `conflict resolved: ${conflict.subject}` }), children: t('resolve') })] }, memory.id))) }, conflict.subject)))] })), payload.candidates.length > 0 && (_jsxs(_Fragment, { children: [_jsxs(SectionTitle, { icon: "\uD83D\uDCA1", children: [t('candidates'), " (", payload.candidates.length, ")"] }), _jsxs(Card, { children: [_jsx("p", { style: { margin: '0 0 10px', fontSize: 12, opacity: 0.7 }, children: t('candidatesHint') }), _jsx("div", { style: { display: 'flex', flexDirection: 'column', gap: 8 }, children: payload.candidates.map((candidate) => (_jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: 8 }, children: [_jsx(Badge, { children: candidate.kind }), _jsx("span", { style: { fontSize: 12, flex: 1 }, children: candidate.text }), _jsx(Button, { variant: "primary", size: "sm", onClick: () => void decideCandidate(candidate.id, 'accept'), children: t('accept') }), _jsx(Button, { variant: "secondary", size: "sm", onClick: () => void decideCandidate(candidate.id, 'dismiss'), children: t('dismiss') })] }, candidate.id))) })] })] })), _jsx(SectionTitle, { icon: "\u2705", children: t('active') }), payload.active.length === 0 ? _jsx(EmptyState, { icon: "\uD83D\uDCED", message: t('empty') }) : (_jsx(Card, { padding: 0, children: _jsxs("table", { style: tableStyles.table, children: [_jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { style: tableStyles.th, children: "Id" }), _jsx("th", { style: tableStyles.th, children: t('memory') }), _jsx("th", { style: tableStyles.th, children: t('kind') }), _jsx("th", { style: tableStyles.th, children: t('status') }), _jsx("th", { style: tableStyles.th, children: t('from') }), _jsx("th", { style: tableStyles.th })] }) }), _jsx("tbody", { children: payload.active.map((memory) => (_jsxs("tr", { children: [_jsx("td", { style: tableStyles.td, children: _jsx("code", { style: { fontSize: 11 }, children: memory.id }) }), _jsx("td", { style: tableStyles.td, children: memory.text }), _jsx("td", { style: tableStyles.td, children: _jsx(Badge, { children: memory.kind }) }), _jsx("td", { style: tableStyles.td, children: checkLabel(memory, t) }), _jsx("td", { style: { ...tableStyles.td, fontSize: 11, opacity: 0.6 }, children: provenance(memory) }), _jsx("td", { style: tableStyles.td, children: _jsx(Button, { variant: "danger", size: "sm", onClick: () => setForgetTarget({ id: memory.id, scope: memory.scope, reason: 'superseded from panel' }), children: "\uD83D\uDDD1" }) })] }, memoryKey(memory)))) })] }) })), payload.superseded.length > 0 && (_jsxs(_Fragment, { children: [_jsxs(SectionTitle, { icon: "\uD83D\uDCE6", children: [t('superseded'), " (", payload.superseded.length, ")"] }), _jsx(Card, { padding: 0, children: _jsxs("table", { style: tableStyles.table, children: [_jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { style: tableStyles.th, children: "Id" }), _jsx("th", { style: tableStyles.th, children: t('memory') }), _jsx("th", { style: tableStyles.th, children: t('kind') }), _jsx("th", { style: tableStyles.th, children: t('status') })] }) }), _jsx("tbody", { children: payload.superseded.map((memory) => (_jsxs("tr", { children: [_jsx("td", { style: tableStyles.td, children: _jsx("code", { style: { fontSize: 11 }, children: memory.id }) }), _jsx("td", { style: tableStyles.td, children: memory.text }), _jsx("td", { style: tableStyles.td, children: _jsx(Badge, { children: memory.kind }) }), _jsx("td", { style: tableStyles.td, children: checkLabel(memory, t) })] }, memoryKey(memory)))) })] }) })] })), addOpen && _jsx(AddMemoryModal, { t: t, onClose: () => setAddOpen(false), onAdded: reload }), forgetTarget !== null && _jsx(ConfirmDialog, { title: t('forget'), message: t('confirmForget'), confirmLabel: t('forget'), danger: true, onConfirm: handleForget, onClose: () => setForgetTarget(null) })] }));
 }
 export function ContextMemoryPanel({ t }) {
     return _jsx(ToastProvider, { children: _jsx(ContextMemoryPanelInner, { t: t }) });

package/lib/guard.d.ts

@@ -9,58 +9,120 @@
  *
  * Recognition is narrow on purpose. Only statement shapes whose checkable predicate is
  * unambiguous get a guard; everything else stays uncheckable and says so. Emitting an
- * approximate command would produce a check that exits 0 while verifying nothing, and
- * every later "verified" would be a lie.
+ * approximate check would produce one that passes while verifying nothing, and every
+ * later "verified" would be a lie.
  *
  * There is deliberately **no** shape that runs a command taken from memory text. A
- * memory can be written by the agent itself, so treating its content as an executable
- * command is an injection path — the templates below only ever interpolate quoted file
- * paths and literal search strings.
+ * memory can be written by the agent itself, so treating its content as executable is
+ * an injection path. That is why the checks below are evaluated in-process against the
+ * filesystem rather than handed to a shell: the statement supplies operands (a path, a
+ * search string) and never a program, an argument list, or shell syntax.
+ *
+ * **Why not a shell command.** This module used to compile each shape into a shell
+ * command string and run it with `spawnSync(..., { shell: true })`, branching on
+ * `process.platform`. That design made the central question — did the check run at
+ * all? — undecidable on Windows. A guard whose program is missing and a guard whose
+ * predicate is simply false both exit 1 through cmd.exe, and cmd.exe's own diagnostic
+ * is a localized resource string: on a zh-CN host it arrives as GBK bytes reading
+ * 不是内部或外部命令…, which decodes to mojibake under utf8, so neither an English nor
+ * a Chinese pattern could reliably tell the two apart. Any classifier built on "what
+ * did the shell say" is a classifier that answers differently per host language.
+ *
+ * The predicates are all filesystem facts. Four of them are about a file's *text*
+ * (`exists` / `absent` / `contains` / `lacks`); four are about a file's *structure*
+ * (`depends` / `script` / `option` / `lineLimit`), answered by `JSON.parse` and a line
+ * count. Answered directly, they need no shell, no locale, no platform branch, and no
+ * quoting layer — and the distinction this module exists to protect becomes a fact about
+ * a return value instead of a guess about text.
+ *
+ * The structured predicates exist because the text ones cannot answer structural
+ * questions honestly: `contains "tsx" package.json` passes when `tsx` appears in a
+ * description or a script string, so it would report `passed` while verifying nothing.
+ * Parsing is still in-process, and the memory still supplies only operands.
  *
  * @module context-memory/guard
  */
 import type { Guard, GuardOutcome } from './types.js';
 /**
- * Compile a memory statement into an executable check.
+ * Every guard kind this version can evaluate.
+ *
+ * This list is the single definition. `memory.ts` drops a guard whose kind is not in it
+ * (a log written by a newer version), and the exhaustiveness assertion below turns
+ * "added a kind to the union but forgot to teach the evaluator" into a compile error
+ * rather than a runtime fallthrough into whichever branch happens to come last.
+ */
+export declare const GUARD_KINDS: readonly ["exists", "absent", "contains", "lacks", "depends", "script", "option", "lineLimit"];
+/**
+ * Compile a memory statement into a check.
+ *
+ * The returned predicate names operands, never a program: `{ kind: 'exists', path }`
+ * says what must be true, and `runGuard` decides it with `fs`. Nothing from the
+ * statement text is ever executed, so a memory cannot smuggle in an injection.
+ *
+ * Operands are stored as written. Resolution against the project directory happens at
+ * run time, so a memory stays meaningful if the project is moved or the check is
+ * evaluated from a different working directory.
+ */
+export declare function compileGuard(text: string): Guard | undefined;
+/**
+ * A human-readable rendering of a check, for the CLI and the log.
  *
- * Commands are emitted for the platform in use. `process.platform` rather than a
- * hardcoded POSIX spelling: `test -e` on Windows would leave every compiled memory
- * permanently unrunnable, so verification would report on nothing while looking busy.
+ * Deliberately not a shell command: printing one would invite the reader to run it,
+ * which is the interface this module just removed.
  */
-export declare function compileGuard(text: string, platform?: NodeJS.Platform): Guard | undefined;
+export declare function describeGuard(guard: Guard): string;
 /**
- * Quote a string so a POSIX shell treats it as one literal argument.
+ * Why a check contradicted a memory, in one line.
  *
- * Single quotes make every character literal; the only character that cannot appear
- * inside them is the quote itself, escaped by closing, escaping, and reopening.
+ * `runGuard` reports a reason when the check could not run, but a check that ran and came
+ * back false has nothing to report beyond its own verdict — `exists` and `absent` return
+ * an empty `output`. Answering "contradicted" with no detail leaves the reader unable to
+ * tell which path or which string was actually tested, so this falls back to the check's
+ * own description: it names the operand the memory no longer matches, which is the fact
+ * that made the memory wrong.
  */
-export declare function shellQuote(value: string): string;
+export declare function describeContradiction(check: Guard | undefined, output: string | undefined): string;
 /**
- * Run one guard to completion.
+ * Resolve a statement's operand against the project directory.
  *
- * `spawnSync` with a shell so compound commands work as written. No timeout: a guard
- * that hangs is a hang, and killing it after N seconds would turn "slow" into an
- * outcome that varies with machine load.
+ * Absolute operands are kept as written. Anything else is relative to the project the
+ * memory was recorded in, because that is the directory the statement was talking
+ * about — resolving against `process.cwd()` instead would make the same memory mean
+ * different things depending on where the command happened to be invoked.
+ */
+export declare function resolveOperand(path: string, cwd: string): string;
+/**
+ * Evaluate one check and say what happened.
+ *
+ * The three-way split is the whole point. `broken` covers "the check could not be
+ * carried out" — an operand that resolves to nothing, a path that is a directory where
+ * a file was named, a file too large to scan, a manifest that will not parse — and is
+ * never evidence about the memory. `violated` is reserved for a check that ran and came
+ * back false.
+ *
+ * No exit code is invented here. There is no child process, so there is no status to
+ * report; `exitCode` is null and `output` carries the reason. The one place a caller
+ * needs a process-style signal — `ContextMemory.exitCode` — derives it from the summary,
+ * counting only `violated`.
  */
 export declare function runGuard(id: string, guard: Guard, cwd: string, now?: Date): {
     id: string;
     outcome: GuardOutcome;
-    exitCode: null;
-    output: string;
-    at: string;
-} | {
-    id: string;
-    outcome: GuardOutcome;
-    exitCode: number;
+    exitCode: number | null;
     output: string;
     at: string;
 };
 /**
  * Classify an exit code into an outcome.
  *
- * Two conventions mean "the command does not exist": POSIX shells use 127, cmd.exe
- * uses 9009. Both are recognised, along with the text shells print instead of a
- * distinctive code when the failure happens inside the shell. Without this, a
- * misspelled path would look like a memory being wrong about the world.
+ * Kept for callers holding a status they did not produce themselves — the CLI reports
+ * on log entries written by older versions of this plugin, which recorded a child
+ * process's status. 127 is the POSIX convention for "command not found" and 9009 is
+ * cmd.exe's, and both mean the check never ran.
+ *
+ * The textual fallback is gone along with the shell. It could only ever have worked on
+ * an English host, and a classifier that reads differently depending on the system
+ * language is not a classifier. `runGuard` no longer spawns anything, so no new entry
+ * can carry a status that needs interpreting here.
  */
-export declare function classify(code: number, output?: string): GuardOutcome;
+export declare function classify(code: number): GuardOutcome;