@chendpoc/pi-memory 0.1.13 → 0.2.1

package/src/adapters/ollamaClient.ts

@@ -1,179 +0,0 @@
-import http from "node:http";
-import https from "node:https";
-
-import type { LLMClient } from "../trainer/llmExtractor.js";
-import type { MemoryHelperLLM } from "../preflight/detectIntents.js";
-import type { CompileMemoryIntentsResult } from "../preflight/detectIntents.js";
-import {
-  COMPILE_MEMORY_INTENTS_PARAMETERS,
-  MEMORY_HELPER_TOOL_NAME,
-} from "../preflight/detectIntents.js";
-
-export interface OllamaConfig {
-  baseUrl: string;
-  model: string;
-}
-
-export const DEFAULT_OLLAMA_CONFIG: OllamaConfig = {
-  baseUrl: "http://localhost:11434",
-  model: "qwen3:8b",
-};
-
-interface OllamaChatMessage {
-  role: "system" | "user" | "assistant";
-  content: string;
-}
-
-interface OllamaChatRequest {
-  model: string;
-  messages: OllamaChatMessage[];
-  stream: false;
-  tools?: OllamaTool[];
-  options?: { num_predict?: number };
-}
-
-interface OllamaTool {
-  type: "function";
-  function: {
-    name: string;
-    description: string;
-    parameters: Record<string, unknown>;
-  };
-}
-
-interface OllamaChatResponse {
-  message?: {
-    role?: string;
-    content?: string;
-    tool_calls?: Array<{
-      function?: {
-        name?: string;
-        arguments?: Record<string, unknown>;
-      };
-    }>;
-  };
-  error?: string;
-}
-
-async function ollamaRequest<T>(
-  baseUrl: string,
-  path: string,
-  body: unknown,
-): Promise<T> {
-  const url = new URL(path, baseUrl);
-  const mod = url.protocol === "https:" ? https : http;
-  const payload = JSON.stringify(body);
-
-  return new Promise((resolve, reject) => {
-    const req = mod.request(
-      url,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Content-Length": Buffer.byteLength(payload),
-        },
-        timeout: 60_000,
-      },
-      (res) => {
-        const chunks: Buffer[] = [];
-        res.on("data", (c) => chunks.push(c));
-        res.on("end", () => {
-          const text = Buffer.concat(chunks).toString("utf8");
-          try {
-            resolve(JSON.parse(text) as T);
-          } catch {
-            reject(new Error(`Ollama: invalid JSON response: ${text.slice(0, 200)}`));
-          }
-        });
-      },
-    );
-    req.on("error", (err) => reject(new Error(`Ollama: ${err.message}`)));
-    req.on("timeout", () => {
-      req.destroy();
-      reject(new Error("Ollama: request timeout"));
-    });
-    req.write(payload);
-    req.end();
-  });
-}
-
-export async function ollamaHealthCheck(baseUrl: string): Promise<boolean> {
-  try {
-    const url = new URL("/api/tags", baseUrl);
-    const mod = url.protocol === "https:" ? https : http;
-    return new Promise((resolve) => {
-      const req = mod.get(url, { timeout: 3_000 }, (res) => {
-        res.resume();
-        resolve(res.statusCode === 200);
-      });
-      req.on("error", () => resolve(false));
-      req.on("timeout", () => { req.destroy(); resolve(false); });
-    });
-  } catch {
-    return false;
-  }
-}
-
-export function createOllamaLLMClient(cfg: OllamaConfig): LLMClient {
-  return {
-    async complete(prompt: string): Promise<string> {
-      const body: OllamaChatRequest = {
-        model: cfg.model,
-        messages: [{ role: "user", content: prompt }],
-        stream: false,
-        options: { num_predict: 8192 },
-      };
-      const resp = await ollamaRequest<OllamaChatResponse>(cfg.baseUrl, "/api/chat", body);
-      if (resp.error) throw new Error(`Ollama: ${resp.error}`);
-      const text = resp.message?.content?.trim();
-      if (!text) throw new Error("Ollama: empty response");
-      return text;
-    },
-  };
-}
-
-export function createOllamaMemoryHelper(cfg: OllamaConfig): MemoryHelperLLM {
-  return {
-    async compileIntents(text: string): Promise<CompileMemoryIntentsResult> {
-      const body: OllamaChatRequest = {
-        model: cfg.model,
-        messages: [
-          {
-            role: "user",
-            content: `Analyze whether the user message requires recalling private episodic memory.\n\n<message>\n${text}\n</message>`,
-          },
-        ],
-        stream: false,
-        tools: [
-          {
-            type: "function",
-            function: {
-              name: MEMORY_HELPER_TOOL_NAME,
-              description: "Decide whether to recall private episodic memory and compile structured query intents.",
-              parameters: COMPILE_MEMORY_INTENTS_PARAMETERS as unknown as Record<string, unknown>,
-            },
-          },
-        ],
-        options: { num_predict: 2048 },
-      };
-      const resp = await ollamaRequest<OllamaChatResponse>(cfg.baseUrl, "/api/chat", body);
-      if (resp.error) throw new Error(`Ollama: ${resp.error}`);
-
-      const toolCall = resp.message?.tool_calls?.[0]?.function;
-      if (toolCall?.name === MEMORY_HELPER_TOOL_NAME && toolCall.arguments) {
-        return toolCall.arguments as unknown as CompileMemoryIntentsResult;
-      }
-
-      const raw = resp.message?.content?.trim();
-      if (!raw) return { should_recall: false, intents: [] };
-
-      try {
-        const cleaned = raw.replace(/^```(?:json)?\s*/m, "").replace(/\s*```\s*$/m, "").trim();
-        return JSON.parse(cleaned) as CompileMemoryIntentsResult;
-      } catch {
-        return { should_recall: false, intents: [] };
-      }
-    },
-  };
-}

package/src/adapters/openaiCompatClient.ts

@@ -1,155 +0,0 @@
-import http from "node:http";
-import https from "node:https";
-
-import type { LLMClient } from "../trainer/llmExtractor.js";
-import type { MemoryHelperLLM } from "../preflight/detectIntents.js";
-import type { CompileMemoryIntentsResult } from "../preflight/detectIntents.js";
-import {
-  COMPILE_MEMORY_INTENTS_PARAMETERS,
-  MEMORY_HELPER_TOOL_NAME,
-} from "../preflight/detectIntents.js";
-
-export interface OpenAICompatConfig {
-  baseUrl: string;
-  model: string;
-  apiKey?: string;
-}
-
-interface ChatMessage {
-  role: "system" | "user" | "assistant";
-  content: string;
-}
-
-interface ChatCompletionRequest {
-  model: string;
-  messages: ChatMessage[];
-  max_tokens?: number;
-  tools?: Array<{
-    type: "function";
-    function: { name: string; description: string; parameters: Record<string, unknown> };
-  }>;
-  tool_choice?: { type: "function"; function: { name: string } };
-}
-
-interface ChatCompletionResponse {
-  choices?: Array<{
-    message?: {
-      content?: string | null;
-      tool_calls?: Array<{
-        function?: { name?: string; arguments?: string };
-      }>;
-    };
-  }>;
-  error?: { message?: string };
-}
-
-async function postJSON<T>(url: URL, body: unknown, apiKey?: string): Promise<T> {
-  const mod = url.protocol === "https:" ? https : http;
-  const payload = JSON.stringify(body);
-
-  return new Promise((resolve, reject) => {
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-      "Content-Length": String(Buffer.byteLength(payload)),
-    };
-    if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
-
-    const req = mod.request(url, { method: "POST", headers, timeout: 120_000 }, (res) => {
-      const chunks: Buffer[] = [];
-      res.on("data", (c) => chunks.push(c));
-      res.on("end", () => {
-        const text = Buffer.concat(chunks).toString("utf8");
-        try { resolve(JSON.parse(text) as T); }
-        catch { reject(new Error(`OpenAI-compat: invalid JSON: ${text.slice(0, 200)}`)); }
-      });
-    });
-    req.on("error", (err) => reject(new Error(`OpenAI-compat: ${err.message}`)));
-    req.on("timeout", () => { req.destroy(); reject(new Error("OpenAI-compat: timeout")); });
-    req.write(payload);
-    req.end();
-  });
-}
-
-export async function openaiCompatHealthCheck(baseUrl: string): Promise<boolean> {
-  try {
-    const url = new URL("/v1/models", baseUrl);
-    const mod = url.protocol === "https:" ? https : http;
-    return new Promise((resolve) => {
-      const req = mod.get(url, { timeout: 3_000 }, (res) => {
-        res.resume();
-        resolve(res.statusCode === 200);
-      });
-      req.on("error", () => resolve(false));
-      req.on("timeout", () => { req.destroy(); resolve(false); });
-    });
-  } catch {
-    return false;
-  }
-}
-
-export function createOpenAICompatLLMClient(cfg: OpenAICompatConfig): LLMClient {
-  return {
-    async complete(prompt: string): Promise<string> {
-      const url = new URL("/v1/chat/completions", cfg.baseUrl);
-      const body: ChatCompletionRequest = {
-        model: cfg.model,
-        messages: [{ role: "user", content: prompt }],
-        max_tokens: 8192,
-      };
-      const resp = await postJSON<ChatCompletionResponse>(url, body, cfg.apiKey);
-      if (resp.error?.message) throw new Error(`OpenAI-compat: ${resp.error.message}`);
-      const text = resp.choices?.[0]?.message?.content?.trim();
-      if (!text) throw new Error("OpenAI-compat: empty response");
-      return text;
-    },
-  };
-}
-
-export function createOpenAICompatMemoryHelper(cfg: OpenAICompatConfig): MemoryHelperLLM {
-  return {
-    async compileIntents(text: string): Promise<CompileMemoryIntentsResult> {
-      const url = new URL("/v1/chat/completions", cfg.baseUrl);
-      const body: ChatCompletionRequest = {
-        model: cfg.model,
-        messages: [
-          {
-            role: "user",
-            content: `Analyze whether the user message requires recalling private episodic memory.\n\n<message>\n${text}\n</message>`,
-          },
-        ],
-        max_tokens: 2048,
-        tools: [
-          {
-            type: "function",
-            function: {
-              name: MEMORY_HELPER_TOOL_NAME,
-              description: "Decide whether to recall private episodic memory and compile structured query intents.",
-              parameters: COMPILE_MEMORY_INTENTS_PARAMETERS as unknown as Record<string, unknown>,
-            },
-          },
-        ],
-        tool_choice: { type: "function", function: { name: MEMORY_HELPER_TOOL_NAME } },
-      };
-      const resp = await postJSON<ChatCompletionResponse>(url, body, cfg.apiKey);
-      if (resp.error?.message) throw new Error(`OpenAI-compat: ${resp.error.message}`);
-
-      const msg = resp.choices?.[0]?.message;
-      const toolCall = msg?.tool_calls?.[0]?.function;
-      if (toolCall?.name === MEMORY_HELPER_TOOL_NAME && toolCall.arguments) {
-        try {
-          return JSON.parse(toolCall.arguments) as CompileMemoryIntentsResult;
-        } catch { /* fall through */ }
-      }
-
-      const raw = msg?.content?.trim();
-      if (!raw) return { should_recall: false, intents: [] };
-
-      try {
-        const cleaned = raw.replace(/^```(?:json)?\s*/m, "").replace(/\s*```\s*$/m, "").trim();
-        return JSON.parse(cleaned) as CompileMemoryIntentsResult;
-      } catch {
-        return { should_recall: false, intents: [] };
-      }
-    },
-  };
-}

package/src/adapters/piComplete.ts

@@ -1,233 +0,0 @@
-import { complete, getEnvApiKey, getModels } from "@earendil-works/pi-ai/compat";
-import type { Api, Model, ProviderEnv, ToolCall } from "@earendil-works/pi-ai";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-
-import {
-  COMPILE_MEMORY_INTENTS_PARAMETERS,
-  MEMORY_HELPER_TOOL_NAME,
-  type CompileMemoryIntentsResult,
-  type MemoryHelperLLM,
-} from "../preflight/detectIntents.js";
-import type { LLMClient } from "../trainer/llmExtractor.js";
-
-export const DEFAULT_HELPER_PROVIDER = "deepseek";
-export const DEFAULT_HELPER_MODEL = "deepseek-v4-flash";
-
-const CompileMemoryIntentsParams = Type.Unsafe(COMPILE_MEMORY_INTENTS_PARAMETERS);
-
-export function parseModelSpec(
-  spec: string | boolean | undefined,
-  defaultProvider = DEFAULT_HELPER_PROVIDER,
-  defaultModelId = DEFAULT_HELPER_MODEL,
-): { provider: string; modelId: string } {
-  if (typeof spec !== "string" || !spec.trim()) {
-    return { provider: defaultProvider, modelId: defaultModelId };
-  }
-  const trimmed = spec.trim();
-  const slash = trimmed.indexOf("/");
-  if (slash === -1) {
-    return { provider: defaultProvider, modelId: trimmed };
-  }
-  return {
-    provider: trimmed.slice(0, slash),
-    modelId: trimmed.slice(slash + 1),
-  };
-}
-
-async function resolveModelAuth(
-  ctx: ExtensionContext,
-  provider: string,
-  modelId: string,
-): Promise<{ model: Model<Api>; apiKey: string; headers?: Record<string, string>; env?: ProviderEnv } | null> {
-  const model = ctx.modelRegistry.find(provider, modelId);
-  if (!model) return null;
-
-  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-  if (!auth.ok || !auth.apiKey) return null;
-
-  return {
-    model,
-    apiKey: auth.apiKey,
-    headers: auth.headers,
-    env: auth.env,
-  };
-}
-
-function extractTextFromResponse(content: Array<{ type: string; text?: string }>): string {
-  return content
-    .filter((block): block is { type: "text"; text: string } => block.type === "text")
-    .map((block) => block.text)
-    .join("\n");
-}
-
-function findToolCall(
-  content: Array<{ type: string; name?: string; arguments?: Record<string, unknown> }>,
-  toolName: string,
-): ToolCall | null {
-  for (const block of content) {
-    if (block.type === "toolCall" && block.name === toolName && block.arguments) {
-      return block as ToolCall;
-    }
-  }
-  return null;
-}
-
-function buildMemoryHelperLLM(
-  resolved: NonNullable<Awaited<ReturnType<typeof resolveModelAuth>>>,
-): MemoryHelperLLM {
-  return {
-    async compileIntents(text: string, signal?: AbortSignal): Promise<CompileMemoryIntentsResult> {
-      const response = await complete(
-        resolved.model,
-        {
-          messages: [
-            {
-              role: "user",
-              content: [
-                {
-                  type: "text",
-                  text: `Analyze whether the user message requires recalling private episodic memory.\n\n<message>\n${text}\n</message>`,
-                },
-              ],
-              timestamp: Date.now(),
-            },
-          ],
-          tools: [
-            {
-              name: MEMORY_HELPER_TOOL_NAME,
-              description:
-                "Decide whether to recall private episodic memory and compile structured query intents.",
-              parameters: CompileMemoryIntentsParams,
-            },
-          ],
-        },
-        {
-          apiKey: resolved.apiKey,
-          headers: resolved.headers,
-          env: resolved.env,
-          signal,
-          toolChoice: { type: "tool", name: MEMORY_HELPER_TOOL_NAME },
-        },
-      );
-
-      const toolCall = findToolCall(response.content, MEMORY_HELPER_TOOL_NAME);
-      if (toolCall?.arguments) {
-        return toolCall.arguments as CompileMemoryIntentsResult;
-      }
-
-      const raw = extractTextFromResponse(response.content);
-      if (!raw.trim()) {
-        return { should_recall: false, intents: [] };
-      }
-      return JSON.parse(raw) as CompileMemoryIntentsResult;
-    },
-  };
-}
-
-/** Resolve helper LLM when model + auth are available; otherwise null (regex-only preflight). */
-export async function resolveMemoryHelperLLM(
-  ctx: ExtensionContext,
-  modelSpec: string | boolean | undefined,
-): Promise<MemoryHelperLLM | null> {
-  const { provider, modelId } = parseModelSpec(modelSpec);
-  const resolved = await resolveModelAuth(ctx, provider, modelId);
-  if (!resolved) return null;
-  return buildMemoryHelperLLM(resolved);
-}
-
-/** @alias resolveMemoryHelperLLM */
-export const createMemoryHelperLLM = resolveMemoryHelperLLM;
-
-export function createPiLLMClient(
-  ctx: ExtensionContext,
-  modelSpec: string | boolean | undefined,
-): LLMClient | null {
-  const { provider, modelId } = parseModelSpec(modelSpec);
-
-  return {
-    async complete(prompt: string): Promise<string> {
-      const resolved = await resolveModelAuth(ctx, provider, modelId);
-      if (!resolved) {
-        throw new Error(`LLM model not available: ${provider}/${modelId}`);
-      }
-
-      const response = await complete(
-        resolved.model,
-        {
-          messages: [
-            {
-              role: "user",
-              content: [{ type: "text", text: prompt }],
-              timestamp: Date.now(),
-            },
-          ],
-        },
-        {
-          apiKey: resolved.apiKey,
-          headers: resolved.headers,
-          env: resolved.env,
-          maxTokens: 8192,
-        },
-      );
-
-      const text = extractTextFromResponse(response.content);
-      if (!text.trim()) {
-        throw new Error("LLM response was empty");
-      }
-      return text;
-    },
-  };
-}
-
-/** Standalone LLM client for CLI usage without ExtensionContext. */
-export function createStandaloneLLMClient(
-  modelSpec?: string,
-  env: NodeJS.ProcessEnv = process.env,
-): LLMClient {
-  const { provider, modelId } = parseModelSpec(modelSpec);
-  const providerEnv = toProviderEnv(env);
-  const model = getModels(provider as Parameters<typeof getModels>[0]).find((m) => m.id === modelId);
-  if (!model) {
-    throw new Error(`Model not found: ${provider}/${modelId}`);
-  }
-
-  const apiKey = getEnvApiKey(provider, providerEnv);
-  if (!apiKey) {
-    throw new Error(`No API key for ${provider} — set the provider env var or use regex extractor`);
-  }
-
-  return {
-    async complete(prompt: string): Promise<string> {
-      const response = await complete(
-        model,
-        {
-          messages: [
-            {
-              role: "user",
-              content: [{ type: "text", text: prompt }],
-              timestamp: Date.now(),
-            },
-          ],
-        },
-        {
-          apiKey,
-          maxTokens: 8192,
-          env: providerEnv,
-        },
-      );
-
-      const text = extractTextFromResponse(response.content);
-      if (!text.trim()) {
-        throw new Error("LLM response was empty");
-      }
-      return text;
-    },
-  };
-}
-
-function toProviderEnv(env: NodeJS.ProcessEnv): ProviderEnv {
-  return Object.fromEntries(
-    Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined),
-  );
-}