@rol1n/memory-log 0.0.0-stage → 0.1.1

package/memory/index-render.ts

@@ -0,0 +1,45 @@
+import type { Topic } from "./paths.ts";
+
+function summaryOf(topic: Topic): string {
+  const s = (topic.summary ?? "").trim();
+  return s.length > 0 ? s : "(no summary)";
+}
+
+function titleOf(topic: Topic): string {
+  const t = (topic.title ?? "").trim();
+  return t.length > 0 ? t : topic.filename;
+}
+
+/** The on-disk INDEX.md content. Orchestrator-owned; the consolidator never writes it. */
+export function renderIndexFile(topics: Topic[]): string {
+  const parts: string[] = ["# Memory index", ""];
+  if (topics.length === 0) {
+    parts.push("_No topics yet._");
+    return `${parts.join("\n")}\n`;
+  }
+  parts.push("Durable memory topics for this project. Read a file for its full current state.", "");
+  for (const topic of topics) {
+    const updated = topic.updated ? ` · updated ${topic.updated}` : "";
+    parts.push(`## ${titleOf(topic)}`);
+    parts.push(`- \`${topic.path}\`${updated}`);
+    parts.push(`- ${summaryOf(topic)}`);
+    parts.push("");
+  }
+  return `${parts.join("\n").trimEnd()}\n`;
+}
+
+/**
+ * The compaction injection block's memory-map section. Returns undefined when there are no topics.
+ */
+export function renderMemoryMap(topics: Topic[]): string | undefined {
+  if (topics.length === 0) return undefined;
+  const lines: string[] = [
+    "## Memory map",
+    "Durable long-term notes live in `.memory/`. Read a file when a topic below looks relevant; these summaries are intentionally terse.",
+  ];
+  for (const topic of topics) {
+    const updated = topic.updated ? ` (updated ${topic.updated})` : "";
+    lines.push(`- \`${topic.path}\` — ${summaryOf(topic)}${updated}`);
+  }
+  return lines.join("\n");
+}

package/memory/paths.ts

@@ -0,0 +1,120 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+
+export const INDEX_FILENAME = "INDEX.md";
+export const JOURNEY_FILENAME = "JOURNEY.md";
+
+/** The project-level `.memory/` base. Per-session roots live one level below it. */
+export function memoryBaseDir(cwd: string): string {
+  return join(cwd, ".memory");
+}
+
+/**
+ * The per-session memory root: `.memory/<sessionId>/`.
+ */
+export function sessionMemoryRoot(cwd: string, sessionId: string): string {
+  return join(memoryBaseDir(cwd), sessionId);
+}
+
+export function indexPath(root: string): string {
+  return join(root, INDEX_FILENAME);
+}
+
+export function journeyPath(root: string): string {
+  return join(root, JOURNEY_FILENAME);
+}
+
+/** Read `.memory/JOURNEY.md` body, trimmed. Returns undefined when missing or effectively empty. */
+export function readJourney(root: string): string | undefined {
+  const path = journeyPath(root);
+  if (!existsSync(path)) return undefined;
+  try {
+    const body = readFileSync(path, "utf-8").trim();
+    return body.length > 0 ? body : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Atomic write (temp + rename). Creates parent dirs as needed. */
+export function atomicWrite(path: string, content: string): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  writeFileSync(tmp, content, "utf-8");
+  renameSync(tmp, path);
+}
+
+/**
+ * Resolve a (possibly relative) path and confirm it stays inside `.memory/`.
+ */
+export function resolveWithinMemory(root: string, requestedPath: string): string | undefined {
+  const base = resolve(root);
+  const abs = resolve(base, requestedPath);
+  const rel = relative(base, abs);
+  if (rel === "" || rel === ".") return abs;
+  if (rel.startsWith("..") || resolve(base, rel) !== abs) return undefined;
+  return abs;
+}
+
+export type TopicFrontMatter = {
+  id?: string;
+  title?: string;
+  summary?: string;
+  updated?: string;
+};
+
+export type Topic = TopicFrontMatter & {
+  /** Path relative to the project root, e.g. ".memory/<sessionId>/auth.md". */
+  path: string;
+  /** Bare filename, e.g. "auth.md". */
+  filename: string;
+};
+
+const FRONT_MATTER_RE = /^---\n([\s\S]*?)\n---\n?/;
+
+/**
+ * Parse leading YAML-ish front-matter.
+ */
+export function parseFrontMatter(content: string): { front: TopicFrontMatter; body: string } {
+  const match = FRONT_MATTER_RE.exec(content);
+  if (!match) return { front: {}, body: content };
+  const front: TopicFrontMatter = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx < 0) continue;
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    if (key === "id" || key === "title" || key === "summary" || key === "updated") {
+      front[key] = value;
+    }
+  }
+  return { front, body: content.slice(match[0].length) };
+}
+
+/**
+ * List parsed topic files under a session memory root, sorted by filename.
+ */
+export function listTopics(root: string): Topic[] {
+  if (!existsSync(root)) return [];
+  const cwd = resolve(root, "..", "..");
+  const topics: Topic[] = [];
+  for (const filename of readdirSync(root)) {
+    if (!filename.endsWith(".md") || filename === INDEX_FILENAME || filename === JOURNEY_FILENAME) continue;
+    let content: string;
+    try {
+      content = readFileSync(join(root, filename), "utf-8");
+    } catch {
+      continue;
+    }
+    const { front } = parseFrontMatter(content);
+    topics.push({ ...front, path: relative(cwd, join(root, filename)), filename });
+  }
+  topics.sort((a, b) => (a.filename < b.filename ? -1 : a.filename > b.filename ? 1 : 0));
+  return topics;
+}

package/memory/session.ts

@@ -0,0 +1,64 @@
+import { cpSync, existsSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { basename, sep } from "node:path";
+import { sessionMemoryRoot } from "./paths.ts";
+
+type SessionCtx = {
+  cwd: string;
+  sessionManager: {
+    getSessionId: () => string;
+    getHeader?: () => { id?: string; cwd?: string; parentSession?: string } | null | undefined;
+  };
+};
+
+/** Read a session file's header id (first JSONL line). Undefined on any parse/IO failure. */
+function readSessionHeaderId(file: string): string | undefined {
+  try {
+    const firstLine = readFileSync(file, "utf-8").split("\n", 1)[0] ?? "";
+    const header = JSON.parse(firstLine) as { type?: string; id?: string } | undefined;
+    return typeof header?.id === "string" ? header.id : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Resolve the parent session's memory root for fork/clone seeding.
+ */
+function parentMemoryRoot(ctx: SessionCtx): string | undefined {
+  const parentFile = ctx.sessionManager.getHeader?.()?.parentSession;
+  if (!parentFile) return undefined;
+  const parentId = readSessionHeaderId(parentFile);
+  if (!parentId) return undefined;
+  const root = sessionMemoryRoot(ctx.cwd, parentId);
+  return existsSync(root) ? root : undefined;
+}
+
+/** True for any path inside a `.runs` directory (transient IPC; never seeded). */
+function isRunsPath(p: string): boolean {
+  return basename(p) === ".runs" || p.includes(`${sep}.runs${sep}`);
+}
+
+/**
+ * Resolve this session's `.memory/<sessionId>/` root, seeding it from the parent session on first touch.
+ */
+export function ensureSessionMemory(ctx: SessionCtx): string {
+  const sessionId = ctx.sessionManager.getSessionId();
+  const root = sessionMemoryRoot(ctx.cwd, sessionId);
+  if (existsSync(root)) return root;
+
+  const parent = parentMemoryRoot(ctx);
+  if (parent) {
+    const tmp = `${root}.seed-tmp-${process.pid}-${Date.now()}`;
+    try {
+      cpSync(parent, tmp, { recursive: true, filter: (src: string) => !isRunsPath(src) });
+      renameSync(tmp, root);
+    } catch {
+      try {
+        rmSync(tmp, { recursive: true, force: true });
+      } catch {
+        // best-effort cleanup
+      }
+    }
+  }
+  return root;
+}

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@rol1n/memory-log",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "type": "module",
+  "description": "memory-log extension from pi-kit",
+  "keywords": [
+    "pi-package"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RolinShmily/pi-kit.git",
+    "directory": "memory-log"
+  },
+  "homepage": "https://github.com/RolinShmily/pi-kit#readme",
+  "bugs": {
+    "url": "https://github.com/RolinShmily/pi-kit/issues"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "skills": [],
+    "prompts": [],
+    "themes": []
+  }
+}

package/runtime.ts

@@ -0,0 +1,127 @@
+import { type Config, DEFAULTS, loadConfig } from "./config.ts";
+import { foldLedger, poolTokens, rawTokensSinceObservationCoverage, sumSessionCost, type Entry } from "./ledger/index.ts";
+import { StatusController } from "./ui/status-controller.ts";
+
+/**
+ * In-process orchestrator state.
+ */
+export class Runtime {
+  config: Config = { ...DEFAULTS };
+  configLoaded = false;
+
+  /** The per-session on/off gate (uses config.defaultEnabled when no ledger entry exists). */
+  enabled = false;
+
+  /**
+   * Absolute `.memory/<sessionId>/` root for this session.
+   */
+  memoryRoot = "";
+
+  /**
+   * In-flight observer subprocesses, keyed by runId.
+   */
+  readonly observersInFlight = new Map<string, { controller: AbortController; coversUpToId: string }>();
+
+  /** In-flight observer async tasks. */
+  readonly observerTasks = new Set<Promise<void>>();
+
+  consolidatorInFlight = false;
+  consolidatorController: AbortController | undefined;
+
+  dispatchedCoversUpToId: string | undefined;
+
+  compactInFlight = false;
+  compactHookInFlight = false;
+  autoCompactionController: AbortController | undefined;
+
+  lastWorkerError: string | undefined;
+
+  lastCompactionObserverWait: "skipped" | "waited" | undefined;
+
+  readonly status = new StatusController();
+
+  private pendingInfoToastLines: string[] = [];
+  private infoToastFlushTimer: ReturnType<typeof setTimeout> | undefined;
+
+  queueToast(
+    line: string,
+    level: "info" | "warning" | "error",
+    notify: (message: string, level: "info" | "warning" | "error") => void,
+  ): void {
+    if (level !== "info") {
+      notify(line, level);
+      return;
+    }
+    this.pendingInfoToastLines.push(line);
+    if (this.infoToastFlushTimer !== undefined) return;
+    this.infoToastFlushTimer = setTimeout(() => {
+      this.infoToastFlushTimer = undefined;
+      const lines = this.pendingInfoToastLines.splice(0);
+      if (lines.length > 0) notify(lines.join("\n"), "info");
+    }, 0);
+    (this.infoToastFlushTimer as any)?.unref?.();
+  }
+
+  cancelPendingToasts(): void {
+    if (this.infoToastFlushTimer !== undefined) {
+      clearTimeout(this.infoToastFlushTimer);
+      this.infoToastFlushTimer = undefined;
+    }
+    this.pendingInfoToastLines = [];
+  }
+
+  ensureConfig(cwd: string): void {
+    if (this.configLoaded) return;
+    this.config = loadConfig(cwd);
+    this.configLoaded = true;
+  }
+
+  refreshFooterGauges(branch: Entry[], contextTokens?: number | null): void {
+    if (!this.enabled) return;
+    const folded = foldLedger(branch);
+    this.status.setGauges({
+      nextValue: rawTokensSinceObservationCoverage(branch),
+      nextMax: this.config.chunkTokens,
+      poolValue: poolTokens(folded.activeObservations),
+      poolMax: this.config.consolidateAtPoolTokens,
+      ctxValue: contextTokens ?? 0,
+      ctxMax: this.config.compactAtContextTokens,
+    });
+  }
+
+  refreshCost(allEntries: Entry[]): void {
+    if (!this.enabled) return;
+    const { costUsd, runs } = sumSessionCost(allEntries);
+    this.status.setCost(costUsd, runs);
+  }
+
+  abortAllWorkers(): void {
+    this.cancelPendingToasts();
+    for (const { controller } of this.observersInFlight.values()) {
+      controller.abort();
+    }
+    this.observersInFlight.clear();
+    this.consolidatorController?.abort();
+    this.consolidatorController = undefined;
+    this.consolidatorInFlight = false;
+    if (this.autoCompactionController) {
+      this.autoCompactionController.abort();
+      this.autoCompactionController = undefined;
+    }
+  }
+
+  trackObserverTask(task: Promise<void>): void {
+    this.observerTasks.add(task);
+    void task.finally(() => this.observerTasks.delete(task));
+  }
+
+  async whenObserversIdle(): Promise<void> {
+    while (this.observerTasks.size > 0) {
+      await Promise.allSettled([...this.observerTasks]);
+    }
+  }
+
+  get observerSlotsAvailable(): number {
+    return Math.max(0, this.config.observerConcurrency - this.observersInFlight.size);
+  }
+}

package/spawn/launch.ts

@@ -0,0 +1,133 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
+import type { ConfiguredModel } from "../config.ts";
+import { runCostPath, runResultPath } from "./runs.ts";
+
+/** Path to agent/index.ts relative to spawn directory */
+export const AGENT_EXTENSION_PATH = resolve(dirname(fileURLToPath(import.meta.url)), "..", "agent", "index.ts");
+
+export function modelArg(model: ConfiguredModel): string {
+  return model.provider && model.id ? `${model.provider}/${model.id}` : (model.id || "");
+}
+
+/** Resolve the `pi` entry point, falling back to `pi` on PATH. */
+export function resolvePiBinary(): { command: string; baseArgs: string[] } {
+  const entry = process.argv[1];
+  if (entry) {
+    try {
+      const realEntry = realpathSync(entry);
+      if (/\.(?:mjs|cjs|js|ts)$/i.test(realEntry)) {
+        return { command: process.execPath, baseArgs: [realEntry] };
+      }
+    } catch {
+      // fall through
+    }
+  }
+  const fallbackCmd = process.platform === "win32" ? "pi.cmd" : "pi";
+  return { command: fallbackCmd, baseArgs: [] };
+}
+
+export function buildWorkerArgv(opts: {
+  model: ConfiguredModel;
+  sessionName: string;
+  kickoffPrompt: string;
+  promptPath?: string;
+  agentExtensionPath?: string;
+}): string[] {
+  const pi = resolvePiBinary();
+  const args = [
+    ...pi.baseArgs,
+    "--no-skills",
+    "--no-prompt-templates",
+    "--no-context-files",
+    "--no-builtin-tools",
+  ];
+  if (opts.model.provider) {
+    args.push("--provider", opts.model.provider);
+  }
+  if (opts.model.id) {
+    args.push("--model", opts.model.id);
+  }
+  if (opts.model.thinking) {
+    args.push("--thinking", opts.model.thinking);
+  }
+  args.push("-e", opts.agentExtensionPath ?? AGENT_EXTENSION_PATH);
+  args.push("-n", opts.sessionName);
+  if (opts.promptPath) {
+    args.push("-p", `@${resolve(opts.promptPath)}`);
+  } else {
+    args.push("-p", opts.kickoffPrompt);
+  }
+  return [pi.command, ...args];
+}
+
+export type WorkerExit = { code: number | null; signal: NodeJS.Signals | null; stderr: string };
+
+/**
+ * Spawn a headless worker; resolve when it exits.
+ */
+export function spawnWorker(opts: {
+  argv: string[];
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  signal?: AbortSignal;
+}): Promise<WorkerExit> {
+  const [command, ...rest] = opts.argv;
+  mkdirSync(opts.cwd, { recursive: true });
+  return new Promise<WorkerExit>((resolvePromise) => {
+    const isWindowsCmd = process.platform === "win32" && (command.endsWith(".cmd") || command.endsWith(".bat"));
+    let proc;
+    try {
+      proc = spawn(command, rest, {
+        cwd: opts.cwd,
+        env: opts.env,
+        stdio: ["ignore", "ignore", "pipe"],
+        shell: isWindowsCmd,
+      });
+    } catch (err: any) {
+      resolvePromise({ code: 1, signal: null, stderr: `spawn error: ${err?.message || String(err)}` });
+      return;
+    }
+
+    let stderr = "";
+    proc.stderr?.on("data", (d: Buffer | string) => {
+      stderr += d.toString();
+    });
+    proc.on("error", (err: any) => resolvePromise({ code: 1, signal: null, stderr: stderr || `spawn error: ${err?.message || String(err)}` }));
+    proc.on("close", (code: number | null, signal: NodeJS.Signals | null) => resolvePromise({ code, signal, stderr }));
+
+    if (opts.signal) {
+      const kill = () => {
+        proc.kill("SIGTERM");
+        const timer = setTimeout(() => {
+          if (!proc.killed) proc.kill("SIGKILL");
+        }, 3000);
+        (timer as any).unref?.();
+      };
+      if (opts.signal.aborted) kill();
+      else opts.signal.addEventListener("abort", kill, { once: true });
+    }
+  });
+}
+
+export type ObserverLaunchEnv = {
+  /** Absolute `.memory/<sessionId>/` root. */
+  memoryRoot: string;
+  runId: string;
+};
+
+/**
+ * Build the env a worker subprocess needs to write its result file.
+ */
+export function buildWorkerEnv(role: "observer" | "consolidator", opts: ObserverLaunchEnv): NodeJS.ProcessEnv {
+  return {
+    ...process.env,
+    OM_WORKER: role,
+    OM_RUN_ID: opts.runId,
+    OM_RESULT_PATH: runResultPath(opts.memoryRoot, opts.runId),
+    OM_COST_PATH: runCostPath(opts.memoryRoot, opts.runId),
+    OM_MEMORY_DIR: opts.memoryRoot,
+  };
+}

package/spawn/runs.ts

@@ -0,0 +1,83 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+/** What the observer model emits, before the orchestrator re-derives precise timestamp-ids. */
+export type RawObservation = {
+  timestamp: string; // "YYYY-MM-DD HH:MM"
+  content: string;
+};
+
+export type ObserverRunResult = {
+  observations: RawObservation[];
+};
+
+export function runsDir(root: string): string {
+  return resolve(root, ".runs");
+}
+
+export function runResultPath(root: string, runId: string): string {
+  return resolve(runsDir(root), `${runId}.result.json`);
+}
+
+/**
+ * Per-run cost handoff file. Written by the worker EXTENSION from pi's built-in usage.cost.total.
+ */
+export function runCostPath(root: string, runId: string): string {
+  return resolve(runsDir(root), `${runId}.cost.json`);
+}
+
+/**
+ * Per-run prompt file for workers to avoid command line length limits (spawn ENAMETOOLONG on Windows).
+ */
+export function runPromptPath(root: string, runId: string): string {
+  return resolve(runsDir(root), `${runId}.prompt.txt`);
+}
+
+export type WorkerCostResult = {
+  costUsd: number;
+};
+
+export function writeWorkerCost(path: string, cost: WorkerCostResult): void {
+  atomicWrite(path, JSON.stringify(cost));
+}
+
+/** Best-effort read of a worker cost file; returns undefined on missing/malformed input. */
+export function readWorkerCost(path: string): WorkerCostResult | undefined {
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf-8")) as unknown;
+    if (!raw || typeof raw !== "object") return undefined;
+    const cost = (raw as { costUsd?: unknown }).costUsd;
+    if (typeof cost !== "number" || !Number.isFinite(cost) || cost < 0) return undefined;
+    return { costUsd: cost };
+  } catch {
+    return undefined;
+  }
+}
+
+/** Atomic write (temp + rename) so a reader never sees a half-written file. */
+export function atomicWrite(path: string, content: string): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  writeFileSync(tmp, content, "utf-8");
+  renameSync(tmp, path);
+}
+
+function isRawObservation(value: unknown): value is RawObservation {
+  if (!value || typeof value !== "object") return false;
+  const v = value as Record<string, unknown>;
+  return typeof v.timestamp === "string" && typeof v.content === "string" && v.content.trim().length > 0;
+}
+
+/** Parse + validate an observer result file. Throws on malformed input. */
+export function readObserverResult(path: string): ObserverRunResult {
+  const raw = JSON.parse(readFileSync(path, "utf-8")) as unknown;
+  if (!raw || typeof raw !== "object" || !Array.isArray((raw as { observations?: unknown }).observations)) {
+    throw new Error("observer result missing observations array");
+  }
+  const observations = (raw as { observations: unknown[] }).observations.filter(isRawObservation);
+  return { observations };
+}
+
+export function writeObserverResult(path: string, result: ObserverRunResult): void {
+  atomicWrite(path, JSON.stringify(result));
+}

package/tokens.ts

@@ -0,0 +1,66 @@
+/** Rough char-based token estimate. Matches OM's heuristic (≈4 chars/token). */
+export function estimateStringTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}
+
+export function estimateMessageTokens(message: unknown): number {
+  if (!message || typeof message !== "object") return 0;
+  const msg = message as { content?: unknown };
+  if (typeof msg.content === "string") {
+    return estimateStringTokens(msg.content);
+  }
+  if (Array.isArray(msg.content)) {
+    let total = 0;
+    for (const part of msg.content) {
+      if (part && typeof part === "object") {
+        if ("text" in part && typeof (part as { text?: unknown }).text === "string") {
+          total += estimateStringTokens((part as { text: string }).text);
+        } else if ("thinking" in part && typeof (part as { thinking?: unknown }).thinking === "string") {
+          total += estimateStringTokens((part as { thinking: string }).thinking);
+        }
+      }
+    }
+    return total;
+  }
+  try {
+    return estimateStringTokens(JSON.stringify(message));
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Estimate the token cost of a single ledger entry. Only "source" entries
+ * (message / custom_message / branch_summary) carry conversational text; every
+ * other entry type (memory ledger records, compaction, etc.) contributes 0 so
+ * the raw-token clocks measure only new conversation.
+ */
+export function estimateEntryTokens(entry: {
+  type: string;
+  message?: unknown;
+  content?: unknown;
+  summary?: unknown;
+}): number {
+  if (entry.type === "message" && entry.message) {
+    return estimateMessageTokens(
+      entry.message as Parameters<typeof estimateMessageTokens>[0],
+    );
+  }
+  if (entry.type === "custom_message" && entry.content) {
+    const content = entry.content;
+    if (typeof content === "string") return estimateStringTokens(content);
+    if (Array.isArray(content)) {
+      let total = 0;
+      for (const block of content) {
+        if (block.type === "text" && block.text) {
+          total += estimateStringTokens(block.text);
+        }
+      }
+      return total;
+    }
+  }
+  if (entry.type === "branch_summary" && typeof entry.summary === "string") {
+    return estimateStringTokens(entry.summary);
+  }
+  return 0;
+}