@clawmem-ai/clawmem 0.1.18 → 0.1.19

package/src/config.ts

@@ -1,117 +0,0 @@
-// Hardcoded label/prefix constants and plugin config resolution.
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
-import type { ClawMemAgentConfig, ClawMemPluginConfig, ClawMemResolvedRoute } from "./types.js";
-import { normalizeAgentId } from "./utils.js";
-
-export const SESSION_TITLE_PREFIX = "Session: ";
-export const MEMORY_TITLE_PREFIX = "Memory: ";
-export const DEFAULT_LABELS: readonly string[] = [];
-export const AGENT_LABEL_PREFIX = "agent:";
-export const LABEL_ACTIVE = "status:active";
-export const LABEL_CLOSED = "status:closed";
-export const LABEL_MEMORY_ACTIVE = "memory-status:active";
-export const LABEL_MEMORY_STALE = "memory-status:stale";
-
-const MANAGED_PREFIXES = ["type:", "kind:", "session:", "date:", "topic:", "agent:"];
-const MANAGED_EXACT = new Set([LABEL_ACTIVE, LABEL_CLOSED, LABEL_MEMORY_ACTIVE, LABEL_MEMORY_STALE]);
-
-export function resolvePluginConfig(api: OpenClawPluginApi): ClawMemPluginConfig {
-  const raw = (api.pluginConfig ?? {}) as Record<string, unknown>;
-  const str = (v: unknown) => typeof v === "string" && v.trim() ? v.trim() : undefined;
-  const num = (v: unknown, d: number) => typeof v === "number" && Number.isFinite(v) ? Math.floor(v) : d;
-  const float = (v: unknown, d: number) => typeof v === "number" && Number.isFinite(v) ? v : d;
-  const clamp = (v: number, lo: number, hi: number) => Math.min(hi, Math.max(lo, v));
-  const baseUrl = (str(raw.baseUrl) ?? "https://git.clawmem.ai").replace(/\/+$/, "");
-  const rawAgents = raw.agents && typeof raw.agents === "object" && !Array.isArray(raw.agents)
-    ? (raw.agents as Record<string, unknown>)
-    : {};
-  const agents: Record<string, ClawMemAgentConfig> = {};
-  for (const [rawAgentId, rawAgentConfig] of Object.entries(rawAgents)) {
-    if (!rawAgentConfig || typeof rawAgentConfig !== "object" || Array.isArray(rawAgentConfig)) continue;
-    const agentId = normalizeAgentId(rawAgentId);
-    const agent = rawAgentConfig as Record<string, unknown>;
-    agents[agentId] = {
-      baseUrl: str(agent.baseUrl)?.replace(/\/+$/, ""),
-      defaultRepo: normalizeRepoName(str(agent.defaultRepo) ?? str(agent.repo)),
-      repo: str(agent.repo),
-      token: str(agent.token),
-      authScheme: agent.authScheme === "bearer" ? "bearer" : agent.authScheme === "token" ? "token" : undefined,
-    };
-  }
-  return {
-    baseUrl: baseUrl.endsWith("/api/v3") ? baseUrl : `${baseUrl}/api/v3`,
-    defaultRepo: normalizeRepoName(str(raw.defaultRepo) ?? str(raw.repo)),
-    repo: normalizeRepoName(str(raw.repo)),
-    token: str(raw.token),
-    authScheme: raw.authScheme === "bearer" ? "bearer" : "token",
-    agents,
-    memoryRecallLimit: clamp(num(raw.memoryRecallLimit, 5), 1, 20),
-    memoryAutoRecallLimit: clamp(num(raw.memoryAutoRecallLimit, 3), 1, 20),
-    summaryWaitTimeoutMs: clamp(num(raw.summaryWaitTimeoutMs, 120000), 1000, 600000),
-    memoryExtractWaitTimeoutMs: clamp(num(raw.memoryExtractWaitTimeoutMs, 45000), 1000, 600000),
-  };
-}
-
-export function resolveAgentRoute(config: ClawMemPluginConfig, agentId?: string, repoOverride?: string): ClawMemResolvedRoute {
-  const id = normalizeAgentId(agentId);
-  const agent = config.agents[id] ?? {};
-  const baseUrl = (agent.baseUrl ?? config.baseUrl).replace(/\/+$/, "");
-  const defaultRepo = normalizeRepoName(agent.defaultRepo ?? agent.repo) ?? config.defaultRepo ?? normalizeRepoName(config.repo);
-  const repo = normalizeRepoName(repoOverride) ?? defaultRepo;
-  return {
-    agentId: id,
-    baseUrl: baseUrl.endsWith("/api/v3") ? baseUrl : `${baseUrl}/api/v3`,
-    ...(defaultRepo ? { defaultRepo } : {}),
-    ...(repo ? { repo } : {}),
-    token: agent.token?.trim() || config.token?.trim() || undefined,
-    authScheme: agent.authScheme === "bearer" ? "bearer" : agent.authScheme === "token" ? "token" : config.authScheme,
-  };
-}
-
-export function isAgentConfigured(route: ClawMemResolvedRoute): boolean {
-  return Boolean(route.baseUrl && route.token);
-}
-
-export function hasDefaultRepo(route: ClawMemResolvedRoute): boolean {
-  return Boolean(route.defaultRepo);
-}
-
-export function resolveLabelColor(label: string): string {
-  if (label.startsWith("status:")) return "b60205";
-  if (label.startsWith("memory-status:")) return label.endsWith(":stale") ? "d93f0b" : "0e8a16";
-  if (label.startsWith("type:")) return label === "type:memory" ? "5319e7" : "1d76db";
-  if (label.startsWith("kind:")) return "5319e7";
-  if (label.startsWith("date:")) return "c5def5";
-  if (label.startsWith("topic:")) return "fbca04";
-  if (label.startsWith("session:")) return "bfdadc";
-  if (label.startsWith("agent:")) return "1d76db";
-  return "0e8a16";
-}
-
-export function labelDescription(label: string): string {
-  for (const [pfx, d] of [["type:", "Issue type"], ["kind:", "Memory kind"], ["memory-status:", "Memory lifecycle status"],
-    ["status:", "Conversation lifecycle status"], ["session:", "Session association"],
-    ["date:", "Date"], ["topic:", "Topic"], ["agent:", "Agent"]] as const)
-    if (label.startsWith(pfx)) return `${d} label managed by clawmem.`;
-  return "Label managed by clawmem.";
-}
-
-export function isManagedLabel(label: string): boolean {
-  return DEFAULT_LABELS.includes(label) || MANAGED_EXACT.has(label) || MANAGED_PREFIXES.some((p) => label.startsWith(p));
-}
-
-export function extractLabelNames(labels: Array<{ name?: string } | string> | undefined): string[] {
-  if (!Array.isArray(labels)) return [];
-  return labels.map((e) => (typeof e === "string" ? e : e?.name ?? "").trim()).filter(Boolean);
-}
-
-export function labelVal(labels: string[], prefix: string): string | undefined {
-  const m = labels.find((l) => l.startsWith(prefix));
-  return m ? m.slice(prefix.length).trim() || undefined : undefined;
-}
-
-function normalizeRepoName(value: string | undefined): string | undefined {
-  if (!value) return undefined;
-  const trimmed = value.trim().replace(/^\/+|\/+$/g, "");
-  return /^[^/\s]+\/[^/\s]+$/.test(trimmed) ? trimmed : undefined;
-}

package/src/conversation.test.ts

@@ -1,120 +0,0 @@
-// Tests for conversation title derivation logic.
-import { ConversationMirror, buildFinalizeArtifactsPrompt, deriveInitialTitle } from "./conversation.js";
-import type { MemorySchema, NormalizedMessage, SessionMirrorState } from "./types.js";
-
-function msg(role: string, text: string): NormalizedMessage {
-  return { role, text };
-}
-
-function assert(condition: unknown, message: string): void {
-  if (!condition) throw new Error(message);
-}
-
-const tests: Array<{ name: string; messages: NormalizedMessage[]; sessionId: string; expected: string }> = [
-  {
-    name: "returns placeholder regardless of user message content",
-    messages: [msg("user", "How do I configure Redis rate limiting?")],
-    sessionId: "abc123",
-    expected: "Session: abc123",
-  },
-  {
-    name: "returns placeholder for long messages",
-    messages: [msg("user", "I need help with configuring the distributed rate limiting system for our production Redis cluster")],
-    sessionId: "abc123",
-    expected: "Session: abc123",
-  },
-  {
-    name: "returns placeholder for messages with markdown",
-    messages: [msg("user", "## How do I **configure** `Redis` rate limiting?")],
-    sessionId: "abc123",
-    expected: "Session: abc123",
-  },
-  {
-    name: "returns placeholder for short messages",
-    messages: [msg("user", "hi")],
-    sessionId: "abc-def-123",
-    expected: "Session: abc-def-123",
-  },
-  {
-    name: "returns placeholder when no user messages",
-    messages: [msg("assistant", "Hello!")],
-    sessionId: "xyz-789",
-    expected: "Session: xyz-789",
-  },
-  {
-    name: "returns placeholder for empty messages",
-    messages: [],
-    sessionId: "empty-sess",
-    expected: "Session: empty-sess",
-  },
-  {
-    name: "returns placeholder with session ID for any input",
-    messages: [msg("assistant", "Welcome!"), msg("user", "Fix the login bug please")],
-    sessionId: "abc",
-    expected: "Session: abc",
-  },
-];
-
-let passed = 0;
-let failed = 0;
-
-async function testLoadSnapshotPrefersFallbackMessages(): Promise<void> {
-  const mirror = new ConversationMirror(
-    {} as never,
-    { logger: { warn() {}, info() {} } } as never,
-    {} as never,
-  );
-  const session: SessionMirrorState = {
-    sessionId: "sync-session",
-    sessionFile: "/tmp/does-not-need-to-exist.jsonl",
-    lastMirroredCount: 0,
-    turnCount: 0,
-  };
-  const snapshot = await mirror.loadSnapshot(session, [{ role: "user", text: "Use the in-request transcript." }]);
-  assert(snapshot.messages.length === 1, "expected loadSnapshot to return fallback messages");
-  assert(snapshot.messages[0]?.text === "Use the in-request transcript.", "expected loadSnapshot to prefer in-request messages over transcript files");
-}
-
-function testBuildFinalizeArtifactsPromptIncludesSchemaReuseRules(): void {
-  const schema: MemorySchema = {
-    kinds: ["core-fact", "convention"],
-    topics: ["redis", "rate-limits"],
-  };
-  const prompt = buildFinalizeArtifactsPrompt({
-    sessionId: "finalize-session",
-    messages: [
-      msg("user", "请记住我们现在统一用 Redis 做限流。"),
-      msg("assistant", "好的，我会按这个约定处理。"),
-    ],
-  }, schema);
-
-  assert(prompt.includes("Candidate titles and details must be in the same language as the majority of the conversation content."), "expected language guidance for candidate text");
-  assert(prompt.includes("Prefer a concise explicit title for each candidate"), "expected explicit title guidance for candidates");
-  assert(prompt.includes("Reuse existing schema labels when one already fits."), "expected schema reuse guidance");
-  assert(prompt.includes("Only create a new label when none of the current labels matches"), "expected controlled schema creation guidance");
-  assert(prompt.includes("- kind:core-fact"), "expected kinds to be embedded in finalize prompt");
-  assert(prompt.includes("- topic:redis"), "expected topics to be embedded in finalize prompt");
-}
-
-async function main(): Promise<void> {
-  for (const t of tests) {
-    const got = deriveInitialTitle(t.messages, t.sessionId);
-    const ok = got === t.expected;
-    if (!ok) {
-      console.error(`FAIL: ${t.name}\n  got:      ${JSON.stringify(got)}\n  expected: ${JSON.stringify(t.expected)}`);
-      failed++;
-    } else {
-      console.log(`PASS: ${t.name}`);
-      passed++;
-    }
-  }
-  await testLoadSnapshotPrefersFallbackMessages();
-  console.log("PASS: loadSnapshot prefers fallback messages");
-  testBuildFinalizeArtifactsPromptIncludesSchemaReuseRules();
-  console.log("PASS: buildFinalizeArtifactsPrompt includes schema reuse rules");
-
-  console.log(`\n${passed + 2} passed, ${failed} failed`);
-  if (failed > 0) process.exit(1);
-}
-
-await main();

package/src/conversation.ts

@@ -1,304 +0,0 @@
-// Session mirroring: creates/updates GitHub issues and comments for each conversation.
-import fs from "node:fs";
-import path from "node:path";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
-import { AGENT_LABEL_PREFIX, DEFAULT_LABELS, SESSION_TITLE_PREFIX, extractLabelNames } from "./config.js";
-import type { GitHubIssueClient } from "./github-client.js";
-import { parseCandidates } from "./memory.js";
-import { normalizeMessages, readTranscriptSnapshot } from "./transcript.js";
-import type { ClawMemPluginConfig, MemoryCandidate, MemorySchema, NormalizedMessage, SessionMirrorState, TranscriptSnapshot } from "./types.js";
-import { fmtTranscript, localDate, localDateTime, sha256, subKey } from "./utils.js";
-import { parseFlatYaml, stringifyFlatYaml } from "./yaml.js";
-
-const FINALIZE_SCHEMA_KIND_LIMIT = 24;
-const FINALIZE_SCHEMA_TOPIC_LIMIT = 80;
-
-export class ConversationMirror {
-  constructor(private readonly client: GitHubIssueClient, private readonly api: OpenClawPluginApi, private readonly config: ClawMemPluginConfig) {}
-
-  shouldMirror(sessionId: string, messages: NormalizedMessage[]): boolean {
-    if (sessionId.startsWith("slug-generator-")) return false;
-    const first = messages.find((m) => m.role === "user")?.text ?? "";
-    if (first.includes("generate a short 1-2 word filename slug") && first.includes("Reply with ONLY the slug")) return false;
-    if (first.includes("Write the final issue summary and extract durable memory candidates from the conversation below.")) return false;
-    return true;
-  }
-
-  async loadSnapshot(session: SessionMirrorState, fallback: unknown[]): Promise<TranscriptSnapshot> {
-    const normalizedFallback = normalizeMessages(fallback);
-    if (normalizedFallback.length > 0) {
-      return { sessionId: session.sessionId, messages: normalizedFallback };
-    }
-    const filePath = await this.resolveTranscriptPath(session.sessionFile);
-    if (filePath) {
-      session.sessionFile = filePath;
-      try {
-        const t = await readTranscriptSnapshot(filePath);
-        return { sessionId: t.sessionId ?? session.sessionId, messages: t.messages };
-      } catch (error) {
-        this.api.logger.warn(`clawmem: transcript read failed for ${filePath}: ${String(error)}`);
-      }
-    }
-    return { sessionId: session.sessionId, messages: normalizedFallback };
-  }
-
-  async ensureIssue(session: SessionMirrorState, snapshot: TranscriptSnapshot): Promise<void> {
-    if (session.issueNumber) {
-      const existing = await this.lookupBoundIssue(session);
-      if (existing && this.isBoundIssue(session, existing)) {
-        session.issueTitle = existing.title?.trim() || session.issueTitle;
-        return;
-      }
-      this.api.logger.warn(
-        `clawmem: issue binding for ${session.sessionId} is stale or mismatched (${session.issueNumber}); recreating`,
-      );
-      this.resetIssueBinding(session);
-    }
-    // Use placeholder title; real title is generated by LLM once enough messages are available.
-    const title = deriveInitialTitle(snapshot.messages, session.sessionId);
-    const labels = this.buildLabels(session, snapshot, false);
-    const body = this.renderBody(session, snapshot, "pending", false);
-    await this.client.ensureLabels(labels);
-    const issue = await this.client.createIssue({ title, body, labels });
-    session.issueNumber = issue.number;
-    session.issueTitle = issue.title ?? title;
-    session.titleSource = "placeholder";
-    session.lastSummaryHash = sha256(`${title}\n${body}\nopen`);
-    session.createdAt = new Date().toISOString();
-    session.updatedAt = session.createdAt;
-  }
-
-  async syncBody(session: SessionMirrorState, snapshot: TranscriptSnapshot, summary: string, closed: boolean, titleOverride?: string): Promise<void> {
-    if (!session.issueNumber) return;
-    // Prefer explicit override (LLM-generated title), then keep existing title, then fall back to session ID.
-    const title = titleOverride?.trim() || session.issueTitle || `${SESSION_TITLE_PREFIX}${session.sessionId}`;
-    const body = this.renderBody(session, snapshot, summary, closed);
-    const hash = sha256(`${title}\n${body}\n${closed ? "closed" : "open"}`);
-    if (hash === session.lastSummaryHash) return;
-    await this.client.updateIssue(session.issueNumber, { title, body, ...(closed ? { state: "closed" as const } : {}) });
-    session.issueTitle = title;
-    if (titleOverride?.trim()) session.titleSource = "llm";
-    session.lastSummaryHash = hash;
-  }
-
-  async syncLabels(session: SessionMirrorState, snapshot: TranscriptSnapshot, closed: boolean): Promise<void> {
-    if (!session.issueNumber) return;
-    const labels = this.buildLabels(session, snapshot, closed);
-    await this.client.ensureLabels(labels);
-    await this.client.syncManagedLabels(session.issueNumber, labels);
-  }
-
-  async appendComments(issueNumber: number, messages: NormalizedMessage[]): Promise<number> {
-    let count = 0;
-    for (const msg of messages) {
-      try { await this.client.createComment(issueNumber, `role: ${msg.role}\n\n${msg.text.trim()}`); count++; }
-      catch (error) { this.api.logger.warn(`clawmem: conversation comment failed: ${String(error)}`); break; }
-    }
-    return count;
-  }
-
-  async generateFinalArtifacts(
-    session: SessionMirrorState,
-    snapshot: TranscriptSnapshot,
-    schema?: MemorySchema,
-  ): Promise<{ summary: string; title?: string; candidates: MemoryCandidate[] }> {
-    if (snapshot.messages.length === 0) throw new Error("no conversation messages to finalize");
-    const subagent = this.api.runtime.subagent;
-    const sessionKey = subKey(session, "finalize");
-    const message = buildFinalizeArtifactsPrompt(snapshot, schema);
-    try {
-      const run = await subagent.run({
-        sessionKey,
-        message,
-        deliver: false,
-        lane: "clawmem-finalize",
-        idempotencyKey: sha256(`${session.sessionId}:${snapshot.messages.length}:finalize-v2`),
-        extraSystemPrompt: "You finalize ClawMem conversations. Output JSON only with summary, title, and durable memory candidates. Reuse existing schema when it fits and keep human-readable memory text in the conversation language.",
-      });
-      const wait = await subagent.waitForRun({
-        runId: run.runId,
-        timeoutMs: Math.max(this.config.summaryWaitTimeoutMs, this.config.memoryExtractWaitTimeoutMs),
-      });
-      if (wait.status === "timeout") throw new Error("finalize subagent timed out");
-      if (wait.status === "error") throw new Error(wait.error || "finalize subagent failed");
-      const msgs = normalizeMessages((await subagent.getSessionMessages({ sessionKey, limit: 50 })).messages);
-      const text = [...msgs].reverse().find((entry) => entry.role === "assistant" && entry.text.trim())?.text;
-      if (!text) throw new Error("finalize subagent returned no assistant text");
-      return parseFinalArtifacts(text);
-    } finally {
-      subagent.deleteSession({ sessionKey, deleteTranscript: true }).catch(() => {});
-    }
-  }
-
-  private buildLabels(session: SessionMirrorState, _snapshot: TranscriptSnapshot, _closed: boolean): string[] {
-    const labels = new Set([...DEFAULT_LABELS, "type:conversation", `session:${session.sessionId}`]);
-    if (session.agentId) labels.add(`${AGENT_LABEL_PREFIX}${session.agentId}`);
-    return [...labels].filter((l) => l.trim().length > 0);
-  }
-
-  private renderBody(session: SessionMirrorState, snapshot: TranscriptSnapshot, summary: string, _closed: boolean): string {
-    const dates = this.resolveDates(session, snapshot.messages);
-    return stringifyFlatYaml([
-      ["type", "conversation"], ["session_id", session.sessionId], ["date", dates.date],
-      ["start_at", dates.startAt], ["end_at", dates.endAt],
-      ["summary", summary],
-    ]);
-  }
-
-  private resolveDates(session: SessionMirrorState, messages: NormalizedMessage[]): { date: string; startAt: string; endAt: string } {
-    const ts = messages.map((m) => m.timestamp).filter((v): v is string => Boolean(v?.trim()))
-      .map((v) => new Date(v)).filter((d) => Number.isFinite(d.getTime()));
-    const fallbackStart = session.createdAt ? new Date(session.createdAt) : new Date();
-    const fallbackEnd = session.updatedAt ? new Date(session.updatedAt) : fallbackStart;
-    const start = ts[0] ?? fallbackStart, end = ts.at(-1) ?? fallbackEnd;
-    return { date: localDate(start), startAt: localDateTime(start), endAt: localDateTime(end) };
-  }
-
-  private async resolveTranscriptPath(filePath: string | undefined): Promise<string | null> {
-    if (!filePath) return null;
-    if (await fexists(filePath)) return filePath;
-    try {
-      const dir = path.dirname(filePath), prefix = `${path.basename(filePath)}.reset.`;
-      const latest = (await fs.promises.readdir(dir, { withFileTypes: true }))
-        .filter((e) => e.isFile() && e.name.startsWith(prefix)).map((e) => e.name).sort().at(-1);
-      if (latest) {
-        this.api.logger.info?.(`clawmem: using reset transcript ${path.join(dir, latest)} because ${filePath} is missing`);
-        return path.join(dir, latest);
-      }
-    } catch { /* directory unreadable */ }
-    return null;
-  }
-
-  private async lookupBoundIssue(session: SessionMirrorState): Promise<{ number: number; title?: string; labels?: Array<{ name?: string } | string> } | null> {
-    if (!session.issueNumber) return null;
-    try {
-      return await this.client.getIssue(session.issueNumber);
-    } catch (error) {
-      if (isNotFoundError(error)) return null;
-      throw error;
-    }
-  }
-
-  private isBoundIssue(session: SessionMirrorState, issue: { title?: string; labels?: Array<{ name?: string } | string> }): boolean {
-    const labels = extractLabelNames(issue.labels);
-    return labels.includes("type:conversation") && labels.includes(`session:${session.sessionId}`);
-  }
-
-  private resetIssueBinding(session: SessionMirrorState): void {
-    session.issueNumber = undefined;
-    session.issueTitle = undefined;
-    session.titleSource = undefined;
-    session.lastSummaryHash = undefined;
-    session.lastMirroredCount = 0;
-    session.turnCount = 0;
-    session.finalizedAt = undefined;
-  }
-}
-
-export function buildFinalizeArtifactsPrompt(snapshot: TranscriptSnapshot, schema?: MemorySchema): string {
-  return [
-    "Write the final issue summary and extract durable memory candidates from the conversation below.",
-    'Return valid JSON only in the form {"summary":"...","title":"...","candidates":[{"title":"...","detail":"...","kind":"...","topics":["..."],"evidence":"..."}]}.',
-    "The summary should be concise, factual, and written in 2-4 sentences.",
-    "Do not include markdown, bullet points, or analysis.",
-    "",
-    "Title rules:",
-    "- Under 50 characters, accurately describe the main topic or task.",
-    "- Should let someone immediately know what the conversation is about.",
-    "- Must be in the same language as the majority of the conversation content.",
-    "- Good: precise, descriptive, specific. Bad: vague, overly creative, generic.",
-    "",
-    "Candidate rules:",
-    "- Extract only durable facts, preferences, decisions, constraints, workflows, and ongoing context worth remembering later.",
-    "- Each candidate must represent one durable fact. Split independent facts into separate candidates.",
-    "- Prefer a concise explicit title for each candidate whenever the fact can be named clearly.",
-    "- Candidate titles and details must be in the same language as the majority of the conversation content.",
-    "- Do not extract temporary requests, tool chatter, startup boilerplate, or summaries about internal helper sessions.",
-    "- Reuse existing schema labels when one already fits.",
-    "- If no existing kind or topic fits, create one short stable machine-readable label instead of a translated or near-duplicate variant.",
-    "- Keep kind and topic labels short, reusable, low-cardinality, and machine-readable.",
-    "- Evidence is optional. If present, keep it short and quote-free.",
-    "- Prefer an empty candidates array when nothing durable was learned.",
-    "",
-    ...buildFinalizeSchemaSection(schema),
-    "<conversation>",
-    fmtTranscript(snapshot.messages),
-    "</conversation>",
-  ].join("\n");
-}
-
-function buildFinalizeSchemaSection(schema?: MemorySchema): string[] {
-  if (!schema) return [];
-
-  const kinds = schema.kinds.map((kind) => kind.trim()).filter(Boolean);
-  const topics = schema.topics.map((topic) => topic.trim()).filter(Boolean);
-  if (kinds.length === 0 && topics.length === 0) return [];
-
-  const kindLines = kinds.slice(0, FINALIZE_SCHEMA_KIND_LIMIT).map((kind) => `- kind:${kind}`);
-  const topicLines = topics.slice(0, FINALIZE_SCHEMA_TOPIC_LIMIT).map((topic) => `- topic:${topic}`);
-  const kindOverflow = kinds.length > kindLines.length ? [`- ...and ${kinds.length - kindLines.length} more kinds`] : [];
-  const topicOverflow = topics.length > topicLines.length ? [`- ...and ${topics.length - topicLines.length} more topics`] : [];
-
-  return [
-    "Current schema to reuse first:",
-    "<current-schema>",
-    "Kinds:",
-    ...(kindLines.length > 0 ? kindLines : ["- None"]),
-    ...kindOverflow,
-    "Topics:",
-    ...(topicLines.length > 0 ? topicLines : ["- None"]),
-    ...topicOverflow,
-    "</current-schema>",
-    "Prefer these existing labels whenever they fit. Only create a new label when none of the current labels matches the fact you are storing.",
-    "",
-  ];
-}
-
-async function fexists(p: string): Promise<boolean> { try { return (await fs.promises.stat(p)).isFile(); } catch { return false; } }
-function isNotFoundError(error: unknown): boolean {
-  const text = String(error);
-  return text.includes("HTTP 404");
-}
-/** Derive an initial placeholder title for a new conversation. The real title is generated by LLM once enough messages are available. */
-export function deriveInitialTitle(_messages: NormalizedMessage[], sessionId: string): string {
-  return `${SESSION_TITLE_PREFIX}${sessionId}`;
-}
-
-function parseSummaryAndTitle(raw: string): { summary: string; title?: string } {
-  const tryParse = (s: string): { summary: string; title?: string } | null => {
-    try {
-      const p = JSON.parse(s) as { summary?: unknown; title?: unknown };
-      const summary = typeof p?.summary === "string" && p.summary.trim() ? p.summary.trim() : null;
-      if (!summary) return null;
-      const title = typeof p?.title === "string" && p.title.trim() ? p.title.trim() : undefined;
-      return { summary, title };
-    } catch {
-      const i = s.indexOf("{"), j = s.lastIndexOf("}");
-      if (i >= 0 && j > i) {
-        try {
-          const p = JSON.parse(s.slice(i, j + 1)) as { summary?: unknown; title?: unknown };
-          const summary = typeof p?.summary === "string" && p.summary.trim() ? p.summary.trim() : null;
-          if (!summary) return null;
-          const title = typeof p?.title === "string" && p.title.trim() ? p.title.trim() : undefined;
-          return { summary, title };
-        } catch { return null; }
-      }
-      return null;
-    }
-  };
-  const t = raw.trim();
-  const direct = tryParse(t); if (direct) return direct;
-  const f = /^```(?:json)?\s*([\s\S]*?)```$/i.exec(t);
-  if (f?.[1]) { const nested = tryParse(f[1].trim()); if (nested) return nested; }
-  return { summary: t };
-}
-
-function parseFinalArtifacts(raw: string): { summary: string; title?: string; candidates: MemoryCandidate[] } {
-  const parsedSummary = parseSummaryAndTitle(raw);
-  const candidates = parseCandidates(raw);
-  return {
-    summary: parsedSummary.summary,
-    ...(parsedSummary.title ? { title: parsedSummary.title } : {}),
-    candidates,
-  };
-}

package/src/github-client.test.ts

@@ -1,101 +0,0 @@
-import { GitHubIssueClient } from "./github-client.js";
-import type { ClawMemResolvedRoute } from "./types.js";
-
-function assert(condition: unknown, message: string): void {
-  if (!condition) throw new Error(message);
-}
-
-type FetchCall = { url: string; init: RequestInit };
-
-function createClientRecorder(): {
-  client: GitHubIssueClient;
-  calls: FetchCall[];
-  restore(): void;
-} {
-  const calls: FetchCall[] = [];
-  const originalFetch = globalThis.fetch;
-  globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
-    calls.push({ url: String(input), init: init ?? {} });
-    const method = init?.method ?? "GET";
-    if (method === "DELETE" || method === "PATCH") return new Response(null, { status: 204 });
-    return new Response(JSON.stringify({ ok: true }), { status: 200, headers: { "Content-Type": "application/json" } });
-  }) as typeof fetch;
-
-  const route: ClawMemResolvedRoute = {
-    agentId: "main",
-    baseUrl: "https://git.clawmem.ai/api/v3",
-    defaultRepo: "alice/memory",
-    repo: "alice/memory",
-    token: "token-123",
-    authScheme: "token",
-  };
-
-  return {
-    client: new GitHubIssueClient(route, {}),
-    calls,
-    restore() {
-      globalThis.fetch = originalFetch;
-    },
-  };
-}
-
-async function testOrgGovernanceRoutes(): Promise<void> {
-  const { client, calls, restore } = createClientRecorder();
-  try {
-    await client.listOrgMembers("acme", "admin");
-    await client.getOrgMembership("acme", "alice");
-    await client.removeOrgMember("acme", "alice");
-    await client.removeOrgMembership("acme", "alice");
-    await client.revokeOrgInvitation("acme", 12);
-
-    assert(calls[0]?.url === "https://git.clawmem.ai/api/v3/orgs/acme/members?role=admin", "expected org member list route");
-    assert(calls[1]?.url === "https://git.clawmem.ai/api/v3/orgs/acme/memberships/alice", "expected org membership route");
-    assert(calls[2]?.url === "https://git.clawmem.ai/api/v3/orgs/acme/members/alice", "expected org member delete route");
-    assert(calls[2]?.init.method === "DELETE", "expected DELETE for org member removal");
-    assert(calls[3]?.url === "https://git.clawmem.ai/api/v3/orgs/acme/memberships/alice", "expected org membership delete route");
-    assert(calls[3]?.init.method === "DELETE", "expected DELETE for org membership removal");
-    assert(calls[4]?.url === "https://git.clawmem.ai/api/v3/orgs/acme/invitations/12", "expected org invitation revoke route");
-    assert(calls[4]?.init.method === "DELETE", "expected DELETE for org invitation revoke");
-  } finally {
-    restore();
-  }
-}
-
-async function testTeamGovernanceRoutes(): Promise<void> {
-  const { client, calls, restore } = createClientRecorder();
-  try {
-    await client.getTeam("acme", "platform");
-    await client.updateTeam("acme", "platform", { name: "Platform Eng", description: "Core platform", privacy: "closed" });
-    await client.deleteTeam("acme", "platform");
-    await client.listTeamMembers("acme", "platform");
-
-    assert(calls[0]?.url === "https://git.clawmem.ai/api/v3/orgs/acme/teams/platform", "expected team get route");
-    assert(calls[1]?.url === "https://git.clawmem.ai/api/v3/orgs/acme/teams/platform", "expected team update route");
-    assert(calls[1]?.init.method === "PATCH", "expected PATCH for team update");
-    assert(String(calls[1]?.init.body).includes("\"name\":\"Platform Eng\""), "expected team update payload to include name");
-    assert(calls[2]?.url === "https://git.clawmem.ai/api/v3/orgs/acme/teams/platform", "expected team delete route");
-    assert(calls[2]?.init.method === "DELETE", "expected DELETE for team delete");
-    assert(calls[3]?.url === "https://git.clawmem.ai/api/v3/orgs/acme/teams/platform/members", "expected team members route");
-  } finally {
-    restore();
-  }
-}
-
-async function testRepoTransferRoute(): Promise<void> {
-  const { client, calls, restore } = createClientRecorder();
-  try {
-    await client.transferRepo("alice", "memory", "acme");
-    assert(calls.length === 1, "expected one repo transfer request");
-    assert(calls[0]?.url === "https://git.clawmem.ai/api/v3/repos/alice/memory/transfer", "expected repo transfer route");
-    assert(calls[0]?.init.method === "POST", "expected POST for repo transfer");
-    assert(String(calls[0]?.init.body) === "{\"new_owner\":\"acme\"}", "expected repo transfer payload");
-  } finally {
-    restore();
-  }
-}
-
-await testOrgGovernanceRoutes();
-await testTeamGovernanceRoutes();
-await testRepoTransferRoute();
-
-console.log("github client tests passed");