pi-honcho-memory 0.2.0 → 0.3.0

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,33 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/extensions/client.ts

@@ -1,8 +1,16 @@
 import { Honcho } from "@honcho-ai/sdk";
 import type { Peer, Session } from "@honcho-ai/sdk";
 import type { HonchoConfig } from "./config.js";
+import { readConfigFile } from "./config.js";
 import { deriveSessionKey } from "./session.js";
 
+export interface LinkedHostHandle {
+  name: string;
+  honcho: Honcho;
+  userPeer: Peer;
+  aiPeer: Peer;
+}
+
 export interface HonchoHandles {
   honcho: Honcho;
   userPeer: Peer;
@@ -10,6 +18,7 @@ export interface HonchoHandles {
   session: Session | null;
   sessionKey: string;
   config: HonchoConfig;
+  linked: LinkedHostHandle[];
 }
 
 let cachedHandles: HonchoHandles | null = null;
@@ -51,14 +60,41 @@ export const bootstrap = async (config: HonchoConfig, cwd: string): Promise<Honc
     honcho.peer(config.aiPeer),
   ]);
 
+  // Bootstrap linked host clients (read-only cross-workspace access)
+  const linked: LinkedHostHandle[] = [];
+  if (config.linkedHosts.length > 0) {
+    const file = await readConfigFile();
+    const allHosts = file?.hosts ?? {};
+    const settled = await Promise.allSettled(
+      config.linkedHosts.map(async (hostName): Promise<LinkedHostHandle | null> => {
+        const hc = allHosts[hostName];
+        if (!hc?.workspace || !hc?.aiPeer) return null;
+        const h = new Honcho({
+          apiKey: config.apiKey,
+          baseURL: config.baseURL,
+          workspaceId: hc.workspace,
+          environment: config.environment,
+        });
+        const [up, ap] = await Promise.all([h.peer(config.peerName), h.peer(hc.aiPeer)]);
+        return { name: hostName, honcho: h, userPeer: up, aiPeer: ap };
+      }),
+    );
+    for (const result of settled) {
+      if (result.status === "fulfilled" && result.value) linked.push(result.value);
+      else if (result.status === "rejected" && config.logging) {
+        console.error("[honcho-memory] linked host bootstrap failed:", result.reason);
+      }
+    }
+  }
+
   if (config.recallMode === "tools") {
     // Lazy: defer session creation until first tool call
-    cachedHandles = { honcho, userPeer, aiPeer, session: null, sessionKey, config };
+    cachedHandles = { honcho, userPeer, aiPeer, session: null, sessionKey, config, linked };
     return cachedHandles;
   }
 
   // Eager: full init
-  cachedHandles = { honcho, userPeer, aiPeer, session: null, sessionKey, config };
+  cachedHandles = { honcho, userPeer, aiPeer, session: null, sessionKey, config, linked };
   await ensureSession(cachedHandles);
   return cachedHandles;
 };

package/extensions/config.ts

@@ -52,6 +52,7 @@ export interface HonchoConfigFile {
   contextRefresh?: { messageThreshold?: number };
   logging?: boolean;
   hosts?: {
+    [key: string]: Partial<PiHostConfig> | undefined;
     pi?: Partial<PiHostConfig>;
   };
 }

package/extensions/tools.ts

@@ -44,10 +44,10 @@ const ensureHandles = async () => {
   return handles;
 };
 
-const formatSearch = (results: Array<{ peerId: string; content: string }>, preview: number): string => {
+const formatSearch = (results: Array<{ sourceHost?: string; 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)}`)
+    .map((entry, index) => `${index + 1}. [${entry.sourceHost || "pi"} | ${entry.peerId || "unknown"}] ${entry.content.slice(0, preview)}`)
     .join("\n\n");
 };
 
@@ -57,7 +57,7 @@ export const registerTools = (pi: ExtensionAPI): void => {
   pi.registerTool({
     name: "honcho_profile",
     label: "Honcho Profile",
-    description: "Retrieve what Honcho currently knows about the user profile.",
+    description: "Retrieve what Honcho currently knows about the user profile from this and linked workspaces.",
     parameters: Type.Object({}),
     async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
       const handles = await ensureHandles();
@@ -67,8 +67,23 @@ export const registerTools = (pi: ExtensionAPI): void => {
         peerTarget: handles.userPeer,
         tokens: handles.config.contextTokens,
       });
+      let result = `=== [pi] ===\n${context.peerRepresentation?.trim() || "No profile memory available yet."}`;
+
+      for (const lh of handles.linked) {
+        try {
+          const rep = await lh.aiPeer.representation({ target: lh.userPeer });
+          if (rep?.trim()) {
+            result += `\n\n=== [${lh.name}] ===\n${rep.trim()}`;
+          }
+        } catch (err) {
+          if (handles.config.logging) {
+            console.error(`[honcho-memory] ${lh.name} profile read failed:`, err instanceof Error ? err.message : err);
+          }
+        }
+      }
+
       return {
-        content: [{ type: "text", text: context.peerRepresentation?.trim() || "No profile memory available yet." }],
+        content: [{ type: "text", text: result }],
         details: {},
       };
     },
@@ -77,12 +92,33 @@ export const registerTools = (pi: ExtensionAPI): void => {
   pi.registerTool({
     name: "honcho_search",
     label: "Honcho Search",
-    description: "Search durable memory for prior conversations, facts, and decisions.",
+    description: "Search durable memory for prior conversations, facts, and decisions across all linked workspaces.",
     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 });
+      const results: Array<{ sourceHost?: string; peerId?: string; content: string }> = [];
+
+      try {
+        const mainResults = await handles.session!.search(params.query, { limit });
+        results.push(...mainResults.map((r: any) => ({ ...r, sourceHost: "pi" })));
+      } catch (err) {
+        if (handles.config.logging) {
+          console.error("[honcho-memory] primary search failed:", err instanceof Error ? err.message : err);
+        }
+      }
+
+      for (const lh of handles.linked) {
+        try {
+          const hostResults = await lh.honcho.search(params.query, { limit });
+          results.push(...hostResults.map((r: any) => ({ ...r, sourceHost: lh.name })));
+        } catch (err) {
+          if (handles.config.logging) {
+            console.error(`[honcho-memory] ${lh.name} search failed:`, err instanceof Error ? err.message : err);
+          }
+        }
+      }
+
       return {
         content: [{ type: "text", text: formatSearch(results, handles.config.toolPreviewLength) }],
         details: { count: results.length },
@@ -93,7 +129,7 @@ export const registerTools = (pi: ExtensionAPI): void => {
   pi.registerTool({
     name: "honcho_context",
     label: "Honcho Context",
-    description: "Ask Honcho to synthesize memory context for the current question.",
+    description: "Ask Honcho to synthesize memory context for the current question across all linked workspaces.",
     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)),
@@ -103,6 +139,7 @@ export const registerTools = (pi: ExtensionAPI): void => {
       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!,
@@ -118,7 +155,33 @@ export const registerTools = (pi: ExtensionAPI): void => {
           });
         }
       }
-      const result = reply?.slice(0, handles.config.dialecticMaxChars) ?? "No additional context available.";
+      let result = `=== [pi] ===\n${reply?.slice(0, handles.config.dialecticMaxChars) ?? "No additional context available."}`;
+
+      for (const lh of handles.linked) {
+        try {
+          let hostReply = await lh.aiPeer.chat(truncatedQuery, {
+            target: lh.userPeer,
+            reasoningLevel: level,
+          });
+          if (!hostReply?.trim()) {
+            const bumped = nextLevel(level);
+            if (bumped) {
+              hostReply = await lh.aiPeer.chat(truncatedQuery, {
+                target: lh.userPeer,
+                reasoningLevel: bumped,
+              });
+            }
+          }
+          if (hostReply?.trim()) {
+            result += `\n\n=== [${lh.name}] ===\n${hostReply.slice(0, handles.config.dialecticMaxChars)}`;
+          }
+        } catch (err) {
+          if (handles.config.logging) {
+            console.error(`[honcho-memory] ${lh.name} context failed:`, err instanceof Error ? err.message : err);
+          }
+        }
+      }
+
       return {
         content: [{ type: "text", text: result }],
         details: {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-honcho-memory",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Honcho-backed persistent memory extension for PI coding agent. Full Hermes feature parity.",
   "type": "module",
   "license": "MIT",