@contextline/contextline 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,695 +0,0 @@
-#!/usr/bin/env node
-
-// src/mcpServer.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// src/tools/dispatch.ts
-import { z } from "zod";
-
-// src/tools/appendFragment.ts
-import fs5 from "fs/promises";
-
-// src/config.ts
-import fs from "fs";
-import path from "path";
-function getMemoryRoot() {
-  if (process.env.CONTEXTLINE_ROOT) return path.resolve(process.env.CONTEXTLINE_ROOT);
-  return path.join(process.cwd(), ".contextline");
-}
-function resolveRoot(folder) {
-  if (folder) return path.resolve(folder);
-  return getMemoryRoot();
-}
-
-// src/paths.ts
-import path2 from "path";
-
-// src/core/errors.ts
-var ContextLineError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ContextLineError";
-  }
-};
-var PathSafetyError = class extends ContextLineError {
-  constructor(message) {
-    super(message);
-    this.name = "PathSafetyError";
-  }
-};
-
-// src/paths.ts
-var L1_FILE = "L1_Quick.md";
-var L2_DIR = "L2_Deep";
-var L3_DIR = "L3_Details";
-function assertSafeRelative(input) {
-  if (!input || input.trim() !== input) {
-    throw new PathSafetyError("Path input must be non-empty and contain no leading/trailing whitespace.");
-  }
-  if (path2.isAbsolute(input)) {
-    throw new PathSafetyError("Absolute paths are not allowed in tool inputs.");
-  }
-  const parts = input.split(/[\\/]+/);
-  if (parts.includes("..") || parts.includes("")) {
-    throw new PathSafetyError("Path traversal and empty path segments are not allowed.");
-  }
-}
-function assertSafeRelativeFile(input) {
-  assertSafeRelative(input);
-  if (!input.endsWith(".md")) {
-    throw new PathSafetyError("Memory file paths must end with .md.");
-  }
-}
-function safeJoin(root, ...segments) {
-  for (const segment of segments) {
-    assertSafeRelative(segment);
-  }
-  const resolvedRoot = path2.resolve(root);
-  const target = path2.resolve(resolvedRoot, ...segments);
-  const rel = path2.relative(resolvedRoot, target);
-  if (rel.startsWith("..") || path2.isAbsolute(rel)) {
-    throw new PathSafetyError("Resolved path escapes ContextLine root.");
-  }
-  return target;
-}
-function deepPath(root, file) {
-  assertSafeRelativeFile(file);
-  if (file.includes("/") || file.includes("\\")) {
-    throw new PathSafetyError("L2 deep memory files must be flat filenames inside L2_Deep for V1.");
-  }
-  return safeJoin(root, L2_DIR, file);
-}
-function detailPath(root, file) {
-  assertSafeRelativeFile(file);
-  return safeJoin(root, L3_DIR, file);
-}
-function l1Path(root) {
-  return safeJoin(root, L1_FILE);
-}
-
-// src/core/atomicWrite.ts
-import fs2 from "fs/promises";
-import path3 from "path";
-async function atomicWriteFile(filePath, content) {
-  await fs2.mkdir(path3.dirname(filePath), { recursive: true });
-  const tmp = path3.join(path3.dirname(filePath), `.${path3.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
-  const handle = await fs2.open(tmp, "w");
-  try {
-    await handle.writeFile(content, "utf8");
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-  await fs2.rename(tmp, filePath);
-}
-
-// src/core/markdown.ts
-function ensureTrailingNewline(content) {
-  return content.endsWith("\n") ? content : `${content}
-`;
-}
-function upsertLineByPrefix(content, prefix, nextLine) {
-  const lines = ensureTrailingNewline(content).split("\n");
-  const index = lines.findIndex((line) => line.trimStart().startsWith(prefix));
-  if (index >= 0) {
-    lines[index] = nextLine;
-  } else {
-    lines.splice(Math.max(0, lines.length - 1), 0, nextLine);
-  }
-  return ensureTrailingNewline(lines.join("\n").replace(/\n{3,}/g, "\n\n"));
-}
-
-// src/core/details.ts
-import { format, parseISO } from "date-fns";
-function detailFilename(dateInput) {
-  const date = dateInput ? parseISO(dateInput) : /* @__PURE__ */ new Date();
-  if (Number.isNaN(date.getTime())) {
-    throw new Error("Invalid date. Expected YYYY-MM-DD.");
-  }
-  return `L3_${format(date, "yyyy_MM")}.md`;
-}
-function detailHeader(dateInput) {
-  const date = dateInput ? parseISO(dateInput) : /* @__PURE__ */ new Date();
-  if (Number.isNaN(date.getTime())) {
-    throw new Error("Invalid date. Expected YYYY-MM-DD.");
-  }
-  return `# ${format(date, "MMMM yyyy")} Detailed Memory
-
-`;
-}
-function detailLine(text, dateInput) {
-  const date = dateInput ? parseISO(dateInput) : /* @__PURE__ */ new Date();
-  if (Number.isNaN(date.getTime())) {
-    throw new Error("Invalid date. Expected YYYY-MM-DD.");
-  }
-  const clean = text.replace(/\s+/g, " ").trim();
-  if (!clean) {
-    throw new Error("Detail text must be non-empty.");
-  }
-  return `* [${format(date, "yyyy-MM-dd")}]: ${clean}`;
-}
-
-// src/core/lock.ts
-import fs3 from "fs/promises";
-import path4 from "path";
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function withLock(root, fn) {
-  const lockPath = path4.join(root, ".lock");
-  const start = Date.now();
-  let handle;
-  while (!handle) {
-    try {
-      await fs3.mkdir(root, { recursive: true });
-      handle = await fs3.open(lockPath, "wx");
-    } catch (error) {
-      const code = error.code;
-      if (code !== "EEXIST" || Date.now() - start > 5e3) {
-        throw error;
-      }
-      await sleep(50);
-    }
-  }
-  try {
-    return await fn();
-  } finally {
-    await handle.close();
-    await fs3.rm(lockPath, { force: true });
-  }
-}
-
-// src/tools/init.ts
-import fs4 from "fs/promises";
-import path5 from "path";
-
-// src/core/instructions.ts
-var CONTEXTLINE_INSTRUCTIONS_FILE = "contextline_instructions.md";
-var DEFAULT_CONTEXTLINE_INSTRUCTIONS = `# ContextLine Instructions
-
-CONTEXTLINE-INSTRUCTIONS-V1
-This file contains generic operating instructions for ContextLine memory.
-Use the single MCP tool named "contextline" for all ContextLine reads and writes.
-Do not use shell commands to read or write .contextline files.
-Do not mention memory saving unless the user asks.
-
-## Operating Policy
-
-Use the single ContextLine MCP tool "contextline" silently for durable memory. Do not use shell commands to read or write .contextline files. Do not mention memory saving unless asked.
-
-Durable memory means stable facts likely to help future sessions: user/project facts, preferences, goals, constraints, decisions, relationships, recurring patterns, and important events. Do not save filler, acknowledgements, or one-off chatter.
-
-Do not save every message. Periodically batch-save useful durable memory since the last ContextLine save in this session.
-
-Use ContextLine as a human-like cache:
-
-- L1_Quick.md stores compact facts, summaries, and active pointers.
-- L2_Deep/ stores deeper facts per important object, person, event, project, preference area, or decision thread.
-- L3_Details/ stores timestamped specifics, receipts, and supporting history.
-
-For V1, use flat L2 filenames with semantic prefixes instead of folders. Prefer names like person_user.md, project_contextline.md, area_work.md, place_san_jose.md, preference_media.md, preference_language.md, decision_memory_architecture.md, event_launch.md, or org_meta.md.
-
-When saving durable memory, complete the full chain. Do not stop after writing L3_Details:
-
-1. Append one L3_Details receipt when supporting specifics are useful.
-2. Cross-save extracted meaning into every relevant L2_Deep file.
-3. Update L1_Quick only for compact high-level facts or active pointers.
-4. Link every L1 line to relevant L2 files.
-5. Link every L2 line to relevant L3 details when supporting detail exists.
-
-Typical tool sequence:
-
-Call "contextline" once with action "save_memory", including:
-
-- detail.text for the L3_Details receipt
-- deep[] entries for every relevant L2_Deep file, such as person_user.md, area_work.md, place_san_jose.md, or preference_media.md
-- quick[] entries for compact L1_Quick facts linked to L2 files
-
-If you write L3_Details but do not update L2_Deep and L1_Quick, the memory is incomplete. Prefer the bundled "save_memory" action so the full chain is saved together.
-`;
-
-// src/tools/init.ts
-var DEFAULT_L1 = `# ContextLine L1 Index
-
-This is the quick memory cache: compact facts, summaries, and active pointers.
-
-## Quick Facts
-
-`;
-async function initContextLine(root) {
-  const created = [];
-  await fs4.mkdir(root, { recursive: true });
-  for (const dir of [
-    L2_DIR,
-    L3_DIR,
-    "maintenance",
-    "maintenance/proposals"
-  ]) {
-    const target = safeJoin(root, ...dir.split("/"));
-    await fs4.mkdir(target, { recursive: true });
-    created.push(path5.relative(root, target));
-  }
-  const files = [
-    [L1_FILE, DEFAULT_L1],
-    [CONTEXTLINE_INSTRUCTIONS_FILE, DEFAULT_CONTEXTLINE_INSTRUCTIONS],
-    ["config.json", `${JSON.stringify({ version: 1, capture: { promotion: "selective" } }, null, 2)}
-`]
-  ];
-  for (const [file, content] of files) {
-    const target = safeJoin(root, file);
-    try {
-      await fs4.writeFile(target, content, { encoding: "utf8", flag: "wx" });
-      created.push(path5.relative(root, target));
-    } catch (error) {
-      if (error.code !== "EEXIST") {
-        throw error;
-      }
-    }
-  }
-  return { ok: true, root, created };
-}
-
-// src/tools/appendFragment.ts
-async function appendFragment(text, date, rootInput) {
-  const root = resolveRoot(rootInput);
-  await initContextLine(root);
-  return withLock(root, async () => {
-    const detail_file = detailFilename(date);
-    const filePath = detailPath(root, detail_file);
-    let content;
-    try {
-      content = await fs5.readFile(filePath, "utf8");
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-      content = detailHeader(date);
-    }
-    const fragment = detailLine(text, date);
-    await atomicWriteFile(filePath, `${ensureTrailingNewline(content)}${fragment}
-`);
-    return {
-      ok: true,
-      detail_file,
-      fragment,
-      next_required_steps: [
-        "Call contextline with action save_memory to save L3, L2, and L1 together.",
-        "If manually continuing, call contextline action update_deep for every relevant L2_Deep file and action update_index for compact L1_Quick facts."
-      ],
-      display: `ContextLine L3 detail appended
-- Detail file: ${detail_file}`
-    };
-  });
-}
-
-// src/tools/hydrate.ts
-import fs6 from "fs/promises";
-async function hydrate(rootInput) {
-  const root = resolveRoot(rootInput);
-  await initContextLine(root);
-  const l1_path = l1Path(root);
-  const instructions_path = safeJoin(root, CONTEXTLINE_INSTRUCTIONS_FILE);
-  const content = await fs6.readFile(l1_path, "utf8");
-  const instructions = await fs6.readFile(instructions_path, "utf8");
-  return {
-    ok: true,
-    root,
-    l1_path,
-    instructions_path,
-    content,
-    instructions,
-    instruction: "Use this L1 content as quick memory. Follow the included ContextLine instructions for reading and saving memory.",
-    display: `ContextLine hydrated
-- Quick memory: ${l1_path}
-- Instructions: ${instructions_path}`
-  };
-}
-
-// src/tools/inspect.ts
-import fs7 from "fs/promises";
-import path6 from "path";
-async function countFiles(dir) {
-  try {
-    return (await fs7.readdir(dir)).length;
-  } catch {
-    return 0;
-  }
-}
-async function inspect(rootInput) {
-  const root = resolveRoot(rootInput);
-  return {
-    root,
-    l1: path6.join(root, L1_FILE),
-    l2_deep_files: await countFiles(safeJoin(root, L2_DIR)),
-    l3_detail_files: await countFiles(safeJoin(root, L3_DIR))
-  };
-}
-
-// src/tools/proposeCompaction.ts
-import { format as format2 } from "date-fns";
-async function proposeCompaction(fileA, fileB, reason, rootInput) {
-  const root = resolveRoot(rootInput);
-  deepPath(root, fileA);
-  deepPath(root, fileB);
-  return withLock(root, async () => {
-    const stamp = format2(/* @__PURE__ */ new Date(), "yyyyMMdd_HHmmss");
-    const proposal = `proposal_${stamp}_${fileA.replace(/\W+/g, "_")}_${fileB.replace(/\W+/g, "_")}.md`;
-    const proposal_path = safeJoin(root, "maintenance", "proposals", proposal);
-    const content = `# Deep Memory Compaction Proposal
-
-Created: ${(/* @__PURE__ */ new Date()).toISOString()}
-
-L2 File A: [[${fileA}]]
-L2 File B: [[${fileB}]]
-
-## Reason
-
-${reason.trim()}
-
-## Instruction
-
-Review manually. V1 never merges or mutates deep memory files automatically.
-`;
-    await atomicWriteFile(proposal_path, content);
-    return { ok: true, proposal_path };
-  });
-}
-
-// src/tools/readDeep.ts
-import fs8 from "fs/promises";
-
-// src/core/links.ts
-var WIKI_LINK_RE = /\[\[([^\]]+)\]\]/g;
-function extractWikiLinks(content) {
-  return [...content.matchAll(WIKI_LINK_RE)].map((match) => match[1]);
-}
-function hasWikiLink(line, filename) {
-  return extractWikiLinks(line).includes(filename);
-}
-function ensureWikiLink(line, filename) {
-  return hasWikiLink(line, filename) ? line : `${line.trim()} [[${filename}]]`;
-}
-
-// src/tools/readDeep.ts
-async function readDeep(file, rootInput) {
-  const root = resolveRoot(rootInput);
-  await initContextLine(root);
-  const deep_memory_path = deepPath(root, file);
-  const content = await fs8.readFile(deep_memory_path, "utf8");
-  const l3_links = extractWikiLinks(content).filter((link) => link.startsWith("L3_") && link.endsWith(".md"));
-  return { l2_path: deep_memory_path, deep_memory_path, content, l3_links };
-}
-
-// src/tools/readDetails.ts
-import fs9 from "fs/promises";
-async function readDetails(file, rootInput) {
-  const root = resolveRoot(rootInput);
-  await initContextLine(root);
-  const detail_path = detailPath(root, file);
-  const content = await fs9.readFile(detail_path, "utf8");
-  return { l3_path: detail_path, detail_path, content };
-}
-
-// src/tools/updateDeepPointer.ts
-import fs10 from "fs/promises";
-import path7 from "path";
-async function updateDeepPointer(file, factText, detailFile, rootInput) {
-  const root = resolveRoot(rootInput);
-  await initContextLine(root);
-  detailPath(root, detailFile);
-  return withLock(root, async () => {
-    const filePath = deepPath(root, file);
-    let content = "";
-    try {
-      content = await fs10.readFile(filePath, "utf8");
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-      content = `# ${path7.basename(file, ".md")}
-
-`;
-    }
-    const updated_line = ensureWikiLink(factText, detailFile);
-    const next = upsertLineByPrefix(ensureTrailingNewline(content), factText.trim(), updated_line);
-    await atomicWriteFile(filePath, next);
-    return { ok: true, file, updated_line, display: `ContextLine L2 updated
-- File: ${file}` };
-  });
-}
-
-// src/tools/updateIndexPointer.ts
-import fs11 from "fs/promises";
-async function updateIndexPointer(indexLine, files, rootInput) {
-  if (files.some((file) => file.startsWith("L3_"))) {
-    throw new Error("L1 quick memory pointers may only reference L2 deep memory files.");
-  }
-  const root = resolveRoot(rootInput);
-  await initContextLine(root);
-  for (const file of files) {
-    deepPath(root, file);
-  }
-  return withLock(root, async () => {
-    const filePath = l1Path(root);
-    const content = await fs11.readFile(filePath, "utf8");
-    const updated_line = files.reduce((line, file) => ensureWikiLink(line, file), indexLine);
-    const next = upsertLineByPrefix(ensureTrailingNewline(content), indexLine.trim(), updated_line);
-    await atomicWriteFile(filePath, next);
-    return { ok: true, updated_line, display: "ContextLine L1 updated" };
-  });
-}
-
-// src/core/topology.ts
-import fs12 from "fs/promises";
-import path8 from "path";
-async function exists(target) {
-  try {
-    await fs12.access(target);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function listMarkdown(dir) {
-  const out = [];
-  try {
-    const entries = await fs12.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = path8.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        const nested = await listMarkdown(full);
-        out.push(...nested.map((file) => path8.join(entry.name, file)));
-      } else if (entry.name.endsWith(".md")) {
-        out.push(entry.name);
-      }
-    }
-    return out;
-  } catch {
-    return [];
-  }
-}
-async function validateTopology(root) {
-  const errors = [];
-  const warnings = [];
-  const l1 = l1Path(root);
-  const l2 = safeJoin(root, L2_DIR);
-  const l3 = safeJoin(root, L3_DIR);
-  if (!await exists(l1)) errors.push("L1_Quick.md is missing.");
-  if (!await exists(l2)) errors.push("L2_Deep directory is missing.");
-  if (!await exists(l3)) errors.push("L3_Details directory is missing.");
-  if (errors.length) return { ok: false, errors, warnings };
-  const l1Content = await fs12.readFile(l1, "utf8");
-  for (const link of extractWikiLinks(l1Content)) {
-    if (link.startsWith("L3_")) {
-      errors.push(`L1 must not link directly to L3 detail file: ${link}`);
-    } else if (!await exists(path8.join(l2, link))) {
-      errors.push(`L1 links to missing L2 deep memory file: ${link}`);
-    }
-  }
-  for (const file of await listMarkdown(l2)) {
-    const content = await fs12.readFile(path8.join(l2, file), "utf8");
-    for (const link of extractWikiLinks(content)) {
-      if (link === L1_FILE) {
-        errors.push(`L2 deep memory file ${file} must not link upward to L1_Quick.md.`);
-      } else if (!link.startsWith("L3_")) {
-        warnings.push(`L2 deep memory file ${file} links to non-L3 file: ${link}`);
-      } else if (!await exists(path8.join(l3, link))) {
-        errors.push(`L2 deep memory file ${file} links to missing L3 detail file: ${link}`);
-      }
-    }
-  }
-  for (const file of await listMarkdown(l3)) {
-    const content = await fs12.readFile(path8.join(l3, file), "utf8");
-    const links = extractWikiLinks(content);
-    if (links.length) {
-      errors.push(`L3 detail file ${file} must not contain wiki links.`);
-    }
-  }
-  return { ok: errors.length === 0, errors, warnings };
-}
-
-// src/tools/validateTopology.ts
-async function validateTopology2(rootInput) {
-  const root = resolveRoot(rootInput);
-  await initContextLine(root);
-  const result = await validateTopology(root);
-  return {
-    ...result,
-    display: result.ok ? "ContextLine topology valid" : `ContextLine topology invalid
-- Errors: ${result.errors.length}
-- Warnings: ${result.warnings.length}`
-  };
-}
-
-// src/tools/dispatch.ts
-var contextlineInputSchema = {
-  action: z.enum([
-    "init",
-    "hydrate",
-    "read_deep",
-    "read_details",
-    "append_detail",
-    "update_deep",
-    "update_index",
-    "save_memory",
-    "validate",
-    "inspect",
-    "propose_compaction"
-  ]),
-  root: z.string().optional(),
-  file: z.string().optional(),
-  detail_file: z.string().optional(),
-  text: z.string().optional(),
-  date: z.string().optional(),
-  files: z.array(z.string()).optional(),
-  detail: z.object({
-    text: z.string(),
-    date: z.string().optional()
-  }).optional(),
-  deep: z.array(
-    z.object({
-      file: z.string(),
-      text: z.string()
-    })
-  ).optional(),
-  quick: z.array(
-    z.object({
-      text: z.string(),
-      files: z.array(z.string())
-    })
-  ).optional(),
-  file_a: z.string().optional(),
-  file_b: z.string().optional(),
-  reason: z.string().optional()
-};
-function requireString(value, name) {
-  if (!value) throw new Error(`Missing required field: ${name}`);
-  return value;
-}
-async function saveMemory(input) {
-  await initContextLine(input.root);
-  let detailFile = input.detail_file;
-  let detailResult = null;
-  if (input.detail) {
-    const result = await appendFragment(input.detail.text, input.detail.date, input.root);
-    detailFile = result.detail_file;
-    detailResult = result;
-  }
-  const deepResults = [];
-  for (const item of input.deep ?? []) {
-    if (!detailFile) throw new Error("save_memory deep updates require detail_file or detail.");
-    deepResults.push(await updateDeepPointer(item.file, item.text, detailFile, input.root));
-  }
-  const quickResults = [];
-  for (const item of input.quick ?? []) {
-    quickResults.push(await updateIndexPointer(item.text, item.files, input.root));
-  }
-  const validation = await validateTopology2(input.root);
-  const deepFiles = deepResults.map((result) => result.file);
-  return {
-    ok: validation.ok,
-    detail_file: detailFile,
-    detail: detailResult,
-    deep: deepResults,
-    quick: quickResults,
-    validation,
-    display: [
-      "ContextLine memory saved",
-      detailFile ? `- L3 detail: ${detailFile}` : void 0,
-      deepFiles.length ? `- L2 updated: ${deepFiles.join(", ")}` : void 0,
-      quickResults.length ? `- L1 updated: ${quickResults.length} line${quickResults.length === 1 ? "" : "s"}` : void 0,
-      validation.ok ? "- Topology: valid" : `- Topology errors: ${validation.errors.length}`
-    ].filter(Boolean).join("\n")
-  };
-}
-var handlers = {
-  init: (input) => initContextLine(input.root),
-  hydrate: (input) => hydrate(input.root),
-  read_deep: (input) => readDeep(requireString(input.file, "file"), input.root),
-  read_details: (input) => readDetails(requireString(input.file ?? input.detail_file, "file"), input.root),
-  append_detail: (input) => appendFragment(requireString(input.text, "text"), input.date, input.root),
-  update_deep: (input) => updateDeepPointer(requireString(input.file, "file"), requireString(input.text, "text"), requireString(input.detail_file, "detail_file"), input.root),
-  update_index: (input) => updateIndexPointer(requireString(input.text, "text"), input.files ?? [], input.root),
-  save_memory: saveMemory,
-  validate: (input) => validateTopology2(input.root),
-  inspect: (input) => inspect(input.root),
-  propose_compaction: (input) => proposeCompaction(requireString(input.file_a, "file_a"), requireString(input.file_b, "file_b"), requireString(input.reason, "reason"), input.root)
-};
-async function dispatchContextline(input) {
-  return handlers[input.action](input);
-}
-
-// src/prompts/compilerPrompt.ts
-var compilerPrompt = `Compile durable ContextLine memory from the conversation.
-
-Rules:
-1. Treat L1, L2, and L3 as a human-like memory cache hierarchy.
-2. L1 Quick Memory stores compact facts, summaries, and active pointers.
-3. L2 Deep Memory stores richer facts per important object, person, event, project, preference area, or decision thread. For V1, use flat filenames with semantic prefixes, such as person_user.md, project_contextline.md, area_work.md, place_san_jose.md, preference_media.md, decision_architecture.md, event_launch.md, or org_meta.md.
-4. L3 Details stores timestamped specifics, receipts, and supporting history.
-5. Deconstruct durable facts into timestamped L3 detail fragments when supporting specifics are useful.
-6. Cross-save meaning into every relevant L2 deep memory file. If a fact involves person A and project B, update both the person file and the project file with the relevant angle for each, pointing both to the same L3 detail receipt when one exists.
-7. Every L1 memory line should include one or more wiki links to relevant L2 files.
-8. Every L2 memory line should include one or more wiki links to relevant L3 detail files when supporting detail exists. If no L3 detail is needed, keep the L2 line concise and link it later when detail is created.
-9. Evolve L1 only for compact high-level facts, important summaries, or active pointers.
-10. Do not duplicate raw wording across L1, L2, and L3. Store the right level of detail at each cache layer.
-11. Prefer updating existing L2 lines when possible.
-12. Do not create new L2 files unless necessary.
-13. Prefer one call to the "contextline" MCP tool with action "save_memory" so L3, L2, and L1 updates are saved together.`;
-
-// src/prompts/hydrationPrompt.ts
-var hydrationPrompt = `Use ContextLine as a human-like memory cache.
-
-At the start of work, use L1 Quick Memory as the only cold-start memory map. Follow links into L2 Deep Memory files and L3 Details only when needed for the current task. Do not load the entire memory tree.`;
-
-// src/mcpServer.ts
-function textResult(data) {
-  if (data && typeof data === "object" && "display" in data && typeof data.display === "string") {
-    return {
-      content: [{ type: "text", text: data.display }],
-      structuredContent: data
-    };
-  }
-  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-}
-function createServer() {
-  const server = new McpServer({ name: "contextline", version: "0.1.0" });
-  server.registerTool("contextline", { inputSchema: contextlineInputSchema }, async (input) => textResult(await dispatchContextline(input)));
-  server.registerPrompt("contextline_hydration_guide", {}, () => ({
-    messages: [{ role: "user", content: { type: "text", text: hydrationPrompt } }]
-  }));
-  server.registerPrompt("contextline_compile_update", {}, () => ({
-    messages: [{ role: "user", content: { type: "text", text: compilerPrompt } }]
-  }));
-  return server;
-}
-async function startServer() {
-  const server = createServer();
-  await server.connect(new StdioServerTransport());
-}
-
-// src/index.ts
-startServer().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
-//# sourceMappingURL=index.js.map