pi-goosedump 0.12.46 → 0.12.47

package/README.md

@@ -57,7 +57,8 @@ Use each tool's schema for full options. Typical flow:
 | `/goose-sessions`                 | List, resume, or delete project sessions         |
 | `/goose-forget [id\|provider:id]` | Forget stored memory                             |
 | `/goose-memory-status`            | Show memory storage and indexing status          |
-| `/goose-settings`                 | Edit project compaction settings                 |
+| `/goose-settings`                 | Edit goosedump settings                          |
+| `/goosedump-settings`             | Edit goosedump settings (alias)                  |
 
 Resume is available only for Pi sessions.
 
@@ -70,15 +71,17 @@ Project: `.pi/settings.json`
 {
   "goosedump": {
     "turnsBeforeCompact": 0,
-    "summaryMaxTokens": 4096
+    "summaryMaxTokens": 4096,
+    "enableMemory": false
   }
 }
 ```
 
-| Key                  | Range         | Default | Notes                                                          |
-| -------------------- | ------------- | ------: | -------------------------------------------------------------- |
-| `turnsBeforeCompact` | `0`–`255`     |       0 | `0` disables; each completed model response counts as one turn |
-| `summaryMaxTokens`   | `512`–`65536` |    4096 | Capped to 80% of `compaction.reserveTokens` when lower         |
+| Key                  | Range          | Default | Notes                                                          |
+| -------------------- | -------------- | ------: | -------------------------------------------------------------- |
+| `turnsBeforeCompact` | `0`–`255`      |       0 | `0` disables; each completed model response counts as one turn |
+| `summaryMaxTokens`   | `512`–`65536`  |    4096 | Capped to 80% of `compaction.reserveTokens` when lower         |
+| `enableMemory`       | `true`/`false` |   false | Controls whether durable memory tools/commands/learning are on |
 
 The footer shows the remaining turn count in hexadecimal.
 

package/dist/index.ts

@@ -25,7 +25,8 @@ var MEMORY_TEXT_TRUNCATED = `
 [Entry text truncated]`;
 var DEFAULT_GOOSEDUMP_SETTINGS = {
   turnsBeforeCompact: 0,
-  summaryMaxTokens: 4096
+  summaryMaxTokens: 4096,
+  enableMemory: false
 };
 var TURNS_BEFORE_COMPACT_MIN = 0;
 var TURNS_BEFORE_COMPACT_MAX = 255;
@@ -475,11 +476,23 @@ import {
 import { homedir } from "node:os";
 import { dirname as dirname2, join as join2 } from "node:path";
 var GOOSEDUMP_SETTING_SPECS = {
-  turnsBeforeCompact: { min: TURNS_BEFORE_COMPACT_MIN, max: TURNS_BEFORE_COMPACT_MAX },
-  summaryMaxTokens: { min: SUMMARY_MAX_TOKENS_MIN, max: SUMMARY_MAX_TOKENS_MAX }
+  turnsBeforeCompact: {
+    kind: "number",
+    min: TURNS_BEFORE_COMPACT_MIN,
+    max: TURNS_BEFORE_COMPACT_MAX
+  },
+  summaryMaxTokens: {
+    kind: "number",
+    min: SUMMARY_MAX_TOKENS_MIN,
+    max: SUMMARY_MAX_TOKENS_MAX
+  },
+  enableMemory: { kind: "boolean" }
 };
+var MEMORY_DISABLED_MESSAGE = "Durable memory is disabled. Set goosedump.enableMemory to true in settings (or /goose-settings).";
 function isValidGoosedumpSettingValue(key, value) {
   const spec = GOOSEDUMP_SETTING_SPECS[key];
+  if (spec.kind === "boolean")
+    return typeof value === "boolean";
   return typeof value === "number" && Number.isSafeInteger(value) && value >= spec.min && value <= spec.max;
 }
 function pickValidGoosedumpSettings(raw) {
@@ -488,11 +501,15 @@ function pickValidGoosedumpSettings(raw) {
   const settings = {};
   for (const key of Object.keys(GOOSEDUMP_SETTING_SPECS)) {
     const value = raw[key];
-    if (isValidGoosedumpSettingValue(key, value))
-      settings[key] = value;
+    if (!isValidGoosedumpSettingValue(key, value))
+      continue;
+    assignGoosedumpSetting(settings, key, value);
   }
   return settings;
 }
+function assignGoosedumpSetting(settings, key, value) {
+  settings[key] = value;
+}
 function piAgentDir() {
   return process.env.PI_CODING_AGENT_DIR ?? join2(homedir(), ".pi", "agent");
 }
@@ -566,6 +583,12 @@ function writeJsonObjectAtomically(path, value) {
 function readGoosedumpSettingsFrom(path) {
   return pickValidGoosedumpSettings(readJsonObject(path).goosedump);
 }
+function goosedumpSettingValidationMessage(key) {
+  const spec = GOOSEDUMP_SETTING_SPECS[key];
+  if (spec.kind === "boolean")
+    return "a boolean";
+  return `an integer from ${spec.min} to ${spec.max}`;
+}
 function validateGoosedumpSettings(path) {
   const root = readJsonObjectStrict(path);
   if (root.goosedump === undefined)
@@ -576,8 +599,7 @@ function validateGoosedumpSettings(path) {
   for (const key of Object.keys(GOOSEDUMP_SETTING_SPECS)) {
     const value = root.goosedump[key];
     if (value !== undefined && !isValidGoosedumpSettingValue(key, value)) {
-      const spec = GOOSEDUMP_SETTING_SPECS[key];
-      throw new Error(`${path}: goosedump.${key} must be an integer from ${spec.min} to ${spec.max}`);
+      throw new Error(`${path}: goosedump.${key} must be ${goosedumpSettingValidationMessage(key)}`);
     }
   }
 }
@@ -624,8 +646,14 @@ function readScopedGoosedumpSettings(cwd, scope) {
   return { ...DEFAULT_GOOSEDUMP_SETTINGS, ...pickValidGoosedumpSettings(raw) };
 }
 function writeScopedGoosedumpSetting(cwd, scope, key, value) {
+  if (!isValidGoosedumpSettingValue(key, value)) {
+    throw new Error(`goosedump.${key} must be ${goosedumpSettingValidationMessage(key)}`);
+  }
   updateScopedGoosedumpSetting(cwd, scope, (current) => ({ ...current, [key]: value }));
 }
+function isMemoryEnabled(cwd, includeProject) {
+  return resolveGoosedumpSettings(cwd, includeProject).enableMemory;
+}
 function clearScopedGoosedumpSetting(cwd, scope, key) {
   updateScopedGoosedumpSetting(cwd, scope, (current, existed) => {
     if (!existed)
@@ -1466,6 +1494,14 @@ import {
   truncateHead
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
+function memoryDisabledResult() {
+  return textResult(MEMORY_DISABLED_MESSAGE);
+}
+function requireMemoryEnabled(ctx) {
+  if (isMemoryEnabled(ctx.cwd, projectSettingsTrusted(ctx)))
+    return null;
+  return memoryDisabledResult();
+}
 function historyProviderParam() {
   return Type.Optional(Type.Union(GOOSE_PROVIDERS.map((provider) => Type.Literal(provider)), {
     default: "pi",
@@ -1549,6 +1585,9 @@ function defineGooseTool(name, parameters, handler) {
 function registerGooseTools(pi, deps) {
   const { nativeExecutablePath, enqueueRemember, requestCompaction } = deps;
   pi.registerTool(defineGooseTool("goose_remember", Type.Object({ ...historyTargetParams() }), async (params, _signal, ctx) => {
+    const disabled = requireMemoryEnabled(ctx);
+    if (disabled)
+      return disabled;
     const resolved = resolveHistoryTarget(ctx, "goose_remember", params);
     if (!resolved.ok)
       return resolved.result;
@@ -1577,6 +1616,9 @@ function registerGooseTools(pi, deps) {
       description: PARAM_DESCRIPTIONS.memoryLimit
     }))
   }), async (params, signal, ctx) => {
+    const disabled = requireMemoryEnabled(ctx);
+    if (disabled)
+      return disabled;
     const { hits, warning } = await goosedumpRecall(params.query, {
       path: params.allProjects ? undefined : ctx.cwd,
       type: params.type,
@@ -1593,14 +1635,22 @@ function registerGooseTools(pi, deps) {
     target: Type.String({
       description: PARAM_DESCRIPTIONS.forgetTarget
     })
-  }), async (params, signal) => {
+  }), async (params, signal, ctx) => {
+    const disabled = requireMemoryEnabled(ctx);
+    if (disabled)
+      return disabled;
     if (params.target.trim().length === 0) {
       return textResult("goose_forget error: target is required");
     }
     const res = await goosedumpMemoryForget(params.target.trim(), signal, nativeExecutablePath);
     return textResult(res);
   }));
-  pi.registerTool(defineGooseTool("goose_memory_status", Type.Object({}), async (_params, signal) => textResult(await goosedumpMemoryStatus(signal, nativeExecutablePath))));
+  pi.registerTool(defineGooseTool("goose_memory_status", Type.Object({}), async (_params, signal, ctx) => {
+    const disabled = requireMemoryEnabled(ctx);
+    if (disabled)
+      return disabled;
+    return textResult(await goosedumpMemoryStatus(signal, nativeExecutablePath));
+  }));
   pi.registerTool(defineGooseTool("goose_search", Type.Object({
     query: Type.String({ description: PARAM_DESCRIPTIONS.searchQuery }),
     ...historyBranchParams(),
@@ -1726,6 +1776,15 @@ import {
   wrapTextWithAnsi
 } from "@earendil-works/pi-tui";
 import { existsSync as existsSync3 } from "node:fs";
+function formatSettingDisplayValue(key, value) {
+  if (key === "turnsBeforeCompact" && typeof value === "number") {
+    return formatCompactSetting(value);
+  }
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  return String(value);
+}
+
 class NumberInputSubmenu {
   input = new Input;
   hint;
@@ -1846,11 +1905,12 @@ async function runSettingsEditor(ctx) {
   const OVERLAY_WIDTH = 84;
   const location = ctx.cwd;
   const projectTrusted = projectSettingsTrusted(ctx);
-  const specs = Object.entries(GOOSEDUMP_SETTING_SPECS).map(([key, spec]) => ({ key, min: spec.min, max: spec.max }));
+  const specs = Object.entries(GOOSEDUMP_SETTING_SPECS).map(([key, spec]) => ({ key, spec }));
   const helpRows = [
     ["Tab", "Next tab"],
     ["↑ / ↓", "Select setting"],
-    ["Enter", "Edit setting or submit value"],
+    ["Enter", "Edit number, toggle boolean, or submit"],
+    ["Backspace", "Clear project setting (inherit global)"],
     ["Esc", "Cancel edit or close"],
     ["Ctrl+C", "Close"],
     ["Empty + Enter", "Clear project setting (inherit global value)"]
@@ -1881,19 +1941,50 @@ async function runSettingsEditor(ctx) {
       const message = error instanceof Error ? error.message : String(error);
       ctx.ui.notify(`goosedump settings error: ${message}`, "error");
     }
+    function clearSelectedSetting(key) {
+      try {
+        clearScopedGoosedumpSetting(location, "project", key);
+        ctx.ui.notify(`${settingLabel(key)} inherits Global`, "info");
+        finishEdit();
+      } catch (error) {
+        reportSettingsError(error);
+      }
+    }
+    function toggleBooleanSetting(key) {
+      if (!projectTrusted) {
+        ctx.ui.notify("Project settings require a trusted project", "warning");
+        return;
+      }
+      const current = projectSettings[key] ?? globalSettings[key];
+      if (typeof current !== "boolean")
+        return;
+      const next = !current;
+      try {
+        writeScopedGoosedumpSetting(location, "project", key, next);
+        ctx.ui.notify(`${settingLabel(key)} = ${next}`, "info");
+        reloadSettings();
+        tui.requestRender();
+      } catch (error) {
+        reportSettingsError(error);
+      }
+    }
     function openEditor() {
-      const spec = specs[selectedSetting];
-      if (!spec)
+      const entry = specs[selectedSetting];
+      if (!entry)
         return;
       if (!projectTrusted) {
         ctx.ui.notify("Project settings require a trusted project", "warning");
         return;
       }
-      const currentValue = projectSettings[spec.key] ?? null;
-      editor = new NumberInputSubmenu(settingLabel(spec.key), currentValue, (value) => {
+      if (entry.spec.kind === "boolean") {
+        toggleBooleanSetting(entry.key);
+        return;
+      }
+      const currentValue = typeof projectSettings[entry.key] === "number" ? projectSettings[entry.key] : null;
+      editor = new NumberInputSubmenu(settingLabel(entry.key), currentValue, (value) => {
         try {
-          writeScopedGoosedumpSetting(location, "project", spec.key, value);
-          ctx.ui.notify(`${settingLabel(spec.key)} = ${spec.key === "turnsBeforeCompact" ? formatCompactSetting(value) : value}`, "info");
+          writeScopedGoosedumpSetting(location, "project", entry.key, value);
+          ctx.ui.notify(`${settingLabel(entry.key)} = ${formatSettingDisplayValue(entry.key, value)}`, "info");
           finishEdit();
         } catch (error) {
           reportSettingsError(error);
@@ -1902,17 +1993,9 @@ async function runSettingsEditor(ctx) {
         editor = undefined;
         tui.requestRender();
       }, {
-        min: spec.min,
-        max: spec.max,
-        onClear: () => {
-          try {
-            clearScopedGoosedumpSetting(location, "project", spec.key);
-            ctx.ui.notify(`${settingLabel(spec.key)} inherits Global`, "info");
-            finishEdit();
-          } catch (error) {
-            reportSettingsError(error);
-          }
-        },
+        min: entry.spec.min,
+        max: entry.spec.max,
+        onClear: () => clearSelectedSetting(entry.key),
         onInvalid: (message) => ctx.ui.notify(message, "error")
       });
     }
@@ -1936,17 +2019,17 @@ async function runSettingsEditor(ctx) {
           const descriptionWidth = Math.max(1, innerW - shortcutWidth - 4);
           content.push(dim(`  ${pad("Shortcut", shortcutWidth)}  Description`), ...helpRows.map(([shortcut, description]) => `  ${accent(pad(shortcut, shortcutWidth))}  ${text(truncateToWidth2(description, descriptionWidth))}`));
         } else {
-          for (const [index, spec] of specs.entries()) {
+          for (const [index, entry] of specs.entries()) {
             const selected = index === selectedSetting;
-            const inherited = projectSettings[spec.key] === undefined;
-            const value = projectSettings[spec.key] ?? globalSettings[spec.key];
-            const valueText = `[ ${value} ]`;
+            const inherited = projectSettings[entry.key] === undefined;
+            const value = projectSettings[entry.key] ?? globalSettings[entry.key];
+            const valueText = `[ ${formatSettingDisplayValue(entry.key, value)} ]`;
             const renderedValue = inherited ? dim(valueText) : selected ? accent(valueText) : text(valueText);
             const cursor = selected ? accent("›") : " ";
-            content.push(`${cursor} ${renderedValue} ${text(spec.key)}`);
+            content.push(`${cursor} ${renderedValue} ${text(entry.key)}`);
           }
           const effective = resolveGoosedumpSettings(location, projectTrusted);
-          content.push("", dim(`Effective: turns=${formatCompactSetting(effective.turnsBeforeCompact)} · summary=${effectiveSummaryMaxTokens(location, projectTrusted)} tokens`));
+          content.push("", dim(`Effective: turns=${formatCompactSetting(effective.turnsBeforeCompact)} · summary=${effectiveSummaryMaxTokens(location, projectTrusted)} tokens · memory=${effective.enableMemory ? "on" : "off"}`));
         }
         return [
           overlayHeader(colors, width, "Goosedump Settings"),
@@ -1979,6 +2062,16 @@ async function runSettingsEditor(ctx) {
           selectedSetting = selectedSetting === 0 ? specs.length - 1 : Math.max(0, selectedSetting - 1);
         } else if (matchesKey(data, Key.down)) {
           selectedSetting = (selectedSetting + 1) % specs.length;
+        } else if (matchesKey(data, Key.backspace) || matchesKey(data, Key.delete)) {
+          const entry = specs[selectedSetting];
+          if (!entry)
+            return;
+          if (!projectTrusted) {
+            ctx.ui.notify("Project settings require a trusted project", "warning");
+            return;
+          }
+          clearSelectedSetting(entry.key);
+          return;
         } else if (matchesKey(data, Key.enter) || matchesKey(data, Key.return)) {
           openEditor();
         } else {
@@ -2426,6 +2519,8 @@ function createGoosedumpIntegration(options = {}) {
   const rememberQueue = [];
   let rememberRunning = null;
   function enqueueRemember(target, ctx, reportError) {
+    if (!isMemoryEnabled(ctx.cwd, projectSettingsTrusted(ctx)))
+      return;
     for (let i = rememberQueue.length - 1;i >= 0; i -= 1) {
       if (rememberQueue[i]?.target === target)
         rememberQueue.splice(i, 1);
@@ -2524,11 +2619,13 @@ ${renderToolRoutingPolicy()}`
         }
       });
     };
-    registerGooseCommand("goose-settings", "Edit goosedump compaction settings", async (_args, ctx) => {
+    const openSettingsEditor = async (_args, ctx) => {
       await runSettingsEditor(ctx);
       compaction.syncCompactCounters(ctx);
       compaction.updateStatus(ctx);
-    });
+    };
+    registerGooseCommand("goose-settings", "Edit goosedump settings", openSettingsEditor);
+    registerGooseCommand("goosedump-settings", "Edit goosedump settings", openSettingsEditor);
     registerGooseCommand("goose-compact", "Compact the current session now; optionally keep the last N user turns", async (args, ctx) => {
       let keep = null;
       if (args.trim()) {
@@ -2562,6 +2659,10 @@ ${renderToolRoutingPolicy()}`
       await runSessionsPanel(ctx, nativeExecutablePath);
     });
     registerGooseCommand("goose-forget", "Remove a durable memory entry or remembered session", async (args, ctx) => {
+      if (!isMemoryEnabled(ctx.cwd, projectSettingsTrusted(ctx))) {
+        ctx.ui.notify(MEMORY_DISABLED_MESSAGE, "warning");
+        return;
+      }
       const target = args.trim() || (await ctx.ui.input("Memory target/ID to forget:", ""))?.trim() || "";
       if (target.length === 0)
         return;
@@ -2569,6 +2670,10 @@ ${renderToolRoutingPolicy()}`
       ctx.ui.notify(res, "info");
     });
     registerGooseCommand("goose-memory-status", "Show durable memory storage health and type counts", async (_args, ctx) => {
+      if (!isMemoryEnabled(ctx.cwd, projectSettingsTrusted(ctx))) {
+        ctx.ui.notify(MEMORY_DISABLED_MESSAGE, "warning");
+        return;
+      }
       const res = await goosedumpMemoryStatus(undefined, nativeExecutablePath);
       ctx.ui.notify(res, "info");
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.12.46",
+  "version": "0.12.47",
   "description": "Pi extension for goosedump session search, durable memory, session management, and compaction",
   "keywords": [
     "compaction",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.82.1",
-    "@jarkkojs/goosedump": "^0.12.46",
+    "@jarkkojs/goosedump": "^0.12.47",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {