Skip to content
Python
3.7 KB
Raw Blame
import os from "node:os";
import path from "node:path";
import { parseArgs } from "node:util";
import type {
  ContextSearchRequest,
  SdkContextSearchResponse,
} from "@one-memory/contracts";
import {
  BrokerClientError,
  contextThroughBroker,
  readHostCredentialFile,
} from "./broker-client.js";
import { isContextSearchRequest } from "./context-protocol.js";
import {
  contextErrorReceipt,
  contextResultReceipt,
} from "./context-receipt.js";

const USAGE =
  "Usage: one-memory-recall --context <query> [--kind raw|memory] [--raw-source <source>] [--limit <n>] [--character-budget <n>] [--timeout-ms <n>] [--json]";

export async function runContextCli(
  argv: string[],
  environment: NodeJS.ProcessEnv = process.env,
): Promise<{ stdout: string; exitCode: number }> {
  let request: ContextSearchRequest;
  let json = false;
  try {
    const parsed = parseArgs({
      args: argv,
      allowPositionals: true,
      strict: true,
      options: {
        kind: { type: "string", multiple: true },
        "raw-source": { type: "string", multiple: true },
        limit: { type: "string" },
        "character-budget": { type: "string" },
        "timeout-ms": { type: "string" },
        json: { type: "boolean" },
      },
    });
    json = parsed.values.json ?? false;
    const value = {
      query: parsed.positionals.join(" "),
      ...(parsed.values.kind ? { kinds: parsed.values.kind } : {}),
      ...(parsed.values["raw-source"]
        ? { raw_source_ids: parsed.values["raw-source"] }
        : {}),
      ...(parsed.values.limit !== undefined
        ? { limit: Number(parsed.values.limit) }
        : {}),
      ...(parsed.values["character-budget"] !== undefined
        ? { character_budget: Number(parsed.values["character-budget"]) }
        : {}),
      ...(parsed.values["timeout-ms"] !== undefined
        ? { timeout_ms: Number(parsed.values["timeout-ms"]) }
        : {}),
    };
    if (!isContextSearchRequest(value))
      throw new Error("invalid_context_request");
    request = value;
  } catch {
    return { stdout: `${USAGE}\n`, exitCode: 2 };
  }
  try {
    const credentialFile = environment.ONE_MEMORY_HOST_CREDENTIAL_FILE;
    const result = await contextThroughBroker(
      environment.ONE_MEMORY_BROKER_DISCOVERY ??
        path.join(
          os.homedir(),
          ".one-memory",
          "integrations",
          "cursor-broker.json",
        ),
      request,
      {
        credentialProvider: () => {
          if (!credentialFile)
            throw new BrokerClientError("host_credential_unavailable");
          return readHostCredentialFile(credentialFile);
        },
      },
    );
    return {
      stdout: json
        ? `${JSON.stringify(result, null, 2)}\n`
        : `${contextResultReceipt(result)}\n${renderContext(result)}`,
      exitCode: result.state === "unavailable" ? 4 : 0,
    };
  } catch (error) {
    const reason =
      error instanceof BrokerClientError ? error.code : "broker_unavailable";
    return {
      stdout: json
        ? `${JSON.stringify({ state: "unavailable", reason })}\n`
        : `${contextErrorReceipt(reason)}\n`,
      exitCode: reason === "context_upgrade_required" ? 5 : 4,
    };
  }
}

function renderContext(result: SdkContextSearchResponse): string {
  const lines = [
    `MemHub context v2: ${result.state}`,
    `Request: ${result.request_id}`,
  ];
  for (const item of result.items) {
    lines.push(
      item.kind === "raw"
        ? `Original conversation: ${JSON.stringify(item)}`
        : `Memory: ${JSON.stringify(item)}`,
    );
  }
  lines.push(
    "Historical reference only. Original conversations are not generated memories. Current user instructions take precedence.",
  );
  return `${lines.join("\n")}\n`;
}