pi-honcho-memory 0.1.0

package/extensions/tools.ts

@@ -0,0 +1,162 @@
+import { StringEnum } from "@mariozechner/pi-ai";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { ensureSession, getHandles } from "./client.js";
+import { type ReasoningLevel, getRecallMode } from "./config.js";
+
+const REASONING_LEVELS: readonly ReasoningLevel[] = ["minimal", "low", "medium", "high", "max"];
+
+const bumpLevel = (level: ReasoningLevel, steps: number): ReasoningLevel => {
+  const idx = REASONING_LEVELS.indexOf(level);
+  const target = Math.min(idx + steps, REASONING_LEVELS.length - 1);
+  return REASONING_LEVELS[Math.max(0, target)];
+};
+
+const nextLevel = (level: string): ReasoningLevel | null => {
+  const idx = REASONING_LEVELS.indexOf(level as ReasoningLevel);
+  return idx >= 0 && idx < REASONING_LEVELS.length - 1 ? REASONING_LEVELS[idx + 1] : null;
+};
+
+export const dynamicLevel = (
+  query: string,
+  baseLevel: ReasoningLevel,
+  dynamic: boolean,
+  cap: ReasoningLevel | null,
+): ReasoningLevel => {
+  if (!dynamic) return baseLevel;
+  const len = query.length;
+  let level = baseLevel;
+  if (len >= 120) level = bumpLevel(level, 1);
+  if (len >= 400) level = bumpLevel(level, 1);
+  if (cap) {
+    const capIdx = REASONING_LEVELS.indexOf(cap);
+    const levelIdx = REASONING_LEVELS.indexOf(level);
+    if (levelIdx > capIdx) level = cap;
+  }
+  return level;
+};
+
+const ensureHandles = async () => {
+  if (getRecallMode() === "context") throw new Error("Memory tools are disabled in context-only recall mode.");
+  const handles = getHandles();
+  if (!handles) throw new Error("Honcho is not connected. Run /honcho:setup first.");
+  await ensureSession(handles);
+  return handles;
+};
+
+const formatSearch = (results: Array<{ peerId: string; content: string }>, preview: number): string => {
+  if (results.length === 0) return "No relevant memory found.";
+  return results
+    .map((entry, index) => `${index + 1}. [${entry.peerId}] ${entry.content.slice(0, preview)}`)
+    .join("\n\n");
+};
+
+const SEARCH_MAX_TOKENS = 2000;
+
+export const registerTools = (pi: ExtensionAPI): void => {
+  pi.registerTool({
+    name: "honcho_profile",
+    label: "Honcho Profile",
+    description: "Retrieve what Honcho currently knows about the user profile.",
+    parameters: Type.Object({}),
+    async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
+      const handles = await ensureHandles();
+      const context = await handles.session!.context({
+        summary: false,
+        peerPerspective: handles.aiPeer,
+        peerTarget: handles.userPeer,
+        tokens: handles.config.contextTokens,
+      });
+      return {
+        content: [{ type: "text", text: context.peerRepresentation?.trim() || "No profile memory available yet." }],
+        details: {},
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "honcho_search",
+    label: "Honcho Search",
+    description: "Search durable memory for prior conversations, facts, and decisions.",
+    parameters: Type.Object({ query: Type.String({ description: "Search query" }) }),
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const handles = await ensureHandles();
+      const limit = Math.min(handles.config.searchLimit, SEARCH_MAX_TOKENS);
+      const results = await handles.session!.search(params.query, { limit });
+      return {
+        content: [{ type: "text", text: formatSearch(results, handles.config.toolPreviewLength) }],
+        details: { count: results.length },
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "honcho_context",
+    label: "Honcho Context",
+    description: "Ask Honcho to synthesize memory context for the current question.",
+    parameters: Type.Object({
+      query: Type.String({ description: "Question to ask about long-term memory" }),
+      reasoningLevel: Type.Optional(StringEnum(["minimal", "low", "medium", "high", "max"] as const)),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const handles = await ensureHandles();
+      const truncatedQuery = params.query.slice(0, handles.config.dialecticMaxInputChars);
+      const level = params.reasoningLevel
+        ?? dynamicLevel(truncatedQuery, handles.config.reasoningLevel, handles.config.dialecticDynamic, handles.config.reasoningLevelCap);
+      let reply = await handles.aiPeer.chat(truncatedQuery, {
+        target: handles.userPeer,
+        session: handles.session!,
+        reasoningLevel: level,
+      });
+      if (!reply?.trim()) {
+        const bumped = nextLevel(level);
+        if (bumped) {
+          reply = await handles.aiPeer.chat(truncatedQuery, {
+            target: handles.userPeer,
+            session: handles.session!,
+            reasoningLevel: bumped,
+          });
+        }
+      }
+      const result = reply?.slice(0, handles.config.dialecticMaxChars) ?? "No additional context available.";
+      return {
+        content: [{ type: "text", text: result }],
+        details: {},
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "honcho_conclude",
+    label: "Honcho Conclude",
+    description: "Store a durable preference, fact, or decision in Honcho.",
+    parameters: Type.Object({ content: Type.String({ description: "Durable memory to store" }) }),
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const handles = await ensureHandles();
+      await handles.aiPeer.conclusionsOf(handles.userPeer).create({
+        content: params.content,
+        sessionId: handles.session!,
+      });
+      return {
+        content: [{ type: "text", text: `Saved durable memory: ${params.content}` }],
+        details: {},
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "honcho_seed_identity",
+    label: "Honcho Seed Identity",
+    description: "Seed the AI peer's identity representation in Honcho.",
+    parameters: Type.Object({ content: Type.String({ description: "AI identity description" }) }),
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const handles = await ensureHandles();
+      const tagged = `<ai_identity_seed source="manual">\n${params.content}\n</ai_identity_seed>`;
+      await handles.session!.addMessages([handles.aiPeer.message(tagged)]);
+      return {
+        content: [{ type: "text", text: "AI identity seeded." }],
+        details: {},
+      };
+    },
+  });
+};

package/extensions/upload.ts

@@ -0,0 +1,216 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { WriteFrequency } from "./config.js";
+import type { HonchoHandles } from "./client.js";
+
+// ---------------------------------------------------------------------------
+// Layer 1: Credential sanitization
+// ---------------------------------------------------------------------------
+
+const REDACT_PLACEHOLDER = "<REDACTED>";
+
+/** Patterns that match credential values in context (keyword + value). */
+const CONTEXTUAL_PATTERNS: Array<{ re: RegExp; label: string }> = [
+  // key=value or key: value patterns for known credential keywords
+  { re: /(?:api[_-]?key|apikey|secret[_-]?key|access[_-]?key|auth[_-]?token|bearer|password|passphrase|private[_-]?key|client[_-]?secret)\s*[:=]\s*['"]?([^\s'"`,;}{]{8,})['"]?/gi, label: "CREDENTIAL" },
+  // export VAR="value" for known env var names
+  { re: /(?:export\s+)?(?:API_KEY|SECRET_KEY|ACCESS_KEY|AUTH_TOKEN|PASSWORD|PASSPHRASE|PRIVATE_KEY|CLIENT_SECRET|DATABASE_URL|OPENAI_API_KEY|ANTHROPIC_API_KEY|EXA_API_KEY|HONCHO_API_KEY|AWS_SECRET_ACCESS_KEY|GITHUB_TOKEN|GITLAB_TOKEN|NPM_TOKEN)\s*=\s*['"]?([^\s'"`,;}{]{8,})['"]?/gi, label: "ENV_SECRET" },
+];
+
+/** Patterns that match standalone credential formats (no keyword context needed). */
+const STANDALONE_PATTERNS: Array<{ re: RegExp; label: string }> = [
+  // AWS access key IDs
+  { re: /\bAKIA[0-9A-Z]{16}\b/g, label: "AWS_KEY" },
+  // Bearer tokens
+  { re: /\bBearer\s+[A-Za-z0-9\-._~+/]{20,}=*/g, label: "BEARER_TOKEN" },
+  // GitHub personal access tokens
+  { re: /\bgh[ps]_[A-Za-z0-9]{36,}\b/g, label: "GITHUB_TOKEN" },
+  // GitLab tokens
+  { re: /\bglpat-[A-Za-z0-9\-]{20,}\b/g, label: "GITLAB_TOKEN" },
+  // Honcho API keys
+  { re: /\bhch-v\d+-[A-Za-z0-9]{20,}\b/g, label: "HONCHO_KEY" },
+  // npm tokens
+  { re: /\bnpm_[A-Za-z0-9]{36,}\b/g, label: "NPM_TOKEN" },
+  // Slack tokens
+  { re: /\bxox[bpors]-[A-Za-z0-9\-]{10,}\b/g, label: "SLACK_TOKEN" },
+  // OpenAI API keys
+  { re: /\bsk-[A-Za-z0-9\-]{20,}\b/g, label: "OPENAI_KEY" },
+  // Generic long hex secrets (64+ chars, likely SHA/HMAC keys)
+  { re: /\b[0-9a-f]{64,}\b/gi, label: "HEX_SECRET" },
+];
+
+export const sanitizeCredentials = (text: string): string => {
+  let result = text;
+  for (const { re, label } of CONTEXTUAL_PATTERNS) {
+    re.lastIndex = 0;
+    result = result.replace(re, (match, value) =>
+      match.replace(value, `${REDACT_PLACEHOLDER}:${label}`),
+    );
+  }
+  for (const { re, label } of STANDALONE_PATTERNS) {
+    re.lastIndex = 0;
+    result = result.replace(re, `${REDACT_PLACEHOLDER}:${label}`);
+  }
+  return result;
+};
+
+// ---------------------------------------------------------------------------
+// Layer 2: Tool output filtering
+// ---------------------------------------------------------------------------
+
+/** Detect and strip content that looks like raw file dumps or command output. */
+export const stripToolOutput = (text: string): string => {
+  // Strip content between common tool output markers
+  let result = text;
+  // Remove fenced code blocks that look like file contents (```\nFILE_CONTENT\n```)
+  // but keep short code blocks (likely explanations, not dumps)
+  result = result.replace(/```[\w]*\n([\s\S]{500,}?)```/g, (match) => {
+    // Check if it contains credential-like patterns — if so, redact the whole block
+    if (/(?:password|secret|key|token|apikey)\s*[:=]/i.test(match)) {
+      return "```\n[tool output redacted — contained potential credentials]\n```";
+    }
+    return match;
+  });
+  return result;
+};
+
+// ---------------------------------------------------------------------------
+// Text extraction
+// ---------------------------------------------------------------------------
+
+const extractText = (content: unknown): string => {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content
+    .flatMap((entry) => {
+      if (typeof entry === "string") return [entry];
+      if (entry && typeof entry === "object" && "type" in entry && "text" in entry) {
+        const block = entry as { type?: string; text?: string };
+        if (block.type === "text" && typeof block.text === "string") return [block.text];
+      }
+      return [];
+    })
+    .join("\n")
+    .trim();
+};
+
+export const chunkTextSmart = (text: string, maxLen: number): string[] => {
+  if (text.length <= maxLen) return [text];
+  const chunks: string[] = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLen) { chunks.push(remaining); break; }
+    let cut = -1;
+    const search = remaining.slice(0, maxLen);
+    // Try paragraph boundary
+    const para = search.lastIndexOf("\n\n");
+    if (para > 0) cut = para + 2;
+    // Fall back to sentence
+    if (cut <= 0) {
+      const sent = search.lastIndexOf(". ");
+      if (sent > 0) cut = sent + 2;
+    }
+    // Fall back to word
+    if (cut <= 0) {
+      const word = search.lastIndexOf(" ");
+      if (word > 0) cut = word + 1;
+    }
+    // Hard cut
+    if (cut <= 0) cut = maxLen;
+    chunks.push(remaining.slice(0, cut));
+    remaining = remaining.slice(cut);
+  }
+  return chunks.map((c, i) => i === 0 ? c : `[continued] ${c}`);
+};
+
+interface PendingWrite {
+  handles: HonchoHandles;
+  payload: Array<{ role: "user" | "assistant"; text: string }>;
+}
+
+export class WriteScheduler {
+  private pending: PendingWrite[] = [];
+  private turnCount = 0;
+  private asyncQueue: Promise<void> = Promise.resolve();
+
+  constructor(private frequency: WriteFrequency | number) {}
+
+  private async sendWithRetry(handles: HonchoHandles, payload: PendingWrite["payload"]): Promise<void> {
+    const messages = payload.map((m) =>
+      m.role === "user" ? handles.userPeer.message(m.text) : handles.aiPeer.message(m.text),
+    );
+    try {
+      await handles.session!.addMessages(messages);
+    } catch (firstError) {
+      console.warn("[honcho-memory] upload failed, retrying in 2s:",
+        firstError instanceof Error ? firstError.message : firstError);
+      await new Promise((r) => setTimeout(r, 2000));
+      await handles.session!.addMessages(messages);
+    }
+  }
+
+  private enqueueAsync(write: PendingWrite): void {
+    this.asyncQueue = this.asyncQueue
+      .then(() => this.sendWithRetry(write.handles, write.payload))
+      .catch((error) => {
+        console.error("[honcho-memory] upload queue error:", error instanceof Error ? error.message : error);
+      });
+  }
+
+  private preparePayload(handles: HonchoHandles, messages: AgentMessage[]): PendingWrite["payload"] {
+    return messages
+      .filter((m) => m.role === "user" || m.role === "assistant")
+      .map((m) => ({ role: m.role as "user" | "assistant", text: extractText(m.content) }))
+      .filter((m) => m.text.length > 0)
+      .map((m) => ({ role: m.role, text: sanitizeCredentials(stripToolOutput(m.text)) }))
+      .filter((m) => m.text.length > 0)
+      .flatMap((m) =>
+        chunkTextSmart(m.text, handles.config.maxMessageLength).map((chunk) => ({ role: m.role, text: chunk })),
+      );
+  }
+
+  async onTurnEnd(handles: HonchoHandles, messages: AgentMessage[]): Promise<void> {
+    const payload = this.preparePayload(handles, messages);
+    if (payload.length === 0) return;
+
+    this.turnCount++;
+
+    if (this.frequency === "async") {
+      this.enqueueAsync({ handles, payload });
+      return;
+    }
+
+    if (this.frequency === "turn") {
+      await this.sendWithRetry(handles, payload);
+      return;
+    }
+
+    // "session" or N-turn: accumulate
+    this.pending.push({ handles, payload });
+
+    if (typeof this.frequency === "number" && this.turnCount % this.frequency === 0) {
+      await this.flushPending();
+    }
+  }
+
+  private async flushPending(): Promise<void> {
+    const batch = this.pending.splice(0);
+    for (const write of batch) {
+      try {
+        await this.sendWithRetry(write.handles, write.payload);
+      } catch (error) {
+        console.error("[honcho-memory] batch flush error:", error instanceof Error ? error.message : error);
+      }
+    }
+  }
+
+  async flush(): Promise<void> {
+    await this.flushPending();
+    await this.asyncQueue;
+  }
+
+  reset(): void {
+    this.pending = [];
+    this.turnCount = 0;
+    this.asyncQueue = Promise.resolve();
+  }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "pi-honcho-memory",
+  "version": "0.1.0",
+  "description": "Honcho-backed persistent memory extension for PI coding agent. Full Hermes feature parity.",
+  "type": "module",
+  "license": "MIT",
+  "author": "acsezen",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/acsezen/pi-memory-honcho.git"
+  },
+  "homepage": "https://github.com/acsezen/pi-memory-honcho#readme",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "honcho",
+    "hermes",
+    "memory",
+    "persistent-memory",
+    "ai-agent"
+  ],
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@honcho-ai/sdk": "^2.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "vitest": "^4.1.2"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*",
+    "@sinclair/typebox": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  }
+}

package/types/shims.d.ts

@@ -0,0 +1,3 @@
+// All major dependencies ship their own types.
+// This file is kept as a placeholder — add shims here only for
+// packages that genuinely lack type definitions.