@swarmvaultai/engine 0.1.11 → 0.1.13

package/dist/index.d.ts

@@ -189,6 +189,10 @@ interface SourceAttachment {
     mimeType: string;
     originalPath?: string;
 }
+interface IngestOptions {
+    includeAssets?: boolean;
+    maxAssetSize?: number;
+}
 interface SourceManifest {
     sourceId: string;
     title: string;
@@ -674,7 +678,7 @@ declare function initWorkspace(rootDir: string): Promise<{
     paths: ResolvedPaths;
 }>;
 
-declare function ingestInput(rootDir: string, input: string): Promise<SourceManifest>;
+declare function ingestInput(rootDir: string, input: string, options?: IngestOptions): Promise<SourceManifest>;
 declare function importInbox(rootDir: string, inputDir?: string): Promise<InboxImportResult>;
 declare function listManifests(rootDir: string): Promise<SourceManifest[]>;
 declare function readExtractedText(rootDir: string, manifest: SourceManifest): Promise<string | undefined>;
@@ -756,4 +760,4 @@ declare function watchVault(rootDir: string, options?: WatchOptions): Promise<Wa
 declare function createWebSearchAdapter(id: string, config: WebSearchProviderConfig, rootDir: string): Promise<WebSearchAdapter>;
 declare function getWebSearchAdapterForTask(rootDir: string, task: "deepLintProvider"): Promise<WebSearchAdapter>;
 
-export { type AnalyzedTerm, type ApprovalChangeType, type ApprovalDetail, type ApprovalEntry, type ApprovalEntryDetail, type ApprovalEntryStatus, type ApprovalManifest, type ApprovalSummary, type CandidateRecord, type ChartDatum, type ChartSpec, type ClaimStatus, type CodeAnalysis, type CodeDiagnostic, type CodeImport, type CodeLanguage, type CodeSymbol, type CodeSymbolKind, type CommandRoleExecutorConfig, type CompileOptions, type CompileResult, type CompileState, type ExploreOptions, type ExploreResult, type ExploreStepResult, type Freshness, type GenerationAttachment, type GenerationRequest, type GenerationResponse, type GraphArtifact, type GraphEdge, type GraphNode, type GraphPage, type ImageGenerationRequest, type ImageGenerationResponse, type InboxImportResult, type InboxImportSkip, type InitOptions, type LintFinding, type LintOptions, type OrchestrationConfig, type OrchestrationFinding, type OrchestrationProposal, type OrchestrationRole, type OrchestrationRoleConfig, type OrchestrationRoleResult, type OutputAsset, type OutputAssetRole, type OutputFormat, type OutputOrigin, type PageKind, type PageManager, type PageStatus, type Polarity, type ProviderAdapter, type ProviderCapability, type ProviderConfig, type ProviderRoleExecutorConfig, type ProviderType, type QueryOptions, type QueryResult, type ResolvedPaths, type ReviewActionResult, type RoleExecutorConfig, type SceneElement, type SceneSpec, type ScheduleController, type ScheduleJobConfig, type ScheduleStateRecord, type ScheduleTriggerConfig, type ScheduledCompileTask, type ScheduledExploreTask, type ScheduledLintTask, type ScheduledQueryTask, type ScheduledRunResult, type ScheduledTaskConfig, type SearchResult, type SourceAnalysis, type SourceAttachment, type SourceClaim, type SourceKind, type SourceManifest, type VaultConfig, type WatchController, type WatchOptions, type WatchRunRecord, type WebSearchAdapter, type WebSearchProviderConfig, type WebSearchProviderType, type WebSearchResult, acceptApproval, archiveCandidate, assertProviderCapability, bootstrapDemo, compileVault, createMcpServer, createProvider, createWebSearchAdapter, defaultVaultConfig, defaultVaultSchema, exploreVault, exportGraphHtml, getProviderForTask, getWebSearchAdapterForTask, getWorkspaceInfo, importInbox, ingestInput, initVault, initWorkspace, installAgent, installConfiguredAgents, lintVault, listApprovals, listCandidates, listManifests, listPages, listSchedules, loadVaultConfig, loadVaultSchema, loadVaultSchemas, promoteCandidate, providerCapabilitySchema, providerTypeSchema, queryVault, readApproval, readExtractedText, readPage, rejectApproval, resolvePaths, runSchedule, searchVault, serveSchedules, startGraphServer, startMcpServer, watchVault, webSearchProviderTypeSchema };
+export { type AnalyzedTerm, type ApprovalChangeType, type ApprovalDetail, type ApprovalEntry, type ApprovalEntryDetail, type ApprovalEntryStatus, type ApprovalManifest, type ApprovalSummary, type CandidateRecord, type ChartDatum, type ChartSpec, type ClaimStatus, type CodeAnalysis, type CodeDiagnostic, type CodeImport, type CodeLanguage, type CodeSymbol, type CodeSymbolKind, type CommandRoleExecutorConfig, type CompileOptions, type CompileResult, type CompileState, type ExploreOptions, type ExploreResult, type ExploreStepResult, type Freshness, type GenerationAttachment, type GenerationRequest, type GenerationResponse, type GraphArtifact, type GraphEdge, type GraphNode, type GraphPage, type ImageGenerationRequest, type ImageGenerationResponse, type InboxImportResult, type InboxImportSkip, type IngestOptions, type InitOptions, type LintFinding, type LintOptions, type OrchestrationConfig, type OrchestrationFinding, type OrchestrationProposal, type OrchestrationRole, type OrchestrationRoleConfig, type OrchestrationRoleResult, type OutputAsset, type OutputAssetRole, type OutputFormat, type OutputOrigin, type PageKind, type PageManager, type PageStatus, type Polarity, type ProviderAdapter, type ProviderCapability, type ProviderConfig, type ProviderRoleExecutorConfig, type ProviderType, type QueryOptions, type QueryResult, type ResolvedPaths, type ReviewActionResult, type RoleExecutorConfig, type SceneElement, type SceneSpec, type ScheduleController, type ScheduleJobConfig, type ScheduleStateRecord, type ScheduleTriggerConfig, type ScheduledCompileTask, type ScheduledExploreTask, type ScheduledLintTask, type ScheduledQueryTask, type ScheduledRunResult, type ScheduledTaskConfig, type SearchResult, type SourceAnalysis, type SourceAttachment, type SourceClaim, type SourceKind, type SourceManifest, type VaultConfig, type WatchController, type WatchOptions, type WatchRunRecord, type WebSearchAdapter, type WebSearchProviderConfig, type WebSearchProviderType, type WebSearchResult, acceptApproval, archiveCandidate, assertProviderCapability, bootstrapDemo, compileVault, createMcpServer, createProvider, createWebSearchAdapter, defaultVaultConfig, defaultVaultSchema, exploreVault, exportGraphHtml, getProviderForTask, getWebSearchAdapterForTask, getWorkspaceInfo, importInbox, ingestInput, initVault, initWorkspace, installAgent, installConfiguredAgents, lintVault, listApprovals, listCandidates, listManifests, listPages, listSchedules, loadVaultConfig, loadVaultSchema, loadVaultSchemas, promoteCandidate, providerCapabilitySchema, providerTypeSchema, queryVault, readApproval, readExtractedText, readPage, rejectApproval, resolvePaths, runSchedule, searchVault, serveSchedules, startGraphServer, startMcpServer, watchVault, webSearchProviderTypeSchema };

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-HFU5S5NO.js";
+} from "./chunk-MZSUYTSL.js";
 
 // src/agents.ts
 import fs from "fs/promises";
@@ -670,6 +670,7 @@ async function appendWatchRun(rootDir, run) {
 }
 
 // src/ingest.ts
+var DEFAULT_MAX_ASSET_SIZE = 10 * 1024 * 1024;
 function inferKind(mimeType, filePath) {
   if (inferCodeLanguage(filePath, mimeType)) {
     return "code";
@@ -698,6 +699,12 @@ function titleFromText(fallback, content) {
 function guessMimeType(target) {
   return mime.lookup(target) || "application/octet-stream";
 }
+function normalizeIngestOptions(options) {
+  return {
+    includeAssets: options?.includeAssets ?? true,
+    maxAssetSize: Math.max(0, Math.floor(options?.maxAssetSize ?? DEFAULT_MAX_ASSET_SIZE))
+  };
+}
 function buildCompositeHash(payloadBytes, attachments = []) {
   if (!attachments.length) {
     return sha256(payloadBytes);
@@ -742,6 +749,40 @@ function extractMarkdownReferences(content) {
   }
   return references;
 }
+function normalizeRemoteReference(value, baseUrl) {
+  const trimmed = value.trim().replace(/^<|>$/g, "");
+  const [withoutTitle] = trimmed.split(/\s+(?=(?:[^"]*"[^"]*")*[^"]*$)/, 1);
+  const candidate = withoutTitle.split("#")[0]?.trim();
+  if (!candidate) {
+    return null;
+  }
+  const lowered = candidate.toLowerCase();
+  if (lowered.startsWith("data:") || lowered.startsWith("mailto:") || lowered.startsWith("#")) {
+    return null;
+  }
+  let resolved;
+  try {
+    resolved = new URL(candidate, baseUrl);
+  } catch {
+    return null;
+  }
+  if (!/^https?:$/i.test(resolved.protocol)) {
+    return null;
+  }
+  resolved.hash = "";
+  return resolved.toString();
+}
+function extractMarkdownImageReferences(content, baseUrl) {
+  const references = [];
+  const imagePattern = /!\[[^\]]*]\(([^)]+)\)/g;
+  for (const match of content.matchAll(imagePattern)) {
+    const normalized = normalizeRemoteReference(match[1] ?? "", baseUrl);
+    if (normalized) {
+      references.push(normalized);
+    }
+  }
+  return references;
+}
 async function convertHtmlToMarkdown(html, url) {
   const dom = new JSDOM(html, { url });
   const article = new Readability(dom.window.document).parse();
@@ -766,6 +807,142 @@ async function readManifestByHash(manifestsDir, contentHash) {
   }
   return null;
 }
+function resolveUrlMimeType(input, response) {
+  const headerMimeType = response.headers.get("content-type")?.split(";")[0]?.trim();
+  const guessedMimeType = guessMimeType(new URL(input).pathname);
+  if (!headerMimeType) {
+    return guessedMimeType;
+  }
+  if ((headerMimeType === "text/plain" || headerMimeType === "application/octet-stream") && guessedMimeType !== "application/octet-stream") {
+    return guessedMimeType;
+  }
+  return headerMimeType;
+}
+function buildRemoteAssetRelativePath(assetUrl, mimeType) {
+  const url = new URL(assetUrl);
+  const normalized = sanitizeAssetRelativePath(`${url.hostname}${url.pathname || "/asset"}`);
+  const extension = path4.posix.extname(normalized);
+  const directory = path4.posix.dirname(normalized);
+  const basename = extension ? path4.posix.basename(normalized, extension) : path4.posix.basename(normalized);
+  const resolvedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
+  const hashedName = `${basename || "asset"}-${sha256(assetUrl).slice(0, 8)}${resolvedExtension}`;
+  return directory === "." ? hashedName : path4.posix.join(directory, hashedName);
+}
+async function readResponseBytesWithinLimit(response, maxBytes) {
+  const contentLength = Number.parseInt(response.headers.get("content-length") ?? "", 10);
+  if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+    throw new Error(`asset exceeds max size (${contentLength} > ${maxBytes})`);
+  }
+  if (!response.body) {
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length > maxBytes) {
+      throw new Error(`asset exceeds max size (${bytes.length} > ${maxBytes})`);
+    }
+    return bytes;
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel("asset exceeds configured size limit");
+      throw new Error(`asset exceeds max size (${total} > ${maxBytes})`);
+    }
+    chunks.push(Buffer.from(value));
+  }
+  return Buffer.concat(chunks);
+}
+async function fetchRemoteImageAttachment(assetUrl, maxAssetSize) {
+  const response = await fetch(assetUrl);
+  if (!response.ok) {
+    throw new Error(`failed with ${response.status} ${response.statusText}`);
+  }
+  const mimeType = response.headers.get("content-type")?.split(";")[0]?.trim() || guessMimeType(new URL(assetUrl).pathname);
+  if (!mimeType.startsWith("image/")) {
+    throw new Error(`unsupported mime type ${mimeType}`);
+  }
+  const bytes = await readResponseBytesWithinLimit(response, maxAssetSize);
+  return {
+    relativePath: buildRemoteAssetRelativePath(assetUrl, mimeType),
+    mimeType,
+    originalPath: assetUrl,
+    bytes
+  };
+}
+async function collectRemoteImageAttachments(assetUrls, options) {
+  if (!options.includeAssets || options.maxAssetSize === 0 || !assetUrls.length) {
+    return { attachments: [], skippedCount: 0 };
+  }
+  const attachments = [];
+  let skippedCount = 0;
+  for (const assetUrl of [...new Set(assetUrls)]) {
+    try {
+      attachments.push(await fetchRemoteImageAttachment(assetUrl, options.maxAssetSize));
+    } catch {
+      skippedCount += 1;
+    }
+  }
+  return { attachments, skippedCount };
+}
+function extractHtmlImageReferences(html, baseUrl) {
+  const dom = new JSDOM(html, { url: baseUrl });
+  const document = dom.window.document;
+  const references = [];
+  for (const image of [...document.querySelectorAll("img[src]")]) {
+    const src = image.getAttribute("src");
+    if (!src) {
+      continue;
+    }
+    const normalized = normalizeRemoteReference(src, baseUrl);
+    if (normalized) {
+      references.push(normalized);
+    }
+  }
+  return references;
+}
+function rewriteHtmlImageReferences(html, baseUrl, replacements) {
+  const dom = new JSDOM(html, { url: baseUrl });
+  const document = dom.window.document;
+  for (const image of [...document.querySelectorAll("img[src]")]) {
+    const src = image.getAttribute("src");
+    if (!src) {
+      continue;
+    }
+    const normalized = normalizeRemoteReference(src, baseUrl);
+    const replacement = normalized ? replacements.get(normalized) : void 0;
+    if (replacement) {
+      image.setAttribute("src", replacement);
+    }
+  }
+  return dom.serialize();
+}
+function rewriteMarkdownImageReferences(content, baseUrl, replacements) {
+  return content.replace(/(!\[[^\]]*]\()([^)]+)(\))/g, (fullMatch, prefix, target, suffix) => {
+    const normalized = normalizeRemoteReference(target, baseUrl);
+    const replacement = normalized ? replacements.get(normalized) : void 0;
+    if (!replacement) {
+      return fullMatch;
+    }
+    return `${prefix}${replacement}${suffix}`;
+  });
+}
+function rewriteMarkdownImageTargets(content, replacements) {
+  return content.replace(/(!\[[^\]]*]\()([^)]+)(\))/g, (fullMatch, prefix, target, suffix) => {
+    const trimmed = target.trim().replace(/^<|>$/g, "");
+    const [withoutTitle] = trimmed.split(/\s+(?=(?:[^"]*"[^"]*")*[^"]*$)/, 1);
+    const candidate = withoutTitle.trim();
+    const replacement = replacements.get(candidate);
+    if (!replacement) {
+      return fullMatch;
+    }
+    return `${prefix}${replacement}${suffix}`;
+  });
+}
 async function persistPreparedInput(rootDir, prepared, paths) {
   await ensureDir(paths.rawSourcesDir);
   await ensureDir(paths.rawAssetsDir);
@@ -817,7 +994,8 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   await appendLogEntry(rootDir, "ingest", prepared.title, [
     `source_id=${sourceId}`,
     `kind=${prepared.sourceKind}`,
-    `attachments=${manifestAttachments.length}`
+    `attachments=${manifestAttachments.length}`,
+    ...prepared.logDetails ?? []
   ]);
   return { manifest, isNew: true };
 }
@@ -847,33 +1025,86 @@ async function prepareFileInput(_rootDir, absoluteInput) {
     extractedText
   };
 }
-async function prepareUrlInput(input) {
+async function prepareUrlInput(input, options) {
   const response = await fetch(input);
   if (!response.ok) {
     throw new Error(`Failed to fetch ${input}: ${response.status} ${response.statusText}`);
   }
-  let payloadBytes = Buffer.from(await response.arrayBuffer());
-  let mimeType = response.headers.get("content-type")?.split(";")[0]?.trim() || guessMimeType(input);
-  let sourceKind = inferKind(mimeType, input);
-  const language = inferCodeLanguage(input, mimeType);
+  const inputUrl = new URL(input);
+  const originalPayloadBytes = Buffer.from(await response.arrayBuffer());
+  let payloadBytes = originalPayloadBytes;
+  let mimeType = resolveUrlMimeType(input, response);
+  let sourceKind = inferKind(mimeType, inputUrl.pathname);
+  const language = inferCodeLanguage(inputUrl.pathname, mimeType);
   let storedExtension = ".bin";
-  let title = new URL(input).hostname + new URL(input).pathname;
+  let title = inputUrl.hostname + inputUrl.pathname;
   let extractedText;
+  let attachments;
+  let contentHash;
+  const logDetails = [];
   if (sourceKind === "html" || mimeType.startsWith("text/html")) {
-    const html = payloadBytes.toString("utf8");
-    const converted = await convertHtmlToMarkdown(html, input);
-    title = converted.title;
+    const html = originalPayloadBytes.toString("utf8");
+    const initialConversion = await convertHtmlToMarkdown(html, input);
+    title = initialConversion.title;
+    let localizedHtml = html;
+    let localAssetReplacements;
+    if (options.includeAssets) {
+      const { attachments: remoteAttachments, skippedCount } = await collectRemoteImageAttachments(
+        extractHtmlImageReferences(html, input),
+        options
+      );
+      if (remoteAttachments.length) {
+        attachments = remoteAttachments;
+        contentHash = buildCompositeHash(originalPayloadBytes, remoteAttachments);
+        const sourceId = `${slugify(title)}-${contentHash.slice(0, 8)}`;
+        localAssetReplacements = new Map(
+          remoteAttachments.map((attachment) => [attachment.originalPath ?? "", `../assets/${sourceId}/${attachment.relativePath}`])
+        );
+        localizedHtml = rewriteHtmlImageReferences(html, input, localAssetReplacements);
+        logDetails.push(`remote_assets=${remoteAttachments.length}`);
+      }
+      if (skippedCount) {
+        logDetails.push(`remote_asset_skips=${skippedCount}`);
+      }
+    }
+    const converted = localizedHtml === html && !attachments?.length ? initialConversion : await convertHtmlToMarkdown(localizedHtml, input);
     extractedText = converted.markdown;
-    payloadBytes = Buffer.from(converted.markdown, "utf8");
+    if (localAssetReplacements?.size) {
+      const absoluteLocalAssetReplacements = new Map(
+        [...localAssetReplacements.values()].map((replacement) => [new URL(replacement, input).toString(), replacement])
+      );
+      extractedText = rewriteMarkdownImageTargets(extractedText, absoluteLocalAssetReplacements);
+    }
+    payloadBytes = Buffer.from(extractedText, "utf8");
     mimeType = "text/markdown";
     sourceKind = "markdown";
     storedExtension = ".md";
   } else {
-    const extension = path4.extname(new URL(input).pathname);
+    const extension = path4.extname(inputUrl.pathname);
     storedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
     if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
       extractedText = payloadBytes.toString("utf8");
-      title = titleFromText(title || new URL(input).hostname, extractedText);
+      title = titleFromText(title || inputUrl.hostname, extractedText);
+      if (sourceKind === "markdown" && options.includeAssets) {
+        const { attachments: remoteAttachments, skippedCount } = await collectRemoteImageAttachments(
+          extractMarkdownImageReferences(extractedText, input),
+          options
+        );
+        if (remoteAttachments.length) {
+          attachments = remoteAttachments;
+          contentHash = buildCompositeHash(originalPayloadBytes, remoteAttachments);
+          const sourceId = `${slugify(title)}-${contentHash.slice(0, 8)}`;
+          const replacements = new Map(
+            remoteAttachments.map((attachment) => [attachment.originalPath ?? "", `../assets/${sourceId}/${attachment.relativePath}`])
+          );
+          extractedText = rewriteMarkdownImageReferences(extractedText, input, replacements);
+          payloadBytes = Buffer.from(extractedText, "utf8");
+          logDetails.push(`remote_assets=${remoteAttachments.length}`);
+        }
+        if (skippedCount) {
+          logDetails.push(`remote_asset_skips=${skippedCount}`);
+        }
+      }
     }
   }
   return {
@@ -885,7 +1116,10 @@ async function prepareUrlInput(input) {
     mimeType,
     storedExtension,
     payloadBytes,
-    extractedText
+    extractedText,
+    attachments,
+    contentHash,
+    logDetails
   };
 }
 async function collectInboxAttachmentRefs(inputDir, files) {
@@ -975,9 +1209,10 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
 function isSupportedInboxKind(sourceKind) {
   return ["markdown", "text", "html", "pdf", "image"].includes(sourceKind);
 }
-async function ingestInput(rootDir, input) {
+async function ingestInput(rootDir, input, options) {
   const { paths } = await initWorkspace(rootDir);
-  const prepared = /^https?:\/\//i.test(input) ? await prepareUrlInput(input) : await prepareFileInput(rootDir, path4.resolve(rootDir, input));
+  const normalizedOptions = normalizeIngestOptions(options);
+  const prepared = /^https?:\/\//i.test(input) ? await prepareUrlInput(input, normalizedOptions) : await prepareFileInput(rootDir, path4.resolve(rootDir, input));
   const result = await persistPreparedInput(rootDir, prepared, paths);
   return result.manifest;
 }
@@ -3592,7 +3827,7 @@ async function resolveImageGenerationProvider(rootDir) {
   if (!providerConfig) {
     throw new Error(`No provider configured with id "${preferredProviderId}" for task "imageProvider".`);
   }
-  const { createProvider: createProvider2 } = await import("./registry-U76DBOV3.js");
+  const { createProvider: createProvider2 } = await import("./registry-2XHXZDGH.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -6531,7 +6766,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.1.11";
+var SERVER_VERSION = "0.1.13";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",

package/dist/registry-2XHXZDGH.js

@@ -0,0 +1,12 @@
+import {
+  assertProviderCapability,
+  createProvider,
+  getProviderForTask,
+  getResolvedPaths
+} from "./chunk-MZSUYTSL.js";
+export {
+  assertProviderCapability,
+  createProvider,
+  getProviderForTask,
+  getResolvedPaths
+};

package/dist/registry-4QRMVAHX.js

@@ -0,0 +1,12 @@
+import {
+  assertProviderCapability,
+  createProvider,
+  getProviderForTask,
+  getResolvedPaths
+} from "./chunk-SRHM3HP4.js";
+export {
+  assertProviderCapability,
+  createProvider,
+  getProviderForTask,
+  getResolvedPaths
+};

package/dist/registry-B7UXRBW3.js

@@ -0,0 +1,12 @@
+import {
+  assertProviderCapability,
+  createProvider,
+  getProviderForTask,
+  getResolvedPaths
+} from "./chunk-HOJ7NSYC.js";
+export {
+  assertProviderCapability,
+  createProvider,
+  getProviderForTask,
+  getResolvedPaths
+};

package/dist/registry-FLSGGY2R.js

@@ -0,0 +1,12 @@
+import {
+  assertProviderCapability,
+  createProvider,
+  getProviderForTask,
+  getResolvedPaths
+} from "./chunk-6MO57J5C.js";
+export {
+  assertProviderCapability,
+  createProvider,
+  getProviderForTask,
+  getResolvedPaths
+};

package/dist/registry-PGZWRXMD.js

@@ -0,0 +1,12 @@
+import {
+  assertProviderCapability,
+  createProvider,
+  getProviderForTask,
+  getResolvedPaths
+} from "./chunk-F7HZZ3VM.js";
+export {
+  assertProviderCapability,
+  createProvider,
+  getProviderForTask,
+  getResolvedPaths
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmvaultai/engine",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Core engine for SwarmVault: ingest, compile, query, lint, and provider abstractions.",
   "type": "module",
   "main": "dist/index.js",
@@ -39,6 +39,11 @@
   "engines": {
     "node": ">=24.0.0"
   },
+  "scripts": {
+    "build": "test -f ../viewer/dist/index.html || pnpm --dir ../viewer build; tsup src/index.ts --format esm --dts && rm -rf dist/viewer && mkdir -p dist/viewer && cp -R ../viewer/dist/. dist/viewer/",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@mozilla/readability": "^0.6.0",
@@ -57,10 +62,5 @@
     "@types/turndown": "^5.0.5",
     "tsup": "^8.5.0",
     "vitest": "^3.2.4"
-  },
-  "scripts": {
-    "build": "test -f ../viewer/dist/index.html || pnpm --dir ../viewer build; tsup src/index.ts --format esm --dts && rm -rf dist/viewer && mkdir -p dist/viewer && cp -R ../viewer/dist/. dist/viewer/",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 SwarmVault
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.