@chendpoc/pi-memory 0.2.1 → 0.2.3

package/src/adapters/embed/ollama.ts

@@ -1,49 +0,0 @@
-import { postJson } from "../http.js";
-import { assertEmbeddingDim, normalizeEmbedding } from "./normalize.js";
-import type { Embedder } from "./types.js";
-
-type OllamaEmbedResponse = {
-  model: string;
-  embeddings: number[][];
-};
-
-function joinUrl(baseUrl: string, path: string): string {
-  return `${baseUrl.replace(/\/+$/, "")}${path}`;
-}
-
-export function createOllamaEmbedder(opts: {
-  baseUrl: string;
-  model: string;
-  dim: number;
-  timeoutMs: number;
-}): Embedder {
-  const url = joinUrl(opts.baseUrl, "/api/embed");
-
-  const embedRemote = async (texts: string[]): Promise<Float32Array[]> => {
-    const json = await postJson<OllamaEmbedResponse>(
-      url,
-      { model: opts.model, input: texts.length === 1 ? texts[0] : texts },
-      { timeoutMs: opts.timeoutMs },
-    );
-
-    return json.embeddings.map((row, index) => {
-      const embedding = normalizeEmbedding(new Float32Array(row));
-      assertEmbeddingDim(embedding, opts.dim, `Ollama ${opts.model} row ${index}`);
-      return embedding;
-    });
-  };
-
-  return {
-    provider: "ollama",
-    model: opts.model,
-    dim: opts.dim,
-    async embed(text) {
-      const [embedding] = await embedRemote([text]);
-      return embedding!;
-    },
-    async embedBatch(texts) {
-      if (texts.length === 0) return [];
-      return embedRemote(texts);
-    },
-  };
-}

package/src/adapters/embed/openai.ts

@@ -1,46 +0,0 @@
-import { postJson } from "../http.js";
-import { assertEmbeddingDim, normalizeEmbedding } from "./normalize.js";
-import type { Embedder } from "./types.js";
-
-type OpenAiEmbedResponse = {
-  data: Array<{ embedding: number[]; index: number }>;
-};
-
-export function createOpenAiEmbedder(opts: {
-  apiKey: string;
-  model: string;
-  dim: number;
-  timeoutMs: number;
-}): Embedder {
-  const embedRemote = async (texts: string[]): Promise<Float32Array[]> => {
-    const json = await postJson<OpenAiEmbedResponse>(
-      "https://api.openai.com/v1/embeddings",
-      { model: opts.model, input: texts },
-      {
-        headers: { Authorization: `Bearer ${opts.apiKey}` },
-        timeoutMs: opts.timeoutMs,
-      },
-    );
-
-    return json.data
-      .sort((a, b) => a.index - b.index)
-      .map((row) => {
-        const embedding = normalizeEmbedding(new Float32Array(row.embedding));
-        assertEmbeddingDim(embedding, opts.dim, `OpenAI ${opts.model}`);
-        return embedding;
-      });
-  };
-
-  return {
-    provider: "openai",
-    model: opts.model,
-    dim: opts.dim,
-    async embed(text) {
-      const [embedding] = await embedRemote([text]);
-      return embedding!;
-    },
-    async embedBatch(texts) {
-      return embedRemote(texts);
-    },
-  };
-}

package/src/adapters/embed/types.ts

@@ -1,9 +0,0 @@
-import type { EmbedderProvider } from "../../config/env.js";
-
-export type Embedder = {
-  provider: EmbedderProvider;
-  model: string;
-  dim: number;
-  embed(text: string): Promise<Float32Array>;
-  embedBatch(texts: string[]): Promise<Float32Array[]>;
-};

package/src/adapters/http.ts

@@ -1,42 +0,0 @@
-export type PostJsonOptions = {
-  headers?: Record<string, string>;
-  timeoutMs?: number;
-  signal?: AbortSignal;
-};
-
-export class HttpRequestError extends Error {
-  constructor(
-    readonly url: string,
-    readonly status: number,
-    readonly body: string,
-  ) {
-    super(`${url} failed (${status}): ${body}`);
-    this.name = "HttpRequestError";
-  }
-}
-
-export async function postJson<T>(
-  url: string,
-  body: unknown,
-  opts: PostJsonOptions = {},
-): Promise<T> {
-  const timeoutMs = opts.timeoutMs ?? 30_000;
-  const signal = opts.signal ?? AbortSignal.timeout(timeoutMs);
-
-  const res = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      ...opts.headers,
-    },
-    body: JSON.stringify(body),
-    signal,
-  });
-
-  const text = await res.text();
-  if (!res.ok) {
-    throw new HttpRequestError(url, res.status, text);
-  }
-
-  return JSON.parse(text) as T;
-}

package/src/adapters/index.ts

@@ -1,16 +0,0 @@
-export { HttpRequestError, postJson, type PostJsonOptions } from "./http.js";
-export {
-  createEmbedder,
-  getEmbedder,
-  resetEmbedderForTests,
-  type Embedder,
-} from "./embed/factory.js";
-export {
-  createLlmClient,
-  createOllamaLlmClient,
-  createOpenAICompatLlmClient,
-  createPiLlmClient,
-  createStandaloneLlmClient,
-  parseModelSpec,
-  type LlmClient,
-} from "./llm/index.js";

package/src/adapters/llm/extractText.ts

@@ -1,6 +0,0 @@
-export function extractTextFromResponse(content: Array<{ type: string; text?: string }>): string {
-  return content
-    .filter((block) => block.type === "text")
-    .map((block) => block.text ?? "")
-    .join("\n");
-}

package/src/adapters/llm/factory.ts

@@ -1,60 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-
-import { readPiMemoryEnv, type PiMemoryEnv } from "../../config/env.js";
-import { isOllamaModelSpec, parseModelSpec } from "./modelSpec.js";
-import { createOllamaLlmClient, ollamaHealthCheck } from "./ollama.js";
-import { createOpenAICompatLlmClient, openaiCompatHealthCheck } from "./openai-compat.js";
-import { tryCreatePiLlmClient } from "./pi-ai.js";
-import { createStandaloneLlmClient } from "./standalone.js";
-import type { LlmClient } from "./types.js";
-
-export type CreateLlmClientOptions = {
-  ctx?: ExtensionContext;
-  modelSpec?: string;
-  env?: PiMemoryEnv;
-};
-
-/** Best-effort LLM client for QueryIntent / consolidate. Returns null when unavailable. */
-export async function createLlmClient(options: CreateLlmClientOptions = {}): Promise<LlmClient | null> {
-  const env = options.env ?? readPiMemoryEnv();
-  const modelSpec = options.modelSpec ?? env.helperModel;
-
-  if (options.ctx) {
-    const fromRegistry = await tryCreatePiLlmClient(options.ctx, modelSpec);
-    if (fromRegistry) return fromRegistry;
-  }
-
-  if (env.openaiCompatBaseUrl && env.openaiCompatModel) {
-    const ok = await openaiCompatHealthCheck(env.openaiCompatBaseUrl);
-    if (ok) {
-      return createOpenAICompatLlmClient({
-        baseUrl: env.openaiCompatBaseUrl,
-        model: env.openaiCompatModel,
-        apiKey: env.openaiCompatApiKey,
-        timeoutMs: env.httpTimeoutMs,
-      });
-    }
-  }
-
-  const ollamaModel = env.ollamaLlmModel ?? (isOllamaModelSpec(modelSpec) ? parseModelSpec(modelSpec).modelId : undefined);
-  if (ollamaModel) {
-    const ok = await ollamaHealthCheck(env.ollamaLlmBaseUrl);
-    if (ok) {
-      return createOllamaLlmClient({
-        baseUrl: env.ollamaLlmBaseUrl,
-        model: ollamaModel,
-        timeoutMs: env.httpTimeoutMs,
-      });
-    }
-  }
-
-  if (env.helperApiKey && modelSpec && !isOllamaModelSpec(modelSpec)) {
-    try {
-      return createStandaloneLlmClient(modelSpec, { apiKey: env.helperApiKey });
-    } catch {
-      // fall through
-    }
-  }
-
-  return null;
-}

package/src/adapters/llm/index.ts

@@ -1,7 +0,0 @@
-export { createLlmClient, type CreateLlmClientOptions } from "./factory.js";
-export { DEFAULT_HELPER_MODEL, DEFAULT_HELPER_PROVIDER, isOllamaModelSpec, parseModelSpec } from "./modelSpec.js";
-export { createOllamaLlmClient, ollamaHealthCheck } from "./ollama.js";
-export { createOpenAICompatLlmClient, openaiCompatHealthCheck } from "./openai-compat.js";
-export { createPiLlmClient } from "./pi-ai.js";
-export { createStandaloneLlmClient } from "./standalone.js";
-export type { LlmClient, OllamaLlmConfig, OpenAICompatLlmConfig } from "./types.js";

package/src/adapters/llm/modelSpec.ts

@@ -1,39 +0,0 @@
-import {
-  DEFAULT_HELPER_MODEL,
-  DEFAULT_HELPER_MODEL_SPEC,
-  DEFAULT_HELPER_PROVIDER,
-} from "../../constants/env.js";
-
-export { DEFAULT_HELPER_MODEL, DEFAULT_HELPER_PROVIDER };
-
-export type ModelSpec = {
-  provider: string;
-  modelId: string;
-};
-
-export function parseModelSpec(
-  spec: string | undefined,
-  defaultProvider = DEFAULT_HELPER_PROVIDER,
-  defaultModelId = DEFAULT_HELPER_MODEL,
-): ModelSpec {
-  if (!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),
-  };
-}
-
-export function isOllamaModelSpec(spec: string | undefined): boolean {
-  return !!spec?.trim().startsWith("ollama/");
-}
-
-export { DEFAULT_HELPER_MODEL_SPEC };

package/src/adapters/llm/ollama.ts

@@ -1,42 +0,0 @@
-import { postJson } from "../http.js";
-import type { LlmClient, OllamaLlmConfig } from "./types.js";
-
-type OllamaChatResponse = {
-  message?: { content?: string };
-  error?: string;
-};
-
-export async function ollamaHealthCheck(baseUrl: string): Promise<boolean> {
-  try {
-    const url = new URL("/api/tags", baseUrl);
-    const res = await fetch(url, { signal: AbortSignal.timeout(3_000) });
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-
-export function createOllamaLlmClient(cfg: OllamaLlmConfig): LlmClient {
-  const baseUrl = cfg.baseUrl.replace(/\/$/, "");
-  const timeoutMs = cfg.timeoutMs ?? 60_000;
-
-  return {
-    async complete(prompt, signal) {
-      const resp = await postJson<OllamaChatResponse>(
-        `${baseUrl}/api/chat`,
-        {
-          model: cfg.model,
-          messages: [{ role: "user", content: prompt }],
-          stream: false,
-          options: { num_predict: 1024 },
-        },
-        { timeoutMs, signal },
-      );
-
-      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;
-    },
-  };
-}

package/src/adapters/llm/openai-compat.ts

@@ -1,46 +0,0 @@
-import { DEFAULT_LLM_COMPAT_TIMEOUT_MS } from "../../constants/timing.js";
-import { postJson } from "../http.js";
-import type { LlmClient, OpenAICompatLlmConfig } from "./types.js";
-
-type ChatCompletionResponse = {
-  choices?: Array<{ message?: { content?: string } }>;
-  error?: { message?: string };
-};
-
-export async function openaiCompatHealthCheck(baseUrl: string): Promise<boolean> {
-  try {
-    const url = new URL("/v1/models", baseUrl);
-    const res = await fetch(url, { signal: AbortSignal.timeout(3_000) });
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-
-export function createOpenAICompatLlmClient(cfg: OpenAICompatLlmConfig): LlmClient {
-  const baseUrl = cfg.baseUrl.replace(/\/$/, "");
-  const timeoutMs = cfg.timeoutMs ?? DEFAULT_LLM_COMPAT_TIMEOUT_MS;
-
-  return {
-    async complete(prompt, signal) {
-      const resp = await postJson<ChatCompletionResponse>(
-        `${baseUrl}/v1/chat/completions`,
-        {
-          model: cfg.model,
-          messages: [{ role: "user", content: prompt }],
-          max_tokens: 1024,
-        },
-        {
-          timeoutMs,
-          signal,
-          headers: cfg.apiKey ? { Authorization: `Bearer ${cfg.apiKey}` } : undefined,
-        },
-      );
-
-      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;
-    },
-  };
-}

package/src/adapters/llm/pi-ai.ts

@@ -1,75 +0,0 @@
-import { complete } from "@earendil-works/pi-ai/compat";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-
-import { nowMs } from "../../utils/time.js";
-import type { LlmClient } from "./types.js";
-import { extractTextFromResponse } from "./extractText.js";
-import { parseModelSpec } from "./modelSpec.js";
-
-async function resolveModelAuth(ctx: ExtensionContext, provider: string, modelId: string) {
-  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,
-  };
-}
-
-export async function tryCreatePiLlmClient(
-  ctx: ExtensionContext,
-  modelSpec?: string,
-): Promise<LlmClient | null> {
-  const { provider, modelId } = parseModelSpec(modelSpec);
-  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 createPiLlmClient(ctx, modelSpec);
-}
-
-export function createPiLlmClient(ctx: ExtensionContext, modelSpec?: string): LlmClient {
-  const { provider, modelId } = parseModelSpec(modelSpec);
-
-  return {
-    async complete(prompt, signal) {
-      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: nowMs(),
-            },
-          ],
-        },
-        {
-          apiKey: resolved.apiKey,
-          headers: resolved.headers,
-          env: resolved.env,
-          maxTokens: 1024,
-          signal,
-        },
-      );
-
-      const text = extractTextFromResponse(response.content);
-      if (!text.trim()) {
-        throw new Error("LLM response was empty");
-      }
-      return text;
-    },
-  };
-}

package/src/adapters/llm/standalone.ts

@@ -1,60 +0,0 @@
-import pickBy from "lodash/pickBy.js";
-
-import { complete, getEnvApiKey, getModels } from "@earendil-works/pi-ai/compat";
-
-import { nowMs } from "../../utils/time.js";
-
-import type { LlmClient } from "./types.js";
-import { extractTextFromResponse } from "./extractText.js";
-import { parseModelSpec } from "./modelSpec.js";
-
-function toProviderEnv(env: NodeJS.ProcessEnv): Record<string, string> {
-  return pickBy(env, (value): value is string => value !== undefined);
-}
-
-export function createStandaloneLlmClient(
-  modelSpec: string,
-  options: { apiKey?: string; env?: NodeJS.ProcessEnv } = {},
-): LlmClient {
-  const { provider, modelId } = parseModelSpec(modelSpec);
-  const providerEnv = toProviderEnv(options.env ?? process.env);
-  type ProviderArg = Parameters<typeof getModels>[0];
-  const model = getModels(provider as ProviderArg).find((item) => item.id === modelId);
-  if (!model) {
-    throw new Error(`Model not found: ${provider}/${modelId}`);
-  }
-
-  const apiKey = options.apiKey ?? getEnvApiKey(provider, providerEnv);
-  if (!apiKey) {
-    throw new Error(`No API key for ${provider}`);
-  }
-
-  return {
-    async complete(prompt, signal) {
-      const response = await complete(
-        model,
-        {
-          messages: [
-            {
-              role: "user",
-              content: [{ type: "text", text: prompt }],
-              timestamp: nowMs(),
-            },
-          ],
-        },
-        {
-          apiKey,
-          maxTokens: 1024,
-          env: providerEnv,
-          signal,
-        },
-      );
-
-      const text = extractTextFromResponse(response.content);
-      if (!text.trim()) {
-        throw new Error("LLM response was empty");
-      }
-      return text;
-    },
-  };
-}

package/src/adapters/llm/types.ts

@@ -1,16 +0,0 @@
-export type LlmClient = {
-  complete(prompt: string, signal?: AbortSignal): Promise<string>;
-};
-
-export type OllamaLlmConfig = {
-  baseUrl: string;
-  model: string;
-  timeoutMs?: number;
-};
-
-export type OpenAICompatLlmConfig = {
-  baseUrl: string;
-  model: string;
-  apiKey?: string;
-  timeoutMs?: number;
-};

package/src/cli/init.ts

@@ -1,18 +0,0 @@
-import { initializeMemoryWorkspace } from "../init/workspace.js";
-
-import type { CliLog } from "./log.js";
-
-export async function runInitCommand(agentDir: string, log: CliLog): Promise<number> {
-  const result = await initializeMemoryWorkspace(agentDir);
-
-  log.line("agent dir", result.agentDir);
-  log.line("memory file", result.memoryFile);
-
-  if (result.skipped) {
-    log.warn("MEMORY.md already exists (left unchanged)");
-    return 0;
-  }
-
-  log.success("Created MEMORY.md from pi-memory template");
-  return 0;
-}

package/src/cli/jobs.ts

@@ -1,144 +0,0 @@
-import type { CliLog } from "./log.js";
-import { runConsolidateJob } from "../consolidate/runJob.js";
-import { runDrainShutdownQueueJob } from "../shutdown/runDrainJob.js";
-import type { LlmClient } from "../adapters/llm/types.js";
-import type { MemoryStore } from "../store/memoryStore.js";
-
-export type MaintenanceCliOptions = {
-  cron: boolean;
-  force: boolean;
-  verbose: boolean;
-};
-
-export async function runMaintenanceCommand(opts: {
-  store: MemoryStore;
-  agentDir: string;
-  llm: LlmClient | null;
-  options: MaintenanceCliOptions;
-  log: CliLog;
-}): Promise<number> {
-  const { store, agentDir, llm, options, log } = opts;
-
-  log.debug(`maintenance agentDir=${agentDir} cron=${options.cron} force=${options.force}`);
-
-  log.line("step", "consolidate");
-  const consolidateResult = await runConsolidateJob({
-    store,
-    agentDir,
-    llm,
-    cronFired: options.cron,
-    force: options.force,
-  });
-
-  switch (consolidateResult.status) {
-    case "skipped":
-      log.warn("consolidate skipped (conditions not met)");
-      break;
-    case "consolidated":
-      log.success("consolidate complete");
-      if (options.verbose) {
-        log.line("entries", `${consolidateResult.stats.entriesBefore} → ${consolidateResult.stats.entriesAfter}`);
-        log.line(
-          "overflow files",
-          `${consolidateResult.stats.overflowBefore} → ${consolidateResult.stats.overflowAfter}`,
-        );
-      }
-      break;
-    case "failed":
-      log.error(`consolidate failed: ${consolidateResult.error.message}`);
-      return 1;
-  }
-
-  log.line("step", "drain-shutdown-queue");
-  const drainResult = await runDrainShutdownQueueJob({ store, agentDir, llm });
-
-  switch (drainResult.status) {
-    case "empty":
-      log.warn("shutdown queue empty");
-      return 0;
-    case "drained":
-      log.success("shutdown queue drained");
-      if (options.verbose) {
-        log.line("queued sessions", String(drainResult.stats.queued));
-        log.line("ingested sessions", String(drainResult.stats.ingested));
-        log.line("skipped sessions", String(drainResult.stats.skipped));
-        log.line("appended entries", String(drainResult.stats.appended));
-        if (drainResult.stats.indexGeneration !== undefined) {
-          log.line("index generation", String(drainResult.stats.indexGeneration));
-        }
-      }
-      return 0;
-    case "failed":
-      log.error(`shutdown queue drain failed: ${drainResult.error.message}`);
-      return 1;
-  }
-}
-
-export async function runDrainShutdownQueueCommand(opts: {
-  store: MemoryStore;
-  agentDir: string;
-  llm: LlmClient | null;
-  verbose: boolean;
-  log: CliLog;
-}): Promise<number> {
-  const result = await runDrainShutdownQueueJob({
-    store: opts.store,
-    agentDir: opts.agentDir,
-    llm: opts.llm,
-  });
-
-  switch (result.status) {
-    case "empty":
-      opts.log.warn("shutdown queue empty");
-      return 0;
-    case "drained":
-      opts.log.success("shutdown queue drained");
-      if (opts.verbose) {
-        opts.log.line("queued sessions", String(result.stats.queued));
-        opts.log.line("ingested sessions", String(result.stats.ingested));
-        opts.log.line("skipped sessions", String(result.stats.skipped));
-        opts.log.line("appended entries", String(result.stats.appended));
-      }
-      return 0;
-    case "failed":
-      opts.log.error(`shutdown queue drain failed: ${result.error.message}`);
-      return 1;
-  }
-}
-
-export async function runConsolidateCommand(opts: {
-  store: MemoryStore;
-  agentDir: string;
-  llm: LlmClient | null;
-  cron: boolean;
-  force: boolean;
-  verbose: boolean;
-  log: CliLog;
-}): Promise<number> {
-  const result = await runConsolidateJob({
-    store: opts.store,
-    agentDir: opts.agentDir,
-    llm: opts.llm,
-    cronFired: opts.cron,
-    force: opts.force,
-  });
-
-  switch (result.status) {
-    case "skipped":
-      opts.log.warn("consolidate skipped (conditions not met)");
-      return 0;
-    case "consolidated":
-      opts.log.success("consolidate complete");
-      if (opts.verbose) {
-        opts.log.line("entries", `${result.stats.entriesBefore} → ${result.stats.entriesAfter}`);
-        opts.log.line(
-          "overflow files",
-          `${result.stats.overflowBefore} → ${result.stats.overflowAfter}`,
-        );
-      }
-      return 0;
-    case "failed":
-      opts.log.error(`consolidate failed: ${result.error.message}`);
-      return 1;
-  }
-}