@fragments-sdk/context 0.1.3 → 0.2.0

package/dist/chunk-3FEHRHFQ.js

@@ -0,0 +1,103 @@
+// src/citations/document-builder.ts
+function buildCitationDocuments(chunks, options) {
+  const documents = [];
+  const documentMap = [];
+  const byFile = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    const existing = byFile.get(chunk.filePath);
+    if (existing) {
+      existing.push(chunk);
+    } else {
+      byFile.set(chunk.filePath, [chunk]);
+    }
+  }
+  for (const [filePath, fileChunks] of byFile) {
+    const docIndex = documents.length;
+    const contentBlocks = fileChunks.map((chunk) => ({
+      type: "text",
+      text: chunk.content
+    }));
+    const contextLines = fileChunks.map((chunk, i) => {
+      const parts = [`Block ${i}: lines ${chunk.startLine}-${chunk.endLine} (${chunk.language})`];
+      if (chunk.symbolName) parts.push(`symbol: ${chunk.symbolName}`);
+      return parts.join(", ");
+    });
+    documents.push({
+      type: "document",
+      source: { type: "content", content: contentBlocks },
+      title: filePath,
+      context: contextLines.join("\n"),
+      citations: { enabled: true }
+    });
+    documentMap.push({
+      documentIndex: docIndex,
+      filePath,
+      sourceType: "code",
+      chunks: fileChunks.map((chunk, i) => ({
+        blockIndex: i,
+        startLine: chunk.startLine,
+        endLine: chunk.endLine,
+        language: chunk.language,
+        symbolName: chunk.symbolName,
+        score: chunk.score
+      }))
+    });
+  }
+  if (options?.additionalDocuments) {
+    for (const doc of options.additionalDocuments) {
+      if (!doc.content.trim()) continue;
+      const docIndex = documents.length;
+      documents.push({
+        type: "document",
+        source: {
+          type: "text",
+          media_type: "text/plain",
+          data: doc.content
+        },
+        title: doc.title,
+        citations: { enabled: true }
+      });
+      documentMap.push({
+        documentIndex: docIndex,
+        filePath: doc.title,
+        sourceType: "plaintext",
+        chunks: []
+      });
+    }
+  }
+  return { documents, documentMap };
+}
+
+// src/citations/resolver.ts
+function resolveCitation(raw, documentMap, citationIndex, textOffset) {
+  const mapping = documentMap[raw.document_index];
+  const base = {
+    index: citationIndex,
+    citedText: raw.cited_text,
+    documentTitle: raw.document_title,
+    filePath: mapping?.filePath ?? raw.document_title ?? "unknown",
+    sourceType: mapping?.sourceType ?? "plaintext",
+    textOffset
+  };
+  if (raw.type === "content_block_location" && mapping?.sourceType === "code" && raw.start_block_index != null) {
+    const chunk = mapping.chunks[raw.start_block_index];
+    if (chunk) {
+      base.startLine = chunk.startLine;
+      base.endLine = chunk.endLine;
+      base.language = chunk.language;
+      base.symbolName = chunk.symbolName;
+    }
+  }
+  return base;
+}
+function resolveCitations(raws, documentMap, textOffsets) {
+  return raws.map(
+    (raw, i) => resolveCitation(raw, documentMap, i + 1, textOffsets[i] ?? 0)
+  );
+}
+
+export {
+  buildCitationDocuments,
+  resolveCitation,
+  resolveCitations
+};

package/dist/chunk-3VPR67FN.js

@@ -0,0 +1,76 @@
+// src/embeddings/voyage.ts
+var VOYAGE_EMBEDDINGS_URL = "https://api.voyageai.com/v1/embeddings";
+var VOYAGE_RERANK_URL = "https://api.voyageai.com/v1/rerank";
+var DEFAULT_MODEL = "voyage-code-3";
+var DEFAULT_RERANK_MODEL = "rerank-2.5";
+var DEFAULT_DIMENSIONS = 1024;
+var DEFAULT_MAX_CHARS = 32e3;
+var DEFAULT_BATCH_SIZE = 128;
+async function generateEmbeddings(texts, options) {
+  if (texts.length === 0) return [];
+  const maxChars = options.maxChars ?? DEFAULT_MAX_CHARS;
+  const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+  const dimensions = options.dimensions ?? DEFAULT_DIMENSIONS;
+  const truncated = texts.map(
+    (t) => t.length > maxChars ? t.slice(0, maxChars) : t
+  );
+  const results = [];
+  for (let i = 0; i < truncated.length; i += batchSize) {
+    const batch = truncated.slice(i, i + batchSize);
+    const response = await fetch(VOYAGE_EMBEDDINGS_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${options.apiKey}`
+      },
+      body: JSON.stringify({
+        model: DEFAULT_MODEL,
+        input: batch,
+        input_type: options.inputType,
+        output_dimension: dimensions
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Voyage API error ${response.status}: ${body}`);
+    }
+    const data = await response.json();
+    const sorted = data.data.sort((a, b) => a.index - b.index);
+    for (const item of sorted) {
+      results.push(item.embedding);
+    }
+  }
+  return results;
+}
+async function rerankResults(query, documents, options) {
+  if (documents.length === 0) return [];
+  const topK = options.topK ?? 15;
+  const model = options.model ?? DEFAULT_RERANK_MODEL;
+  const response = await fetch(VOYAGE_RERANK_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${options.apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      query,
+      documents,
+      top_k: topK
+    })
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Voyage Rerank API error ${response.status}: ${body}`);
+  }
+  const data = await response.json();
+  return data.data.map((item) => ({
+    index: item.index,
+    relevanceScore: item.relevance_score
+  }));
+}
+
+export {
+  generateEmbeddings,
+  rerankResults
+};

package/dist/chunk-HINI3FCI.js

@@ -0,0 +1,42 @@
+// src/indexing/hasher.ts
+import { createHash } from "crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+
+// src/indexing/diff-resolver.ts
+function resolveChanges(oldEntries, newEntries) {
+  const oldMap = /* @__PURE__ */ new Map();
+  for (const entry of oldEntries) {
+    oldMap.set(entry.filePath, entry);
+  }
+  const newMap = /* @__PURE__ */ new Map();
+  for (const entry of newEntries) {
+    newMap.set(entry.filePath, entry);
+  }
+  const added = [];
+  const modified = [];
+  const unchanged = [];
+  const deleted = [];
+  for (const [filePath, newEntry] of newMap) {
+    const oldEntry = oldMap.get(filePath);
+    if (!oldEntry) {
+      added.push(filePath);
+    } else if (oldEntry.contentHash !== newEntry.contentHash) {
+      modified.push(filePath);
+    } else {
+      unchanged.push(filePath);
+    }
+  }
+  for (const filePath of oldMap.keys()) {
+    if (!newMap.has(filePath)) {
+      deleted.push(filePath);
+    }
+  }
+  return { added, modified, deleted, unchanged };
+}
+
+export {
+  hashContent,
+  resolveChanges
+};

package/dist/chunk-JFV27WLV.js

@@ -0,0 +1,168 @@
+// src/indexing/file-filter.ts
+var INDEXABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".swift",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".rb",
+  ".php",
+  ".scala",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".sql",
+  ".graphql",
+  ".gql",
+  ".css",
+  ".scss",
+  ".less",
+  ".html",
+  ".svelte",
+  ".vue",
+  ".md",
+  ".mdx",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".xml",
+  ".proto",
+  ".tf",
+  ".hcl",
+  ".dockerfile",
+  ".prisma"
+]);
+var IGNORED_DIRS = [
+  "node_modules/",
+  "dist/",
+  ".git/",
+  ".next/",
+  "__pycache__/",
+  ".cache/",
+  "coverage/",
+  "build/",
+  ".turbo/",
+  "vendor/",
+  ".venv/"
+];
+var IGNORED_FILES = [
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  "bun.lockb",
+  "Cargo.lock",
+  "go.sum",
+  "poetry.lock",
+  "Pipfile.lock",
+  "composer.lock",
+  "Gemfile.lock"
+];
+var MAX_FILE_SIZE = 100 * 1024;
+function shouldIndexFile(path, size) {
+  if (size > MAX_FILE_SIZE) return false;
+  if (IGNORED_FILES.includes(path.split("/").pop() ?? "")) return false;
+  for (const dir of IGNORED_DIRS) {
+    if (path.includes(dir)) return false;
+  }
+  const ext = getExtension(path);
+  if (!ext) {
+    const basename = path.split("/").pop() ?? "";
+    return basename === "Dockerfile" || basename === "Makefile";
+  }
+  return INDEXABLE_EXTENSIONS.has(ext);
+}
+var LANGUAGE_MAP = {
+  ".ts": { language: "typescript", grammar: "typescript" },
+  ".tsx": { language: "typescript", grammar: "tsx" },
+  ".js": { language: "javascript", grammar: "javascript" },
+  ".jsx": { language: "javascript", grammar: "javascript" },
+  ".mjs": { language: "javascript", grammar: "javascript" },
+  ".cjs": { language: "javascript", grammar: "javascript" },
+  ".py": { language: "python", grammar: "python" },
+  ".go": { language: "go", grammar: "go" },
+  ".rs": { language: "rust", grammar: "rust" },
+  ".java": { language: "java", grammar: "java" },
+  ".kt": { language: "kotlin", grammar: "" },
+  ".swift": { language: "swift", grammar: "" },
+  ".c": { language: "c", grammar: "" },
+  ".cpp": { language: "cpp", grammar: "" },
+  ".h": { language: "c", grammar: "" },
+  ".hpp": { language: "cpp", grammar: "" },
+  ".cs": { language: "csharp", grammar: "" },
+  ".rb": { language: "ruby", grammar: "" },
+  ".php": { language: "php", grammar: "" },
+  ".scala": { language: "scala", grammar: "" },
+  ".sh": { language: "shell", grammar: "" },
+  ".bash": { language: "shell", grammar: "" },
+  ".zsh": { language: "shell", grammar: "" },
+  ".sql": { language: "sql", grammar: "" },
+  ".graphql": { language: "graphql", grammar: "" },
+  ".gql": { language: "graphql", grammar: "" },
+  ".css": { language: "css", grammar: "" },
+  ".scss": { language: "scss", grammar: "" },
+  ".less": { language: "less", grammar: "" },
+  ".html": { language: "html", grammar: "" },
+  ".svelte": { language: "svelte", grammar: "" },
+  ".vue": { language: "vue", grammar: "" },
+  ".md": { language: "markdown", grammar: "" },
+  ".mdx": { language: "markdown", grammar: "" },
+  ".json": { language: "json", grammar: "" },
+  ".yaml": { language: "yaml", grammar: "" },
+  ".yml": { language: "yaml", grammar: "" },
+  ".toml": { language: "toml", grammar: "" },
+  ".xml": { language: "xml", grammar: "" },
+  ".proto": { language: "protobuf", grammar: "" },
+  ".tf": { language: "terraform", grammar: "" },
+  ".hcl": { language: "hcl", grammar: "" },
+  ".dockerfile": { language: "dockerfile", grammar: "" },
+  ".prisma": { language: "prisma", grammar: "" }
+};
+var AST_SUPPORTED_LANGUAGES = /* @__PURE__ */ new Set([
+  "typescript",
+  "tsx",
+  "javascript",
+  "python",
+  "go",
+  "rust",
+  "java"
+]);
+function detectLanguage(path) {
+  const ext = getExtension(path);
+  if (ext && ext in LANGUAGE_MAP) return LANGUAGE_MAP[ext].language;
+  const basename = path.split("/").pop() ?? "";
+  if (basename === "Dockerfile") return "dockerfile";
+  if (basename === "Makefile") return "makefile";
+  return "unknown";
+}
+function getTreeSitterGrammar(path) {
+  const ext = getExtension(path);
+  if (ext && ext in LANGUAGE_MAP) return LANGUAGE_MAP[ext].grammar;
+  return "";
+}
+function getExtension(path) {
+  const basename = path.split("/").pop() ?? "";
+  const dotIdx = basename.lastIndexOf(".");
+  if (dotIdx <= 0) return "";
+  return basename.slice(dotIdx).toLowerCase();
+}
+
+export {
+  INDEXABLE_EXTENSIONS,
+  shouldIndexFile,
+  AST_SUPPORTED_LANGUAGES,
+  detectLanguage,
+  getTreeSitterGrammar
+};

package/dist/chunk-KKABP4K4.js

@@ -0,0 +1,228 @@
+// src/generate/index.ts
+var PLACEHOLDER_PATTERNS = [
+  /^\w+ component is needed$/i,
+  /^Alternative component is more appropriate$/i,
+  /^Use \w+ when you need/i
+];
+function filterPlaceholders(items) {
+  if (!items) return [];
+  return items.filter(
+    (item) => !PLACEHOLDER_PATTERNS.some((pattern) => pattern.test(item.trim()))
+  );
+}
+function generateContext(segments, options = {}, blocks) {
+  const format = options.format ?? "markdown";
+  const compact = options.compact ?? false;
+  const include = {
+    props: options.include?.props ?? true,
+    variants: options.include?.variants ?? true,
+    usage: options.include?.usage ?? true,
+    relations: options.include?.relations ?? false,
+    code: options.include?.code ?? false
+  };
+  const sorted = [...segments].sort((a, b) => {
+    const catCompare = a.meta.category.localeCompare(b.meta.category);
+    if (catCompare !== 0) return catCompare;
+    return a.meta.name.localeCompare(b.meta.name);
+  });
+  if (format === "json") {
+    return generateJsonContext(sorted, include, compact, blocks);
+  }
+  return generateMarkdownContext(sorted, include, compact, blocks);
+}
+function generateMarkdownContext(segments, include, compact, blocks) {
+  const lines = [];
+  lines.push("# Design System Reference");
+  lines.push("");
+  lines.push("## Quick Reference");
+  lines.push("");
+  lines.push("| Component | Category | Use For |");
+  lines.push("|-----------|----------|---------|");
+  for (const segment of segments) {
+    const filteredWhen = filterPlaceholders(segment.usage.when);
+    const useFor = filteredWhen.slice(0, 2).join(", ") || segment.meta.description;
+    lines.push(`| ${segment.meta.name} | ${segment.meta.category} | ${truncate(useFor, 50)} |`);
+  }
+  lines.push("");
+  if (compact) {
+    const content2 = lines.join("\n");
+    return { content: content2, tokenEstimate: estimateTokens(content2) };
+  }
+  lines.push("## Components");
+  lines.push("");
+  for (const segment of segments) {
+    lines.push(`### ${segment.meta.name}`);
+    lines.push("");
+    const statusParts = [`**Category:** ${segment.meta.category}`];
+    if (segment.meta.status) {
+      statusParts.push(`**Status:** ${segment.meta.status}`);
+    }
+    lines.push(statusParts.join(" | "));
+    lines.push("");
+    if (segment.meta.description) {
+      lines.push(segment.meta.description);
+      lines.push("");
+    }
+    const whenFiltered = filterPlaceholders(segment.usage.when);
+    const whenNotFiltered = filterPlaceholders(segment.usage.whenNot);
+    if (include.usage && (whenFiltered.length > 0 || whenNotFiltered.length > 0)) {
+      if (whenFiltered.length > 0) {
+        lines.push("**When to use:**");
+        for (const when of whenFiltered) {
+          lines.push(`- ${when}`);
+        }
+        lines.push("");
+      }
+      if (whenNotFiltered.length > 0) {
+        lines.push("**When NOT to use:**");
+        for (const whenNot of whenNotFiltered) {
+          lines.push(`- ${whenNot}`);
+        }
+        lines.push("");
+      }
+    }
+    if (include.props && Object.keys(segment.props).length > 0) {
+      lines.push("**Props:**");
+      for (const [name, prop] of Object.entries(segment.props)) {
+        lines.push(`- \`${name}\`: ${formatPropType(prop)}${prop.required ? " (required)" : ""}`);
+      }
+      lines.push("");
+    }
+    if (include.variants && segment.variants.length > 0) {
+      const variantNames = segment.variants.map((v) => v.name).join(", ");
+      lines.push(`**Variants:** ${variantNames}`);
+      lines.push("");
+      if (include.code) {
+        for (const variant of segment.variants) {
+          if (variant.code) {
+            lines.push(`*${variant.name}:*`);
+            lines.push("```tsx");
+            lines.push(variant.code);
+            lines.push("```");
+            lines.push("");
+          }
+        }
+      }
+    }
+    if (include.relations && segment.relations && segment.relations.length > 0) {
+      lines.push("**Related:**");
+      for (const relation of segment.relations) {
+        lines.push(`- ${relation.component} (${relation.relationship}): ${relation.note}`);
+      }
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+  }
+  if (blocks && blocks.length > 0) {
+    lines.push("## Blocks");
+    lines.push("");
+    lines.push("Composition patterns showing how components wire together.");
+    lines.push("");
+    for (const block of blocks) {
+      lines.push(`### ${block.name}`);
+      lines.push("");
+      lines.push(block.description);
+      lines.push("");
+      lines.push(`**Category:** ${block.category}`);
+      lines.push(`**Components:** ${block.components.join(", ")}`);
+      if (block.tags && block.tags.length > 0) {
+        lines.push(`**Tags:** ${block.tags.join(", ")}`);
+      }
+      lines.push("");
+      lines.push("```tsx");
+      lines.push(block.code);
+      lines.push("```");
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+  }
+  const content = lines.join("\n");
+  return { content, tokenEstimate: estimateTokens(content) };
+}
+function generateJsonContext(segments, include, compact, blocks) {
+  const categories = [...new Set(segments.map((s) => s.meta.category))].sort();
+  const components = {};
+  for (const segment of segments) {
+    const component = {
+      category: segment.meta.category,
+      description: segment.meta.description
+    };
+    if (segment.meta.status) {
+      component.status = segment.meta.status;
+    }
+    if (!compact) {
+      if (include.usage) {
+        const whenFiltered = filterPlaceholders(segment.usage.when);
+        const whenNotFiltered = filterPlaceholders(segment.usage.whenNot);
+        if (whenFiltered.length > 0) component.whenToUse = whenFiltered;
+        if (whenNotFiltered.length > 0) component.whenNotToUse = whenNotFiltered;
+      }
+      if (include.props && Object.keys(segment.props).length > 0) {
+        component.props = {};
+        for (const [name, prop] of Object.entries(segment.props)) {
+          component.props[name] = {
+            type: formatPropType(prop),
+            description: prop.description
+          };
+          if (prop.required) component.props[name].required = true;
+          if (prop.default !== void 0) component.props[name].default = prop.default;
+        }
+      }
+      if (include.variants && segment.variants.length > 0) {
+        component.variants = segment.variants.map((v) => v.name);
+      }
+      if (include.relations && segment.relations && segment.relations.length > 0) {
+        component.relations = segment.relations.map((r) => ({
+          component: r.component,
+          relationship: r.relationship,
+          note: r.note
+        }));
+      }
+    }
+    components[segment.meta.name] = component;
+  }
+  const blocksMap = blocks && blocks.length > 0 ? Object.fromEntries(blocks.map((b) => [b.name, {
+    description: b.description,
+    category: b.category,
+    components: b.components,
+    code: b.code,
+    tags: b.tags
+  }])) : void 0;
+  const output = {
+    version: "1.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      totalComponents: segments.length,
+      categories,
+      ...blocksMap && { totalBlocks: blocks.length }
+    },
+    components,
+    ...blocksMap && { blocks: blocksMap }
+  };
+  const content = JSON.stringify(output, null, 2);
+  return { content, tokenEstimate: estimateTokens(content) };
+}
+function formatPropType(prop) {
+  if (prop.type === "enum" && prop.values) {
+    return prop.values.map((v) => `"${v}"`).join(" | ");
+  }
+  if (prop.default !== void 0) {
+    return `${prop.type} (default: ${JSON.stringify(prop.default)})`;
+  }
+  return prop.type;
+}
+function truncate(str, maxLength) {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + "...";
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+export {
+  PLACEHOLDER_PATTERNS,
+  filterPlaceholders,
+  generateContext
+};