@selesai/code 0.12.0 → 0.13.1

package/dist/extensions/pi-hermes-memory/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "pi-hermes-memory",
+  "version": "0.9.7",
+  "description": "Bundled Selesai fork of pi-hermes-memory: persistent memory, session search, and secret scanning.",
+  "type": "module",
+  "main": "src/index.ts",
+  "files": [
+    "src",
+    "scripts",
+    "README.md",
+    "LICENSE",
+    "docs"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "scripts": {
+    "check": "node scripts/ensure-dev.mjs check && tsc --noEmit",
+    "check:min-sdk": "node scripts/ensure-dev.mjs check && node scripts/check-min-sdk.mjs",
+    "test": "node scripts/ensure-dev.mjs test && tests/run-all.sh"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "memory",
+    "persistent-memory",
+    "session-search",
+    "sqlite",
+    "fts5",
+    "skills",
+    "learning-loop",
+    "agent",
+    "hermes",
+    "secret-scanning",
+    "content-scanner",
+    "correction-detection",
+    "auto-consolidation",
+    "memory-aging",
+    "context-fencing",
+    "two-tier-memory"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chandra447/pi-hermes-memory"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": ">=0.80.6",
+    "@earendil-works/pi-coding-agent": ">=0.80.6"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "0.84.4",
+    "@earendil-works/pi-coding-agent": "0.84.4",
+    "@types/better-sqlite3": "^7.6.13",
+    "tsx": "^4.21.0",
+    "typebox": "^1.1.33",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "@earendil-works/pi-tui": "0.84.4",
+    "better-sqlite3": "^13.0.3",
+    "strip-ansi": "7.2.0"
+  }
+}

package/dist/extensions/pi-hermes-memory/scripts/check-min-sdk.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * Type-check the extension against the OLDEST Pi SDK we claim to support.
+ *
+ * Why this exists: `peerDependencies` is the only thing telling a user whether
+ * this extension works on their Pi, and nothing verified it. The declared floor
+ * had drifted to `>=0.74.0` while `src/handlers/review-memory-ops.ts` imports
+ * `@earendil-works/pi-ai/compat`, a subpath that does not exist before 0.80.1 —
+ * so anyone on 0.74-0.79.x got ERR_PACKAGE_PATH_NOT_EXPORTED and no extension
+ * at all, with nothing in CI to catch it.
+ *
+ * The regular `check` job structurally cannot catch this: it installs whatever
+ * the devDependency range resolves to, which is always new enough.
+ *
+ * Run: node scripts/check-min-sdk.mjs
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const SCOPE = "@earendil-works";
+// pi-tui is a direct dependency rather than a peer, but its types cross the
+// boundary (ExtensionCommandContext.ui.custom takes a pi-tui TUI). Leaving it
+// at a different version yields a duplicate-private-property error instead of
+// a real finding, so it moves with the floor.
+const FLOOR_PACKAGES = [`${SCOPE}/pi-coding-agent`, `${SCOPE}/pi-ai`, `${SCOPE}/pi-tui`];
+
+const scopeDir = path.join(repoRoot, "node_modules", SCOPE);
+const stashDir = path.join(repoRoot, "node_modules", `${SCOPE}.real`);
+
+function restore() {
+  // Idempotent: safe to call from the finally block and from signal handlers.
+  try {
+    if (existsSync(stashDir)) {
+      if (existsSync(scopeDir)) unlinkSync(scopeDir);
+      renameSync(stashDir, scopeDir);
+    }
+  } catch (error) {
+    console.error(
+      `\nFAILED TO RESTORE node_modules/${SCOPE}. Run: mv "${stashDir}" "${scopeDir}"\n`,
+      error,
+    );
+  }
+}
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => { restore(); process.exit(130); });
+}
+
+const pkg = JSON.parse(readFileSync(path.join(repoRoot, "package.json"), "utf-8"));
+const range = pkg.peerDependencies?.[`${SCOPE}/pi-coding-agent`];
+const floor = /(\d+\.\d+\.\d+)/.exec(range ?? "")?.[1];
+if (!floor) {
+  console.error(`peerDependencies range "${range}" has no explicit floor — pin one like ">=0.80.1"`);
+  process.exit(1);
+}
+
+console.log(`Minimum supported ${SCOPE}/pi-coding-agent: ${floor}`);
+
+const scratch = mkdtempSync(path.join(tmpdir(), "pi-hermes-min-sdk-"));
+let failed = false;
+try {
+  writeFileSync(path.join(scratch, "package.json"), `${JSON.stringify({ name: "min-sdk-probe", private: true })}\n`);
+  const specs = FLOOR_PACKAGES.map((name) => `${name}@${floor}`);
+  console.log(`Installing ${specs.join(" ")} ...`);
+  execFileSync("npm", ["install", "--silent", "--no-audit", "--no-fund", "--no-package-lock", ...specs], {
+    cwd: scratch,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+
+  // Swap the scope in place so the project's own tsconfig applies unchanged —
+  // no divergent probe config that could drift from what `npm run check` uses.
+  renameSync(scopeDir, stashDir);
+  symlinkSync(path.join(scratch, "node_modules", SCOPE), scopeDir);
+
+  console.log("Type-checking src against the minimum SDK ...");
+  execFileSync(path.join(repoRoot, "node_modules", ".bin", "tsc"), ["--noEmit"], {
+    cwd: repoRoot,
+    stdio: "inherit",
+  });
+  console.log(`OK — src type-checks against ${SCOPE}/pi-coding-agent@${floor}`);
+} catch (error) {
+  failed = true;
+  if (!/Command failed/.test(String(error?.message))) console.error(error);
+  console.error(
+    `\nsrc does NOT type-check against the declared minimum (${floor}).\n`
+    + "Either raise the peerDependencies floor in package.json to a version that works,\n"
+    + "or stop using the SDK API that is missing at that version.\n",
+  );
+} finally {
+  restore();
+  rmSync(scratch, { recursive: true, force: true });
+}
+
+process.exit(failed ? 1 : 0);

package/dist/extensions/pi-hermes-memory/scripts/ensure-dev.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+/**
+ * Guard for check/test npm scripts.
+ *
+ * The published tarball intentionally omits tests/ and TypeScript (devDependency).
+ * When those scripts are run from an installed package (e.g. after `pi install`),
+ * fail with a clear message instead of `tsc: not found` / `tests/run-all.sh: not found`.
+ *
+ * @see https://github.com/chandra447/pi-hermes-memory/issues/108
+ */
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const mode = process.argv[2];
+const REPO = "https://github.com/chandra447/pi-hermes-memory";
+
+function fail(message) {
+  console.error(`\n[pi-hermes-memory] ${message}`);
+  console.error("");
+  console.error("These scripts only work from a full source checkout:");
+  console.error(`  git clone ${REPO}.git`);
+  console.error("  cd pi-hermes-memory && npm install");
+  console.error("  npm run check   # or: npm test");
+  console.error("");
+  console.error(
+    "The published package is for runtime use via Pi; CI validates check/test before publish.",
+  );
+  console.error("");
+  process.exit(1);
+}
+
+if (mode === "check") {
+  const require = createRequire(join(root, "package.json"));
+  try {
+    require.resolve("typescript/package.json");
+  } catch {
+    fail(
+      "`npm run check` requires TypeScript (a devDependency). The published npm package does not include it.",
+    );
+  }
+  if (!existsSync(join(root, "tsconfig.json"))) {
+    fail(
+      "`npm run check` requires tsconfig.json. The published npm package does not include it.",
+    );
+  }
+} else if (mode === "test") {
+  if (!existsSync(join(root, "tests", "run-all.sh"))) {
+    fail(
+      "`npm test` requires the tests/ directory. The published npm package intentionally omits it.",
+    );
+  }
+} else {
+  fail(`Unknown mode "${mode ?? ""}". Expected "check" or "test".`);
+}

package/dist/extensions/pi-hermes-memory/src/auto-consolidation-warning.ts

@@ -0,0 +1,6 @@
+export function shouldWarnAutoConsolidationFailure(
+  warnOnFailure: boolean,
+  consolidated: boolean,
+): boolean {
+  return !consolidated && warnOnFailure;
+}

package/dist/extensions/pi-hermes-memory/src/config.ts

@@ -0,0 +1,178 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { MemoryConfig, MemoryOverflowStrategy, ReviewTransport, SessionSearchVariant, ThinkingLevel } from "./types.js";
+import {
+  DEFAULT_MEMORY_CHAR_LIMIT,
+  DEFAULT_USER_CHAR_LIMIT,
+  DEFAULT_PROJECT_CHAR_LIMIT,
+  DEFAULT_PROJECTS_MEMORY_DIR,
+  DEFAULT_NUDGE_INTERVAL,
+  DEFAULT_FLUSH_MIN_TURNS,
+  DEFAULT_NUDGE_TOOL_CALLS,
+  DEFAULT_REVIEW_RECENT_MESSAGES,
+  DEFAULT_FLUSH_RECENT_MESSAGES,
+  DEFAULT_CONSOLIDATION_TIMEOUT_MS,
+  DEFAULT_OVERFLOW_GRACE_MS,
+  DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS,
+  DEFAULT_FAILURE_INJECTION_MAX_ENTRIES,
+} from "./constants.js";
+import { AGENT_ROOT, normalizeConfiguredMemoryDir, normalizeProjectsMemoryDir } from "./paths.js";
+
+const MEMORY_OVERFLOW_STRATEGIES: readonly MemoryOverflowStrategy[] = ["auto-consolidate", "reject", "fifo-evict"];
+const SESSION_SEARCH_VARIANTS: readonly SessionSearchVariant[] = ["legacy", "anchors"];
+const REVIEW_TRANSPORTS: readonly ReviewTransport[] = ["direct", "subprocess"];
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+function isReviewTransport(value: unknown): value is ReviewTransport {
+  return typeof value === "string" && REVIEW_TRANSPORTS.includes(value as ReviewTransport);
+}
+
+function isMemoryOverflowStrategy(value: unknown): value is MemoryOverflowStrategy {
+  return typeof value === "string" && MEMORY_OVERFLOW_STRATEGIES.includes(value as MemoryOverflowStrategy);
+}
+
+function isSessionSearchVariant(value: unknown): value is SessionSearchVariant {
+  return typeof value === "string" && SESSION_SEARCH_VARIANTS.includes(value as SessionSearchVariant);
+}
+
+function isThinkingLevel(value: unknown): value is ThinkingLevel {
+  return typeof value === "string" && (THINKING_LEVELS as readonly string[]).includes(value);
+}
+
+const DEFAULT_CONFIG: MemoryConfig = {
+  memoryMode: "policy-only",
+  memoryPolicyStyle: "full",
+  memoryCharLimit: DEFAULT_MEMORY_CHAR_LIMIT,
+  userCharLimit: DEFAULT_USER_CHAR_LIMIT,
+  projectCharLimit: DEFAULT_PROJECT_CHAR_LIMIT,
+  nudgeInterval: DEFAULT_NUDGE_INTERVAL,
+  reviewRecentMessages: DEFAULT_REVIEW_RECENT_MESSAGES,
+  reviewEnabled: true,
+  reviewTransport: "direct",
+  flushOnCompact: true,
+  flushOnShutdown: true,
+  flushMinTurns: DEFAULT_FLUSH_MIN_TURNS,
+  flushRecentMessages: DEFAULT_FLUSH_RECENT_MESSAGES,
+  memoryOverflowStrategy: "auto-consolidate",
+  overflowGraceMs: DEFAULT_OVERFLOW_GRACE_MS,
+  autoConsolidate: true,
+  correctionDetection: true,
+  failureInjectionEnabled: true,
+  failureInjectionMaxAgeDays: DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS,
+  failureInjectionMaxEntries: DEFAULT_FAILURE_INJECTION_MAX_ENTRIES,
+  consolidationTimeoutMs: DEFAULT_CONSOLIDATION_TIMEOUT_MS,
+  autoConsolidationWarnOnFailure: true,
+  nudgeToolCalls: DEFAULT_NUDGE_TOOL_CALLS,
+  standingInstructionsEnabled: true,
+  projectsMemoryDir: DEFAULT_PROJECTS_MEMORY_DIR,
+  sessionSearch: { variant: "legacy" },
+};
+
+export const DEFAULT_CONFIG_PATH = path.join(
+  AGENT_ROOT,
+  "hermes-memory-config.json",
+);
+
+export function loadConfig(configPath = DEFAULT_CONFIG_PATH): MemoryConfig {
+  try {
+    if (fs.existsSync(configPath)) {
+      const raw = fs.readFileSync(configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      // Merge: override defaults with user config
+      const config: MemoryConfig = { ...DEFAULT_CONFIG };
+      const isNonNegativeNumber = (value: unknown): value is number => (
+        typeof value === "number" && Number.isFinite(value) && value >= 0
+      );
+      const isStringArray = (value: unknown): value is string[] => (
+        Array.isArray(value) && value.every((item) => typeof item === "string")
+      );
+      let hasLegacyAutoConsolidate = false;
+      let hasMemoryOverflowStrategy = false;
+      if (parsed.memoryMode === "policy-only" || parsed.memoryMode === "legacy-inject") config.memoryMode = parsed.memoryMode;
+      if (
+        parsed.memoryPolicyStyle === "full" ||
+        parsed.memoryPolicyStyle === "compact" ||
+        parsed.memoryPolicyStyle === "custom" ||
+        parsed.memoryPolicyStyle === "none"
+      ) config.memoryPolicyStyle = parsed.memoryPolicyStyle;
+      if (typeof parsed.memoryPolicyCustomText === "string") config.memoryPolicyCustomText = parsed.memoryPolicyCustomText;
+      if (typeof parsed.memoryCharLimit === "number") config.memoryCharLimit = parsed.memoryCharLimit;
+      if (typeof parsed.userCharLimit === "number") config.userCharLimit = parsed.userCharLimit;
+      if (typeof parsed.nudgeInterval === "number") config.nudgeInterval = parsed.nudgeInterval;
+      if (isNonNegativeNumber(parsed.reviewRecentMessages)) config.reviewRecentMessages = parsed.reviewRecentMessages;
+      if (typeof parsed.reviewEnabled === "boolean") config.reviewEnabled = parsed.reviewEnabled;
+      if (isReviewTransport(parsed.reviewTransport)) config.reviewTransport = parsed.reviewTransport;
+      if (typeof parsed.flushOnCompact === "boolean") config.flushOnCompact = parsed.flushOnCompact;
+      if (typeof parsed.flushOnShutdown === "boolean") config.flushOnShutdown = parsed.flushOnShutdown;
+      if (typeof parsed.flushMinTurns === "number") config.flushMinTurns = parsed.flushMinTurns;
+      if (isNonNegativeNumber(parsed.flushRecentMessages)) config.flushRecentMessages = parsed.flushRecentMessages;
+      if (typeof parsed.autoConsolidate === "boolean") {
+        config.autoConsolidate = parsed.autoConsolidate;
+        hasLegacyAutoConsolidate = true;
+      }
+      if (isMemoryOverflowStrategy(parsed.memoryOverflowStrategy)) {
+        config.memoryOverflowStrategy = parsed.memoryOverflowStrategy;
+        hasMemoryOverflowStrategy = true;
+      }
+      if (isNonNegativeNumber(parsed.overflowGraceMs)) config.overflowGraceMs = parsed.overflowGraceMs;
+      if (typeof parsed.correctionDetection === "boolean") config.correctionDetection = parsed.correctionDetection;
+      if (isStringArray(parsed.correctionStrongPatterns)) config.correctionStrongPatterns = parsed.correctionStrongPatterns;
+      if (isStringArray(parsed.correctionWeakPatterns)) config.correctionWeakPatterns = parsed.correctionWeakPatterns;
+      if (isStringArray(parsed.correctionNegativePatterns)) config.correctionNegativePatterns = parsed.correctionNegativePatterns;
+      if (isStringArray(parsed.correctionDirectiveWords)) config.correctionDirectiveWords = parsed.correctionDirectiveWords;
+      if (typeof parsed.consolidationTimeoutMs === "number") {
+        config.consolidationTimeoutMs = parsed.consolidationTimeoutMs;
+        if (parsed.consolidationTimeoutMs < DEFAULT_CONSOLIDATION_TIMEOUT_MS) {
+          console.warn(
+            `⚠️ consolidationTimeoutMs is set to ${parsed.consolidationTimeoutMs}ms, below the ${DEFAULT_CONSOLIDATION_TIMEOUT_MS}ms default.`
+            + " Consolidation spawns a child agent turn and is routinely killed mid-run at lower values.",
+          );
+        }
+      }
+      if (typeof parsed.autoConsolidationWarnOnFailure === "boolean") {
+        config.autoConsolidationWarnOnFailure = parsed.autoConsolidationWarnOnFailure;
+      }
+      if (typeof parsed.failureInjectionEnabled === "boolean") config.failureInjectionEnabled = parsed.failureInjectionEnabled;
+      if (typeof parsed.failureInjectionMaxAgeDays === "number") config.failureInjectionMaxAgeDays = parsed.failureInjectionMaxAgeDays;
+      if (typeof parsed.failureInjectionMaxEntries === "number") config.failureInjectionMaxEntries = parsed.failureInjectionMaxEntries;
+      if (typeof parsed.nudgeToolCalls === "number") config.nudgeToolCalls = parsed.nudgeToolCalls;
+      if (typeof parsed.standingInstructionsEnabled === "boolean") config.standingInstructionsEnabled = parsed.standingInstructionsEnabled;
+      if (typeof parsed.projectCharLimit === "number") config.projectCharLimit = parsed.projectCharLimit;
+      if (typeof parsed.memoryDir === "string") {
+        const normalizedMemoryDir = normalizeConfiguredMemoryDir(parsed.memoryDir);
+        if (normalizedMemoryDir) config.memoryDir = normalizedMemoryDir;
+      }
+      if (typeof parsed.projectsMemoryDir === "string") {
+        const normalizedProjectsMemoryDir = normalizeProjectsMemoryDir(parsed.projectsMemoryDir);
+        if (normalizedProjectsMemoryDir) config.projectsMemoryDir = normalizedProjectsMemoryDir;
+      }
+      if (
+        typeof parsed.sessionSearch === "object" &&
+        parsed.sessionSearch !== null &&
+        isSessionSearchVariant(parsed.sessionSearch.variant)
+      ) {
+        config.sessionSearch = { variant: parsed.sessionSearch.variant };
+      }
+      if (typeof parsed.llmModelOverride === "string") {
+        const trimmed = parsed.llmModelOverride.trim();
+        if (trimmed.length > 0) config.llmModelOverride = trimmed;
+      }
+      if (isThinkingLevel(parsed.llmThinkingOverride)) config.llmThinkingOverride = parsed.llmThinkingOverride;
+      if (isStringArray(parsed.childExtensionPaths)) {
+        const childExtensionPaths = [...new Set<string>(
+          (parsed.childExtensionPaths as string[]).map((item) => item.trim()).filter(Boolean),
+        )];
+        if (childExtensionPaths.length > 0) config.childExtensionPaths = childExtensionPaths;
+      }
+      if (hasMemoryOverflowStrategy) {
+        config.autoConsolidate = config.memoryOverflowStrategy === "auto-consolidate";
+      } else if (hasLegacyAutoConsolidate) {
+        config.memoryOverflowStrategy = config.autoConsolidate ? "auto-consolidate" : "reject";
+      }
+      return config;
+    }
+  } catch {
+    // Fall back to defaults on parse error or access issues
+  }
+  return { ...DEFAULT_CONFIG };
+}