@mycontxt/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1036 @@
+// src/types.ts
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var NotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConflictError";
+  }
+};
+var AuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+
+// src/engine/memory.ts
+var MemoryEngine = class {
+  constructor(db) {
+    this.db = db;
+  }
+  // ==================
+  // Decision Management
+  // ==================
+  async addDecision(projectId, input) {
+    if (!input.title?.trim()) {
+      throw new ValidationError("Decision title is required");
+    }
+    if (!input.rationale?.trim()) {
+      throw new ValidationError("Decision rationale is required");
+    }
+    const entry = await this.db.createEntry({
+      projectId,
+      type: "decision",
+      title: input.title.trim(),
+      content: input.rationale.trim(),
+      metadata: {
+        alternatives: input.alternatives || [],
+        consequences: input.consequences || [],
+        tags: input.tags || []
+      }
+    });
+    return entry;
+  }
+  async listDecisions(projectId, branch) {
+    return this.db.listEntries({
+      projectId,
+      type: "decision",
+      branch,
+      isArchived: false
+    });
+  }
+  async getDecision(id) {
+    const entry = await this.db.getEntry(id);
+    if (!entry || entry.type !== "decision") {
+      throw new NotFoundError(`Decision with id ${id} not found`);
+    }
+    return entry;
+  }
+  async updateDecision(id, updates) {
+    const existing = await this.getDecision(id);
+    return this.db.updateEntry(id, {
+      title: updates.title?.trim() || existing.title,
+      content: updates.rationale?.trim() || existing.content,
+      metadata: {
+        ...existing.metadata,
+        alternatives: updates.alternatives || existing.metadata.alternatives,
+        consequences: updates.consequences || existing.metadata.consequences,
+        tags: updates.tags || existing.metadata.tags
+      }
+    });
+  }
+  // ==================
+  // Pattern Management
+  // ==================
+  async addPattern(projectId, input) {
+    if (!input.title?.trim()) {
+      throw new ValidationError("Pattern title is required");
+    }
+    if (!input.content?.trim()) {
+      throw new ValidationError("Pattern content is required");
+    }
+    return this.db.createEntry({
+      projectId,
+      type: "pattern",
+      title: input.title.trim(),
+      content: input.content.trim(),
+      metadata: {
+        category: input.category || "general",
+        tags: input.tags || []
+      }
+    });
+  }
+  async listPatterns(projectId, branch) {
+    return this.db.listEntries({
+      projectId,
+      type: "pattern",
+      branch,
+      isArchived: false
+    });
+  }
+  async getPattern(id) {
+    const entry = await this.db.getEntry(id);
+    if (!entry || entry.type !== "pattern") {
+      throw new NotFoundError(`Pattern with id ${id} not found`);
+    }
+    return entry;
+  }
+  async updatePattern(id, updates) {
+    const existing = await this.getPattern(id);
+    return this.db.updateEntry(id, {
+      title: updates.title?.trim() || existing.title,
+      content: updates.content?.trim() || existing.content,
+      metadata: {
+        ...existing.metadata,
+        category: updates.category || existing.metadata.category,
+        tags: updates.tags || existing.metadata.tags
+      }
+    });
+  }
+  // ==================
+  // Context Management
+  // ==================
+  async setContext(projectId, input) {
+    const existing = await this.db.listEntries({
+      projectId,
+      type: "context",
+      isArchived: false
+    });
+    const contextData = {
+      feature: input.feature || "",
+      blockers: input.blockers || [],
+      nextSteps: input.nextSteps || [],
+      activeFiles: input.activeFiles || []
+    };
+    if (existing.length > 0) {
+      return this.db.updateEntry(existing[0].id, {
+        title: "Project Context",
+        content: JSON.stringify(contextData, null, 2),
+        metadata: contextData
+      });
+    } else {
+      return this.db.createEntry({
+        projectId,
+        type: "context",
+        title: "Project Context",
+        content: JSON.stringify(contextData, null, 2),
+        metadata: contextData
+      });
+    }
+  }
+  async getContext(projectId) {
+    const entries = await this.db.listEntries({
+      projectId,
+      type: "context",
+      isArchived: false
+    });
+    return entries[0] || null;
+  }
+  // ==================
+  // Document Management
+  // ==================
+  async addDocument(projectId, input) {
+    if (!input.title?.trim()) {
+      throw new ValidationError("Document title is required");
+    }
+    if (!input.content?.trim()) {
+      throw new ValidationError("Document content is required");
+    }
+    return this.db.createEntry({
+      projectId,
+      type: "document",
+      title: input.title.trim(),
+      content: input.content.trim(),
+      metadata: {
+        url: input.url,
+        tags: input.tags || []
+      }
+    });
+  }
+  async listDocuments(projectId, branch) {
+    return this.db.listEntries({
+      projectId,
+      type: "document",
+      branch,
+      isArchived: false
+    });
+  }
+  async getDocument(id) {
+    const entry = await this.db.getEntry(id);
+    if (!entry || entry.type !== "document") {
+      throw new NotFoundError(`Document with id ${id} not found`);
+    }
+    return entry;
+  }
+  // ==================
+  // Session Management
+  // ==================
+  async startSession(projectId, input) {
+    if (!input.feature?.trim()) {
+      throw new ValidationError("Session feature is required");
+    }
+    const active = await this.getActiveSession(projectId);
+    if (active) {
+      throw new ValidationError(
+        "An active session already exists. End it first or use a different branch."
+      );
+    }
+    return this.db.createEntry({
+      projectId,
+      type: "session",
+      title: `Session: ${input.feature}`,
+      content: input.description || "",
+      metadata: {
+        feature: input.feature,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        endedAt: null
+      }
+    });
+  }
+  async endSession(projectId, summary) {
+    const active = await this.getActiveSession(projectId);
+    if (!active) {
+      throw new NotFoundError("No active session found");
+    }
+    return this.db.updateEntry(active.id, {
+      content: summary || active.content,
+      metadata: {
+        ...active.metadata,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+  }
+  async getActiveSession(projectId) {
+    const sessions = await this.db.listEntries({
+      projectId,
+      type: "session",
+      isArchived: false
+    });
+    return sessions.find((s) => !s.metadata.endedAt) || null;
+  }
+  async listSessions(projectId, branch) {
+    return this.db.listEntries({
+      projectId,
+      type: "session",
+      branch,
+      isArchived: false
+    });
+  }
+  // ==================
+  // Generic Operations
+  // ==================
+  async deleteEntry(id, hard = false) {
+    return this.db.deleteEntry(id, hard);
+  }
+  async searchEntries(projectId, searchTerm, options) {
+    return this.db.searchEntries(projectId, searchTerm, options);
+  }
+  async getAllEntries(query) {
+    return this.db.listEntries(query);
+  }
+  async getEntryCount(projectId, branch) {
+    return this.db.countEntries({
+      projectId,
+      branch,
+      isArchived: false
+    });
+  }
+};
+
+// src/engine/relevance.ts
+function calculateRelevance(entry, options) {
+  let score = 0;
+  if (options.taskDescription) {
+    score += keywordOverlap(entry, options.taskDescription) * 0.4;
+  }
+  const daysOld = (Date.now() - entry.updatedAt.getTime()) / (1e3 * 60 * 60 * 24);
+  const recencyScore = Math.exp(-daysOld / 30);
+  score += recencyScore * 0.25;
+  const typePriority = getTypePriority(entry.type);
+  score += typePriority * 0.2;
+  if (options.activeFiles && options.activeFiles.length > 0) {
+    const hasFileMatch = options.activeFiles.some(
+      (file) => entry.content.toLowerCase().includes(file.toLowerCase()) || entry.title.toLowerCase().includes(file.toLowerCase())
+    );
+    if (hasFileMatch) {
+      score += 0.15;
+    }
+  }
+  return Math.min(score, 1);
+}
+function keywordOverlap(entry, query) {
+  const entryText = `${entry.title} ${entry.content}`.toLowerCase();
+  const queryWords = query.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  if (queryWords.length === 0) return 0;
+  const matchCount = queryWords.filter((word) => entryText.includes(word)).length;
+  return matchCount / queryWords.length;
+}
+function getTypePriority(type) {
+  const priorities = {
+    context: 1,
+    // Highest priority
+    decision: 0.8,
+    pattern: 0.8,
+    session: 0.5,
+    document: 0.3
+    // Lowest priority
+  };
+  return priorities[type] || 0.5;
+}
+function getMatchReasons(entry, options) {
+  const reasons = [];
+  if (options.taskDescription) {
+    const overlap = keywordOverlap(entry, options.taskDescription);
+    if (overlap > 0.3) {
+      reasons.push(`${Math.round(overlap * 100)}% keyword match`);
+    }
+  }
+  const daysOld = (Date.now() - entry.updatedAt.getTime()) / (1e3 * 60 * 60 * 24);
+  if (daysOld < 7) {
+    reasons.push("Recently updated");
+  }
+  if (entry.type === "context") {
+    reasons.push("Current context");
+  }
+  if (options.activeFiles) {
+    const matchedFiles = options.activeFiles.filter(
+      (file) => entry.content.toLowerCase().includes(file.toLowerCase())
+    );
+    if (matchedFiles.length > 0) {
+      reasons.push(`References ${matchedFiles.join(", ")}`);
+    }
+  }
+  return reasons;
+}
+function rankEntries(entries, options) {
+  const minRelevance = options.minRelevance || 0.3;
+  return entries.map((entry) => ({
+    entry,
+    score: calculateRelevance(entry, options),
+    reasons: getMatchReasons(entry, options)
+  })).filter((ranked) => ranked.score >= minRelevance).sort((a, b) => b.score - a.score);
+}
+
+// src/engine/sync.ts
+var SyncEngine = class {
+  constructor(local, remote) {
+    this.local = local;
+    this.remote = remote;
+  }
+  /**
+   * Push local changes to remote
+   */
+  async push(projectId, options = {}) {
+    const result = {
+      pushed: 0,
+      pulled: 0,
+      conflicts: 0,
+      errors: []
+    };
+    try {
+      const project = await this.local.getProject(projectId);
+      if (!project) {
+        throw new Error("Project not found locally");
+      }
+      if (!options.dryRun) {
+        await this.remote.upsertProject(project);
+      }
+      const unsyncedEntries = await this.local.getUnsyncedEntries(projectId);
+      if (unsyncedEntries.length === 0) {
+        return result;
+      }
+      const conflicts = [];
+      if (!options.force) {
+        const lastPull = await this.local.getLastPull(projectId);
+        if (lastPull) {
+          const remoteChanges = await this.remote.pullEntries(projectId, lastPull);
+          const unsyncedIds = new Set(unsyncedEntries.map((e) => e.id));
+          for (const remoteEntry of remoteChanges) {
+            if (unsyncedIds.has(remoteEntry.id)) {
+              const localEntry = unsyncedEntries.find((e) => e.id === remoteEntry.id);
+              if (localEntry && localEntry.updatedAt.getTime() !== remoteEntry.updatedAt.getTime()) {
+                conflicts.push(localEntry);
+              }
+            }
+          }
+        }
+      }
+      if (conflicts.length > 0 && !options.force) {
+        result.conflicts = conflicts.length;
+        result.errors.push(
+          `${conflicts.length} conflict(s) found. Use --force to push anyway (last-write-wins).`
+        );
+        return result;
+      }
+      if (!options.dryRun) {
+        await this.remote.pushEntries(unsyncedEntries);
+        await this.local.markSynced(unsyncedEntries.map((e) => e.id));
+      }
+      result.pushed = unsyncedEntries.length;
+      const branches = await this.local.listBranches(projectId);
+      for (const branch of branches) {
+        if (!options.dryRun) {
+          await this.remote.upsertBranch(branch);
+        }
+      }
+      return result;
+    } catch (error) {
+      result.errors.push(
+        error instanceof Error ? error.message : "Unknown error during push"
+      );
+      return result;
+    }
+  }
+  /**
+   * Pull remote changes to local
+   */
+  async pull(projectId, options = {}) {
+    const result = {
+      pushed: 0,
+      pulled: 0,
+      conflicts: 0,
+      errors: []
+    };
+    try {
+      const project = await this.local.getProject(projectId);
+      if (!project) {
+        throw new Error("Project not found locally");
+      }
+      const lastPull = await this.local.getLastPull(projectId);
+      const since = lastPull || /* @__PURE__ */ new Date(0);
+      const remoteEntries = await this.remote.pullEntries(projectId, since);
+      if (remoteEntries.length === 0) {
+        return result;
+      }
+      const unsyncedEntries = await this.local.getUnsyncedEntries(projectId);
+      const unsyncedIds = new Set(unsyncedEntries.map((e) => e.id));
+      const conflicts = [];
+      for (const remoteEntry of remoteEntries) {
+        if (unsyncedIds.has(remoteEntry.id)) {
+          const localEntry = unsyncedEntries.find((e) => e.id === remoteEntry.id);
+          if (localEntry && localEntry.updatedAt.getTime() !== remoteEntry.updatedAt.getTime()) {
+            conflicts.push(remoteEntry);
+          }
+        }
+      }
+      if (conflicts.length > 0 && !options.force) {
+        result.conflicts = conflicts.length;
+        result.errors.push(
+          `${conflicts.length} conflict(s) found. Use --force to pull anyway (last-write-wins).`
+        );
+        return result;
+      }
+      if (!options.dryRun) {
+        for (const entry of remoteEntries) {
+          const localEntry = await this.local.getEntry(entry.id);
+          if (!localEntry) {
+            await this.local.createEntry({
+              id: entry.id,
+              projectId: entry.projectId,
+              type: entry.type,
+              title: entry.title,
+              content: entry.content,
+              metadata: entry.metadata,
+              branch: entry.branch
+            });
+          } else if (entry.updatedAt > localEntry.updatedAt || options.force) {
+            await this.local.updateEntry(entry.id, {
+              title: entry.title,
+              content: entry.content,
+              metadata: entry.metadata,
+              updatedAt: entry.updatedAt,
+              isSynced: true
+            });
+          }
+        }
+        await this.local.updateLastPull(projectId, /* @__PURE__ */ new Date());
+      }
+      result.pulled = remoteEntries.length;
+      return result;
+    } catch (error) {
+      result.errors.push(
+        error instanceof Error ? error.message : "Unknown error during pull"
+      );
+      return result;
+    }
+  }
+  /**
+   * Full bidirectional sync (pull then push)
+   */
+  async sync(projectId, options = {}) {
+    const pullResult = await this.pull(projectId, options);
+    if (pullResult.errors.length > 0) {
+      return pullResult;
+    }
+    const pushResult = await this.push(projectId, options);
+    return {
+      pushed: pushResult.pushed,
+      pulled: pullResult.pulled,
+      conflicts: pullResult.conflicts + pushResult.conflicts,
+      errors: [...pullResult.errors, ...pushResult.errors]
+    };
+  }
+};
+
+// src/utils/tokens.ts
+import { get_encoding } from "tiktoken";
+var encoding = get_encoding("cl100k_base");
+function countTokens(text) {
+  const tokens = encoding.encode(text);
+  return tokens.length;
+}
+function countEntryTokens(entry) {
+  const text = formatEntryForContext(entry);
+  return countTokens(text);
+}
+function formatEntryForContext(entry) {
+  const lines = [];
+  lines.push(`## ${entry.type.toUpperCase()}: ${entry.title}`);
+  lines.push("");
+  lines.push(entry.content);
+  if (entry.metadata && Object.keys(entry.metadata).length > 0) {
+    lines.push("");
+    lines.push("**Metadata:**");
+    for (const [key, value] of Object.entries(entry.metadata)) {
+      if (Array.isArray(value) && value.length > 0) {
+        lines.push(`- ${key}: ${value.join(", ")}`);
+      } else if (value && typeof value === "string") {
+        lines.push(`- ${key}: ${value}`);
+      }
+    }
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  return lines.join("\n");
+}
+function fitToBudget(rankedEntries, maxTokens) {
+  const result = [];
+  let currentTokens = 0;
+  const headerTokens = countTokens("# MemoCore Context\n\n");
+  currentTokens += headerTokens;
+  for (const ranked of rankedEntries) {
+    const entryTokens = countEntryTokens(ranked.entry);
+    if (currentTokens + entryTokens <= maxTokens) {
+      result.push(ranked);
+      currentTokens += entryTokens;
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+function buildContext(rankedEntries, options) {
+  const lines = [];
+  lines.push("# MemoCore Context");
+  lines.push("");
+  if (options?.includeStats) {
+    lines.push(`Found ${rankedEntries.length} relevant entries:`);
+    lines.push("");
+  }
+  for (const ranked of rankedEntries) {
+    if (options?.includeReasons && ranked.reasons.length > 0) {
+      lines.push(`<!-- Match reasons: ${ranked.reasons.join(", ")} -->`);
+    }
+    lines.push(formatEntryForContext(ranked.entry));
+  }
+  return lines.join("\n");
+}
+function cleanup() {
+  encoding.free();
+}
+
+// src/engine/context-builder.ts
+function toRankedEntries(entries) {
+  return entries.map((entry) => ({
+    entry,
+    score: 1,
+    reasons: []
+  }));
+}
+function buildContextPayload(entries, options) {
+  const budget = options.maxTokens || 4e3;
+  let rankedEntries = [];
+  if (options.type === "task" && options.taskDescription) {
+    const suggestOpts = {
+      projectId: options.projectId,
+      taskDescription: options.taskDescription,
+      activeFiles: options.activeFiles,
+      maxTokens: budget
+    };
+    rankedEntries = rankEntries(entries, suggestOpts);
+  } else if (options.type === "files" && options.activeFiles && options.activeFiles.length > 0) {
+    const filtered = entries.filter(
+      (entry) => options.activeFiles.some(
+        (file) => entry.content.includes(file) || entry.metadata?.files?.includes(file)
+      )
+    );
+    filtered.sort(
+      (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()
+    );
+    rankedEntries = toRankedEntries(filtered);
+  } else {
+    const sorted = [...entries];
+    sorted.sort(
+      (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()
+    );
+    rankedEntries = toRankedEntries(sorted);
+  }
+  if (options.includeTypes && options.includeTypes.length > 0) {
+    rankedEntries = rankedEntries.filter(
+      (ranked) => options.includeTypes.includes(ranked.entry.type)
+    );
+  }
+  const fitted = fitToBudget(rankedEntries, budget);
+  const context = buildContext(fitted);
+  const tokensUsed = countTokens(context);
+  return {
+    context,
+    entriesIncluded: fitted.length,
+    tokensUsed,
+    budget
+  };
+}
+function buildContextSummary(entries) {
+  const byType = {};
+  const recentActivity = [];
+  let oldest = null;
+  let newest = null;
+  for (const entry of entries) {
+    byType[entry.type] = (byType[entry.type] || 0) + 1;
+    if (!oldest || entry.createdAt < oldest) {
+      oldest = entry.createdAt;
+    }
+    if (!newest || entry.updatedAt > newest) {
+      newest = entry.updatedAt;
+    }
+  }
+  const recent = [...entries].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, 5);
+  for (const entry of recent) {
+    const age = Date.now() - entry.updatedAt.getTime();
+    const daysAgo = Math.floor(age / (1e3 * 60 * 60 * 24));
+    let timeStr = "";
+    if (daysAgo === 0) {
+      timeStr = "today";
+    } else if (daysAgo === 1) {
+      timeStr = "yesterday";
+    } else if (daysAgo < 7) {
+      timeStr = `${daysAgo} days ago`;
+    } else {
+      timeStr = `${Math.floor(daysAgo / 7)} weeks ago`;
+    }
+    recentActivity.push(`${entry.type}: ${entry.title} (${timeStr})`);
+  }
+  return {
+    totalEntries: entries.length,
+    byType,
+    recentActivity,
+    oldestEntry: oldest,
+    newestEntry: newest
+  };
+}
+
+// src/scanner.ts
+import { createHash } from "crypto";
+var COMMENT_PATTERNS = [
+  // Single line comments: // @tag
+  { pattern: /^(\s*)\/\/\s*/, continuation: /^(\s*)\/\/\s+(?!@)/ },
+  // Python/Ruby/Shell: # @tag
+  { pattern: /^(\s*)#\s*/, continuation: /^(\s*)#\s+(?!@)/ },
+  // SQL: -- @tag
+  { pattern: /^(\s*)--\s*/, continuation: /^(\s*)--\s+(?!@)/ }
+];
+var TAG_PATTERN = /@(decision|pattern|context)\s*/i;
+var CATEGORY_PATTERN = /^\[([^\]]+)\]\s*/;
+var FIELD_PATTERN = /\|\s*(\w+):\s*([^|]+)/g;
+function parseFile(content, filePath) {
+  const lines = content.split("\n");
+  const comments = [];
+  let currentComment = null;
+  let currentIndent = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    const tagMatch = detectTag(line);
+    if (tagMatch) {
+      if (currentComment && currentComment.title) {
+        comments.push(finalizeComment(currentComment, filePath));
+      }
+      const { tag, content: content2, category } = tagMatch;
+      const { title, fields } = extractTitleAndFields(content2);
+      currentComment = {
+        tag,
+        category,
+        title,
+        content: title,
+        fields,
+        file: filePath,
+        line: lineNum
+      };
+      currentIndent = getIndent(line);
+      continue;
+    }
+    if (currentComment && isContinuationLine(line, currentIndent)) {
+      const continuationText = extractContinuationText(line);
+      if (continuationText) {
+        currentComment.content += " " + continuationText;
+        const moreFields = extractFields(continuationText);
+        Object.assign(currentComment.fields, moreFields);
+      }
+      continue;
+    }
+    if (currentComment && currentComment.title) {
+      comments.push(finalizeComment(currentComment, filePath));
+      currentComment = null;
+    }
+  }
+  if (currentComment && currentComment.title) {
+    comments.push(finalizeComment(currentComment, filePath));
+  }
+  return comments;
+}
+function detectTag(line) {
+  let commentContent = null;
+  for (const { pattern } of COMMENT_PATTERNS) {
+    const match = line.match(pattern);
+    if (match) {
+      commentContent = line.substring(match[0].length);
+      break;
+    }
+  }
+  if (!commentContent) return null;
+  const tagMatch = commentContent.match(TAG_PATTERN);
+  if (!tagMatch) return null;
+  const tag = tagMatch[1].toLowerCase();
+  let content = commentContent.substring(tagMatch[0].length).trim();
+  let category;
+  const categoryMatch = content.match(CATEGORY_PATTERN);
+  if (categoryMatch) {
+    category = categoryMatch[1];
+    content = content.substring(categoryMatch[0].length).trim();
+  }
+  return { tag, content, category };
+}
+function isContinuationLine(line, expectedIndent) {
+  for (const { continuation } of COMMENT_PATTERNS) {
+    const match = line.match(continuation);
+    if (match && match[1] === expectedIndent) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractContinuationText(line) {
+  for (const { continuation } of COMMENT_PATTERNS) {
+    const match = line.match(continuation);
+    if (match) {
+      return line.substring(match[0].length).trim();
+    }
+  }
+  return null;
+}
+function getIndent(line) {
+  const match = line.match(/^(\s*)/);
+  return match ? match[1] : "";
+}
+function extractTitleAndFields(content) {
+  const fields = extractFields(content);
+  const pipeIndex = content.indexOf("|");
+  const title = pipeIndex >= 0 ? content.substring(0, pipeIndex).trim() : content.trim();
+  return { title, fields };
+}
+function extractFields(content) {
+  const fields = {};
+  let match;
+  FIELD_PATTERN.lastIndex = 0;
+  while ((match = FIELD_PATTERN.exec(content)) !== null) {
+    const key = match[1];
+    const value = match[2].trim();
+    fields[key] = value;
+  }
+  return fields;
+}
+function finalizeComment(partial, filePath) {
+  const content = partial.content || partial.title || "";
+  const hash = createContentHash(partial.tag, partial.title, content);
+  return {
+    tag: partial.tag,
+    category: partial.category,
+    title: partial.title,
+    content,
+    fields: partial.fields || {},
+    file: filePath,
+    line: partial.line,
+    hash
+  };
+}
+function createContentHash(tag, title, content) {
+  const normalized = `${tag}:${title}:${content}`.toLowerCase().replace(/\s+/g, " ");
+  return createHash("sha256").update(normalized).digest("hex").substring(0, 16);
+}
+function scanCommentToEntry(comment, projectId) {
+  const metadata = {
+    source: "scan",
+    file: comment.file,
+    line: comment.line,
+    hash: comment.hash,
+    category: comment.category,
+    ...comment.fields
+  };
+  if (comment.tag === "decision") {
+    return {
+      type: "decision",
+      title: comment.title,
+      content: comment.fields.rationale || comment.content,
+      metadata: {
+        ...metadata,
+        alternatives: comment.fields.alternatives,
+        consequences: comment.fields.consequences,
+        status: comment.fields.status || "active"
+      }
+    };
+  }
+  if (comment.tag === "pattern") {
+    return {
+      type: "pattern",
+      title: comment.title,
+      content: comment.fields.template || comment.content,
+      metadata: {
+        ...metadata,
+        when: comment.fields.when
+      }
+    };
+  }
+  return {
+    type: "context",
+    title: "Active Context",
+    content: comment.content,
+    metadata
+  };
+}
+
+// src/rules-parser.ts
+function parseRulesFile(content) {
+  const lines = content.split("\n");
+  const result = {
+    stack: [],
+    decisions: [],
+    patterns: [],
+    context: null,
+    documents: []
+  };
+  let currentSection = null;
+  let currentContent = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const headingMatch = line.match(/^#+\s+(.+)/);
+    if (headingMatch) {
+      if (currentSection && currentContent.length > 0) {
+        processSection(currentSection, currentContent.join("\n"), result);
+      }
+      currentSection = headingMatch[1].trim();
+      currentContent = [];
+      continue;
+    }
+    if (currentSection && line.trim()) {
+      currentContent.push(line);
+    }
+  }
+  if (currentSection && currentContent.length > 0) {
+    processSection(currentSection, currentContent.join("\n"), result);
+  }
+  return result;
+}
+function processSection(heading, content, result) {
+  const headingLower = heading.toLowerCase();
+  if (headingLower === "stack" || headingLower === "tech stack") {
+    result.stack = parseListItems(content);
+  } else if (headingLower === "decisions") {
+    result.decisions = parseDecisions(content);
+  } else if (headingLower === "patterns") {
+    result.patterns = parsePatterns(content);
+  } else if (headingLower === "context") {
+    result.context = parseContext(content);
+  } else {
+    result.documents.push({
+      type: "document",
+      title: heading,
+      content: content.trim(),
+      metadata: { source: "rules", section: heading }
+    });
+  }
+}
+function parseListItems(content) {
+  const items = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const match = line.match(/^[-*]\s+(.+)/);
+    if (match) {
+      items.push(match[1].trim());
+    }
+  }
+  return items;
+}
+function parseDecisions(content) {
+  const decisions = [];
+  const items = parseListItems(content);
+  for (const item of items) {
+    const match = item.match(/^(.+?)\s*\(([^)]+)\)\s*$/);
+    if (match) {
+      const title = match[1].trim();
+      const rationale = match[2].trim();
+      decisions.push({
+        type: "decision",
+        title,
+        content: rationale,
+        metadata: {
+          source: "rules",
+          rationale
+        }
+      });
+    } else {
+      decisions.push({
+        type: "decision",
+        title: item,
+        content: item,
+        metadata: { source: "rules" }
+      });
+    }
+  }
+  return decisions;
+}
+function parsePatterns(content) {
+  const patterns = [];
+  const items = parseListItems(content);
+  for (const item of items) {
+    const colonIndex = item.indexOf(":");
+    if (colonIndex >= 0) {
+      const name = item.substring(0, colonIndex).trim();
+      const description = item.substring(colonIndex + 1).trim();
+      patterns.push({
+        type: "pattern",
+        title: name,
+        content: description,
+        metadata: { source: "rules" }
+      });
+    } else {
+      patterns.push({
+        type: "pattern",
+        title: item,
+        content: item,
+        metadata: { source: "rules" }
+      });
+    }
+  }
+  return patterns;
+}
+function parseContext(content) {
+  return {
+    type: "context",
+    title: "Active Context",
+    content: content.trim(),
+    metadata: { source: "rules" }
+  };
+}
+function generateRulesFile(entries) {
+  const sections = [];
+  if (entries.stack.length > 0) {
+    sections.push("# Stack\n");
+    for (const item of entries.stack) {
+      sections.push(`- ${item}`);
+    }
+    sections.push("");
+  }
+  if (entries.decisions.length > 0) {
+    sections.push("# Decisions\n");
+    for (const decision of entries.decisions) {
+      const rationale = decision.metadata.rationale || decision.content;
+      sections.push(`- ${decision.title} (${rationale})`);
+    }
+    sections.push("");
+  }
+  if (entries.patterns.length > 0) {
+    sections.push("# Patterns\n");
+    for (const pattern of entries.patterns) {
+      sections.push(`- ${pattern.title}: ${pattern.content}`);
+    }
+    sections.push("");
+  }
+  if (entries.context.length > 0) {
+    sections.push("# Context\n");
+    sections.push(entries.context[0].content);
+    sections.push("");
+  }
+  for (const doc of entries.documents) {
+    sections.push(`# ${doc.title}
+`);
+    sections.push(doc.content);
+    sections.push("");
+  }
+  return sections.join("\n");
+}
+export {
+  AuthError,
+  ConflictError,
+  MemoryEngine,
+  NotFoundError,
+  SyncEngine,
+  ValidationError,
+  buildContext,
+  buildContextPayload,
+  buildContextSummary,
+  calculateRelevance,
+  cleanup,
+  countEntryTokens,
+  countTokens,
+  fitToBudget,
+  formatEntryForContext,
+  generateRulesFile,
+  getMatchReasons,
+  parseFile,
+  parseRulesFile,
+  rankEntries,
+  scanCommentToEntry
+};
+//# sourceMappingURL=index.js.map