@semiont/make-meaning 0.1.0

package/dist/index.js

@@ -0,0 +1,715 @@
+// src/resource-context.ts
+import { FilesystemViewStorage } from "@semiont/event-sourcing";
+import { FilesystemRepresentationStore } from "@semiont/content";
+import { getPrimaryRepresentation, decodeRepresentation } from "@semiont/api-client";
+var ResourceContext = class {
+  /**
+   * Get resource metadata from view storage
+   */
+  static async getResourceMetadata(resourceId, config) {
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const viewStorage = new FilesystemViewStorage(basePath, projectRoot);
+    const view = await viewStorage.get(resourceId);
+    if (!view) {
+      return null;
+    }
+    return view.resource;
+  }
+  /**
+   * List all resources by scanning view storage
+   */
+  static async listResources(filters, config) {
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const viewStorage = new FilesystemViewStorage(basePath, projectRoot);
+    const allViews = await viewStorage.getAll();
+    const resources = [];
+    for (const view of allViews) {
+      const doc = view.resource;
+      if (filters?.archived !== void 0 && doc.archived !== filters.archived) {
+        continue;
+      }
+      if (filters?.search) {
+        const searchLower = filters.search.toLowerCase();
+        if (!doc.name.toLowerCase().includes(searchLower)) {
+          continue;
+        }
+      }
+      resources.push(doc);
+    }
+    resources.sort((a, b) => {
+      const aTime = a.dateCreated ? new Date(a.dateCreated).getTime() : 0;
+      const bTime = b.dateCreated ? new Date(b.dateCreated).getTime() : 0;
+      return bTime - aTime;
+    });
+    return resources;
+  }
+  /**
+   * Add content previews to resources (for search results)
+   * Retrieves and decodes the first 200 characters of each resource's primary representation
+   */
+  static async addContentPreviews(resources, config) {
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const repStore = new FilesystemRepresentationStore({ basePath }, projectRoot);
+    return await Promise.all(
+      resources.map(async (doc) => {
+        try {
+          const primaryRep = getPrimaryRepresentation(doc);
+          if (primaryRep?.checksum && primaryRep?.mediaType) {
+            const contentBuffer = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
+            const contentPreview = decodeRepresentation(contentBuffer, primaryRep.mediaType).slice(0, 200);
+            return { ...doc, content: contentPreview };
+          }
+          return { ...doc, content: "" };
+        } catch {
+          return { ...doc, content: "" };
+        }
+      })
+    );
+  }
+};
+
+// src/annotation-context.ts
+import { generateResourceSummary, generateText } from "@semiont/inference";
+import {
+  getBodySource,
+  getTargetSource,
+  getTargetSelector,
+  getResourceEntityTypes,
+  getTextPositionSelector,
+  getPrimaryRepresentation as getPrimaryRepresentation2,
+  decodeRepresentation as decodeRepresentation2
+} from "@semiont/api-client";
+import { FilesystemRepresentationStore as FilesystemRepresentationStore2 } from "@semiont/content";
+import { FilesystemViewStorage as FilesystemViewStorage2 } from "@semiont/event-sourcing";
+import { resourceId as createResourceId, uriToResourceId } from "@semiont/core";
+import { getEntityTypes } from "@semiont/ontology";
+var AnnotationContext = class {
+  /**
+   * Build LLM context for an annotation
+   *
+   * @param annotationUri - Full annotation URI (e.g., http://localhost:4000/annotations/abc123)
+   * @param resourceId - Source resource ID
+   * @param config - Application configuration
+   * @param options - Context building options
+   * @returns Rich context for LLM processing
+   * @throws Error if annotation or resource not found
+   */
+  static async buildLLMContext(annotationUri, resourceId, config, options = {}) {
+    const {
+      includeSourceContext = true,
+      includeTargetContext = true,
+      contextWindow = 1e3
+    } = options;
+    if (contextWindow < 100 || contextWindow > 5e3) {
+      throw new Error("contextWindow must be between 100 and 5000");
+    }
+    console.log(`[AnnotationContext] buildLLMContext called with annotationUri=${annotationUri}, resourceId=${resourceId}`);
+    const basePath = config.services.filesystem.path;
+    console.log(`[AnnotationContext] basePath=${basePath}`);
+    const projectRoot = config._metadata?.projectRoot;
+    const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
+    const repStore = new FilesystemRepresentationStore2({ basePath }, projectRoot);
+    console.log(`[AnnotationContext] Getting view for resourceId=${resourceId}`);
+    let sourceView;
+    try {
+      sourceView = await viewStorage.get(resourceId);
+      console.log(`[AnnotationContext] Got view:`, !!sourceView);
+      if (!sourceView) {
+        throw new Error("Source resource not found");
+      }
+    } catch (error) {
+      console.error(`[AnnotationContext] Error getting view:`, error);
+      throw error;
+    }
+    console.log(`[AnnotationContext] Looking for annotation ${annotationUri} in resource ${resourceId}`);
+    console.log(`[AnnotationContext] View has ${sourceView.annotations.annotations.length} annotations`);
+    console.log(`[AnnotationContext] First 5 annotation IDs:`, sourceView.annotations.annotations.slice(0, 5).map((a) => a.id));
+    const annotation = sourceView.annotations.annotations.find((a) => a.id === annotationUri);
+    console.log(`[AnnotationContext] Found annotation:`, !!annotation);
+    if (!annotation) {
+      throw new Error("Annotation not found in view");
+    }
+    const targetSource = getTargetSource(annotation.target);
+    const targetResourceId = targetSource.split("/").pop();
+    console.log(`[AnnotationContext] Target source: ${targetSource}, Expected resource ID: ${resourceId}, Extracted ID: ${targetResourceId}`);
+    if (targetResourceId !== resourceId) {
+      throw new Error(`Annotation target resource ID (${targetResourceId}) does not match expected resource ID (${resourceId})`);
+    }
+    const sourceDoc = sourceView.resource;
+    const bodySource = getBodySource(annotation.body);
+    let targetDoc = null;
+    if (bodySource) {
+      const parts = bodySource.split("/");
+      const lastPart = parts[parts.length - 1];
+      if (!lastPart) {
+        throw new Error(`Invalid body source URI: ${bodySource}`);
+      }
+      const targetResourceId2 = createResourceId(lastPart);
+      const targetView = await viewStorage.get(targetResourceId2);
+      targetDoc = targetView?.resource || null;
+    }
+    let sourceContext;
+    if (includeSourceContext) {
+      const primaryRep = getPrimaryRepresentation2(sourceDoc);
+      if (!primaryRep?.checksum || !primaryRep?.mediaType) {
+        throw new Error("Source content not found");
+      }
+      const sourceContent = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
+      const contentStr = decodeRepresentation2(sourceContent, primaryRep.mediaType);
+      const targetSelectorRaw = getTargetSelector(annotation.target);
+      const targetSelector = Array.isArray(targetSelectorRaw) ? targetSelectorRaw[0] : targetSelectorRaw;
+      console.log(`[AnnotationContext] Target selector type:`, targetSelector?.type);
+      if (!targetSelector) {
+        console.warn(`[AnnotationContext] No target selector found`);
+      } else if (targetSelector.type === "TextPositionSelector") {
+        const selector = targetSelector;
+        const start = selector.start;
+        const end = selector.end;
+        const before = contentStr.slice(Math.max(0, start - contextWindow), start);
+        const selected = contentStr.slice(start, end);
+        const after = contentStr.slice(end, Math.min(contentStr.length, end + contextWindow));
+        sourceContext = { before, selected, after };
+        console.log(`[AnnotationContext] Built source context using TextPositionSelector (${start}-${end})`);
+      } else if (targetSelector.type === "TextQuoteSelector") {
+        const selector = targetSelector;
+        const exact = selector.exact;
+        const index = contentStr.indexOf(exact);
+        if (index !== -1) {
+          const start = index;
+          const end = index + exact.length;
+          const before = contentStr.slice(Math.max(0, start - contextWindow), start);
+          const selected = exact;
+          const after = contentStr.slice(end, Math.min(contentStr.length, end + contextWindow));
+          sourceContext = { before, selected, after };
+          console.log(`[AnnotationContext] Built source context using TextQuoteSelector (found at ${index})`);
+        } else {
+          console.warn(`[AnnotationContext] TextQuoteSelector exact text not found in content: "${exact.substring(0, 50)}..."`);
+        }
+      } else {
+        console.warn(`[AnnotationContext] Unknown selector type: ${targetSelector.type}`);
+      }
+    }
+    let targetContext;
+    if (includeTargetContext && targetDoc) {
+      const targetRep = getPrimaryRepresentation2(targetDoc);
+      if (targetRep?.checksum && targetRep?.mediaType) {
+        const targetContent = await repStore.retrieve(targetRep.checksum, targetRep.mediaType);
+        const contentStr = decodeRepresentation2(targetContent, targetRep.mediaType);
+        targetContext = {
+          content: contentStr.slice(0, contextWindow * 2),
+          summary: await generateResourceSummary(targetDoc.name, contentStr, getResourceEntityTypes(targetDoc), config)
+        };
+      }
+    }
+    const suggestedResolution = void 0;
+    const generationContext = sourceContext ? {
+      sourceContext: {
+        before: sourceContext.before || "",
+        selected: sourceContext.selected,
+        after: sourceContext.after || ""
+      },
+      metadata: {
+        resourceType: "document",
+        language: sourceDoc.language,
+        entityTypes: getEntityTypes(annotation)
+      }
+    } : void 0;
+    const response = {
+      annotation,
+      sourceResource: sourceDoc,
+      targetResource: targetDoc,
+      ...generationContext ? { context: generationContext } : {},
+      ...sourceContext ? { sourceContext } : {},
+      // Keep for backward compatibility
+      ...targetContext ? { targetContext } : {},
+      ...suggestedResolution ? { suggestedResolution } : {}
+    };
+    return response;
+  }
+  /**
+   * Get resource annotations from view storage (fast path)
+   * Throws if view missing
+   */
+  static async getResourceAnnotations(resourceId, config) {
+    if (!config.services?.filesystem?.path) {
+      throw new Error("Filesystem path not found in configuration");
+    }
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
+    const view = await viewStorage.get(resourceId);
+    if (!view) {
+      throw new Error(`Resource ${resourceId} not found in view storage`);
+    }
+    return view.annotations;
+  }
+  /**
+   * Get all annotations
+   * @returns Array of all annotation objects
+   */
+  static async getAllAnnotations(resourceId, config) {
+    const annotations = await this.getResourceAnnotations(resourceId, config);
+    return await this.enrichResolvedReferences(annotations.annotations, config);
+  }
+  /**
+   * Enrich reference annotations with resolved document names
+   * Adds _resolvedDocumentName property to annotations that link to documents
+   * @private
+   */
+  static async enrichResolvedReferences(annotations, config) {
+    if (!config.services?.filesystem?.path) {
+      return annotations;
+    }
+    const resolvedUris = /* @__PURE__ */ new Set();
+    for (const ann of annotations) {
+      if (ann.motivation === "linking" && ann.body) {
+        const body = Array.isArray(ann.body) ? ann.body : [ann.body];
+        for (const item of body) {
+          if (item.purpose === "linking" && item.source) {
+            resolvedUris.add(item.source);
+          }
+        }
+      }
+    }
+    if (resolvedUris.size === 0) {
+      return annotations;
+    }
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
+    const metadataPromises = Array.from(resolvedUris).map(async (uri) => {
+      const docId = uri.split("/resources/")[1];
+      if (!docId) return null;
+      try {
+        const view = await viewStorage.get(docId);
+        if (view?.resource?.name) {
+          return {
+            uri,
+            metadata: {
+              name: view.resource.name,
+              mediaType: view.resource.mediaType
+            }
+          };
+        }
+      } catch (e) {
+      }
+      return null;
+    });
+    const results = await Promise.all(metadataPromises);
+    const uriToMetadata = /* @__PURE__ */ new Map();
+    for (const result of results) {
+      if (result) {
+        uriToMetadata.set(result.uri, result.metadata);
+      }
+    }
+    return annotations.map((ann) => {
+      if (ann.motivation === "linking" && ann.body) {
+        const body = Array.isArray(ann.body) ? ann.body : [ann.body];
+        for (const item of body) {
+          if (item.purpose === "linking" && item.source) {
+            const metadata = uriToMetadata.get(item.source);
+            if (metadata) {
+              return {
+                ...ann,
+                _resolvedDocumentName: metadata.name,
+                _resolvedDocumentMediaType: metadata.mediaType
+              };
+            }
+          }
+        }
+      }
+      return ann;
+    });
+  }
+  /**
+   * Get resource stats (version info)
+   * @returns Version and timestamp info for the annotations
+   */
+  static async getResourceStats(resourceId, config) {
+    const annotations = await this.getResourceAnnotations(resourceId, config);
+    return {
+      resourceId: annotations.resourceId,
+      version: annotations.version,
+      updatedAt: annotations.updatedAt
+    };
+  }
+  /**
+   * Check if resource exists in view storage
+   */
+  static async resourceExists(resourceId, config) {
+    if (!config.services?.filesystem?.path) {
+      throw new Error("Filesystem path not found in configuration");
+    }
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const viewStorage = new FilesystemViewStorage2(basePath, projectRoot);
+    return await viewStorage.exists(resourceId);
+  }
+  /**
+   * Get a single annotation by ID
+   * O(1) lookup using resource ID to access view storage
+   */
+  static async getAnnotation(annotationId, resourceId, config) {
+    const annotations = await this.getResourceAnnotations(resourceId, config);
+    return annotations.annotations.find((a) => {
+      const shortId = a.id.split("/").pop();
+      return shortId === annotationId;
+    }) || null;
+  }
+  /**
+   * List annotations with optional filtering
+   * @param filters - Optional filters like resourceId and type
+   * @throws Error if resourceId not provided (cross-resource queries not supported in view storage)
+   */
+  static async listAnnotations(filters, config) {
+    if (!filters?.resourceId) {
+      throw new Error("resourceId is required for annotation listing - cross-resource queries not supported in view storage");
+    }
+    return await this.getAllAnnotations(filters.resourceId, config);
+  }
+  /**
+   * Get annotation context (selected text with surrounding context)
+   */
+  static async getAnnotationContext(annotationId, resourceId, contextBefore, contextAfter, config) {
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const repStore = new FilesystemRepresentationStore2({ basePath }, projectRoot);
+    const annotation = await this.getAnnotation(annotationId, resourceId, config);
+    if (!annotation) {
+      throw new Error("Annotation not found");
+    }
+    const resource = await ResourceContext.getResourceMetadata(
+      uriToResourceId(getTargetSource(annotation.target)),
+      config
+    );
+    if (!resource) {
+      throw new Error("Resource not found");
+    }
+    const contentStr = await this.getResourceContent(resource, repStore);
+    const context = this.extractAnnotationContext(annotation, contentStr, contextBefore, contextAfter);
+    return {
+      annotation,
+      context,
+      resource: {
+        "@context": resource["@context"],
+        "@id": resource["@id"],
+        name: resource.name,
+        entityTypes: resource.entityTypes,
+        representations: resource.representations,
+        archived: resource.archived,
+        creationMethod: resource.creationMethod,
+        wasAttributedTo: resource.wasAttributedTo,
+        dateCreated: resource.dateCreated
+      }
+    };
+  }
+  /**
+   * Generate AI summary of annotation in context
+   */
+  static async generateAnnotationSummary(annotationId, resourceId, config) {
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const repStore = new FilesystemRepresentationStore2({ basePath }, projectRoot);
+    const annotation = await this.getAnnotation(annotationId, resourceId, config);
+    if (!annotation) {
+      throw new Error("Annotation not found");
+    }
+    const resource = await ResourceContext.getResourceMetadata(
+      uriToResourceId(getTargetSource(annotation.target)),
+      config
+    );
+    if (!resource) {
+      throw new Error("Resource not found");
+    }
+    const contentStr = await this.getResourceContent(resource, repStore);
+    const contextSize = 500;
+    const context = this.extractAnnotationContext(annotation, contentStr, contextSize, contextSize);
+    const annotationEntityTypes = getEntityTypes(annotation);
+    const summary = await this.generateSummary(resource, context, annotationEntityTypes, config);
+    return {
+      summary,
+      relevantFields: {
+        resourceId: resource.id,
+        resourceName: resource.name,
+        entityTypes: annotationEntityTypes
+      },
+      context: {
+        before: context.before.substring(Math.max(0, context.before.length - 200)),
+        // Last 200 chars
+        selected: context.selected,
+        after: context.after.substring(0, 200)
+        // First 200 chars
+      }
+    };
+  }
+  /**
+   * Get resource content as string
+   */
+  static async getResourceContent(resource, repStore) {
+    const primaryRep = getPrimaryRepresentation2(resource);
+    if (!primaryRep?.checksum || !primaryRep?.mediaType) {
+      throw new Error("Resource content not found");
+    }
+    const content = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
+    return decodeRepresentation2(content, primaryRep.mediaType);
+  }
+  /**
+   * Extract annotation context from resource content
+   */
+  static extractAnnotationContext(annotation, contentStr, contextBefore, contextAfter) {
+    const targetSelector = getTargetSelector(annotation.target);
+    const posSelector = targetSelector ? getTextPositionSelector(targetSelector) : null;
+    if (!posSelector) {
+      throw new Error("TextPositionSelector required for context");
+    }
+    const selStart = posSelector.start;
+    const selEnd = posSelector.end;
+    const start = Math.max(0, selStart - contextBefore);
+    const end = Math.min(contentStr.length, selEnd + contextAfter);
+    return {
+      before: contentStr.substring(start, selStart),
+      selected: contentStr.substring(selStart, selEnd),
+      after: contentStr.substring(selEnd, end)
+    };
+  }
+  /**
+   * Generate LLM summary of annotation in context
+   */
+  static async generateSummary(resource, context, entityTypes, config) {
+    const summaryPrompt = `Summarize this text in context:
+
+Context before: "${context.before.substring(Math.max(0, context.before.length - 200))}"
+Selected exact: "${context.selected}"
+Context after: "${context.after.substring(0, 200)}"
+
+Resource: ${resource.name}
+Entity types: ${entityTypes.join(", ")}`;
+    return await generateText(summaryPrompt, config, 500, 0.5);
+  }
+};
+
+// src/graph-context.ts
+import { getGraphDatabase } from "@semiont/graph";
+import { resourceIdToURI } from "@semiont/core";
+var GraphContext = class {
+  /**
+   * Get all resources referencing this resource (backlinks)
+   * Requires graph traversal - must use graph database
+   */
+  static async getBacklinks(resourceId, config) {
+    const graphDb = await getGraphDatabase(config);
+    const resourceUri = resourceIdToURI(resourceId, config.services.backend.publicURL);
+    return await graphDb.getResourceReferencedBy(resourceUri);
+  }
+  /**
+   * Find shortest path between two resources
+   * Requires graph traversal - must use graph database
+   */
+  static async findPath(fromResourceId, toResourceId, config, maxDepth) {
+    const graphDb = await getGraphDatabase(config);
+    return await graphDb.findPath(fromResourceId, toResourceId, maxDepth);
+  }
+  /**
+   * Get resource connections (graph edges)
+   * Requires graph traversal - must use graph database
+   */
+  static async getResourceConnections(resourceId, config) {
+    const graphDb = await getGraphDatabase(config);
+    return await graphDb.getResourceConnections(resourceId);
+  }
+  /**
+   * Search resources by name (cross-resource query)
+   * Requires full-text search - must use graph database
+   */
+  static async searchResources(query, config, limit) {
+    const graphDb = await getGraphDatabase(config);
+    return await graphDb.searchResources(query, limit);
+  }
+};
+
+// src/annotation-detection.ts
+import { FilesystemRepresentationStore as FilesystemRepresentationStore3 } from "@semiont/content";
+import { getPrimaryRepresentation as getPrimaryRepresentation3, decodeRepresentation as decodeRepresentation3 } from "@semiont/api-client";
+import {
+  MotivationPrompts,
+  MotivationParsers,
+  generateText as generateText2
+} from "@semiont/inference";
+import { getTagSchema, getSchemaCategory } from "@semiont/ontology";
+var AnnotationDetection = class {
+  /**
+   * Detect comments in a resource
+   *
+   * @param resourceId - The resource to analyze
+   * @param config - Environment configuration
+   * @param instructions - Optional user instructions for comment generation
+   * @param tone - Optional tone guidance (e.g., "academic", "conversational")
+   * @param density - Optional target number of comments per 2000 words
+   * @returns Array of validated comment matches
+   */
+  static async detectComments(resourceId, config, instructions, tone, density) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId, config);
+    if (!resource) {
+      throw new Error(`Resource ${resourceId} not found`);
+    }
+    const content = await this.loadResourceContent(resourceId, config);
+    if (!content) {
+      throw new Error(`Could not load content for resource ${resourceId}`);
+    }
+    const prompt = MotivationPrompts.buildCommentPrompt(content, instructions, tone, density);
+    const response = await generateText2(
+      prompt,
+      config,
+      3e3,
+      // maxTokens: Higher than highlights/assessments due to comment text
+      0.4
+      // temperature: Slightly higher to allow creative context
+    );
+    return MotivationParsers.parseComments(response, content);
+  }
+  /**
+   * Detect highlights in a resource
+   *
+   * @param resourceId - The resource to analyze
+   * @param config - Environment configuration
+   * @param instructions - Optional user instructions for highlight selection
+   * @param density - Optional target number of highlights per 2000 words
+   * @returns Array of validated highlight matches
+   */
+  static async detectHighlights(resourceId, config, instructions, density) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId, config);
+    if (!resource) {
+      throw new Error(`Resource ${resourceId} not found`);
+    }
+    const content = await this.loadResourceContent(resourceId, config);
+    if (!content) {
+      throw new Error(`Could not load content for resource ${resourceId}`);
+    }
+    const prompt = MotivationPrompts.buildHighlightPrompt(content, instructions, density);
+    const response = await generateText2(
+      prompt,
+      config,
+      2e3,
+      // maxTokens: Lower than comments/assessments (no body text)
+      0.3
+      // temperature: Low for consistent importance judgments
+    );
+    return MotivationParsers.parseHighlights(response, content);
+  }
+  /**
+   * Detect assessments in a resource
+   *
+   * @param resourceId - The resource to analyze
+   * @param config - Environment configuration
+   * @param instructions - Optional user instructions for assessment generation
+   * @param tone - Optional tone guidance (e.g., "critical", "supportive")
+   * @param density - Optional target number of assessments per 2000 words
+   * @returns Array of validated assessment matches
+   */
+  static async detectAssessments(resourceId, config, instructions, tone, density) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId, config);
+    if (!resource) {
+      throw new Error(`Resource ${resourceId} not found`);
+    }
+    const content = await this.loadResourceContent(resourceId, config);
+    if (!content) {
+      throw new Error(`Could not load content for resource ${resourceId}`);
+    }
+    const prompt = MotivationPrompts.buildAssessmentPrompt(content, instructions, tone, density);
+    const response = await generateText2(
+      prompt,
+      config,
+      3e3,
+      // maxTokens: Higher for assessment text
+      0.3
+      // temperature: Lower for analytical consistency
+    );
+    return MotivationParsers.parseAssessments(response, content);
+  }
+  /**
+   * Detect tags in a resource for a specific category
+   *
+   * @param resourceId - The resource to analyze
+   * @param config - Environment configuration
+   * @param schemaId - The tag schema identifier (e.g., "irac", "imrad")
+   * @param category - The specific category to detect
+   * @returns Array of validated tag matches
+   */
+  static async detectTags(resourceId, config, schemaId, category) {
+    const schema = getTagSchema(schemaId);
+    if (!schema) {
+      throw new Error(`Invalid tag schema: ${schemaId}`);
+    }
+    const categoryInfo = getSchemaCategory(schemaId, category);
+    if (!categoryInfo) {
+      throw new Error(`Invalid category "${category}" for schema ${schemaId}`);
+    }
+    const resource = await ResourceContext.getResourceMetadata(resourceId, config);
+    if (!resource) {
+      throw new Error(`Resource ${resourceId} not found`);
+    }
+    const content = await this.loadResourceContent(resourceId, config);
+    if (!content) {
+      throw new Error(`Could not load content for resource ${resourceId}`);
+    }
+    const prompt = MotivationPrompts.buildTagPrompt(
+      content,
+      category,
+      schema.name,
+      schema.description,
+      schema.domain,
+      categoryInfo.description,
+      categoryInfo.examples
+    );
+    const response = await generateText2(
+      prompt,
+      config,
+      4e3,
+      // maxTokens: Higher for full document analysis
+      0.2
+      // temperature: Lower for structural consistency
+    );
+    const parsedTags = MotivationParsers.parseTags(response);
+    return MotivationParsers.validateTagOffsets(parsedTags, content, category);
+  }
+  /**
+   * Load resource content from representation store
+   * Helper method used by all detection methods
+   *
+   * @param resourceId - The resource ID to load
+   * @param config - Environment configuration
+   * @returns Resource content as string, or null if not available
+   */
+  static async loadResourceContent(resourceId, config) {
+    const resource = await ResourceContext.getResourceMetadata(resourceId, config);
+    if (!resource) return null;
+    const primaryRep = getPrimaryRepresentation3(resource);
+    if (!primaryRep) return null;
+    const baseMediaType = primaryRep.mediaType?.split(";")[0]?.trim() || "";
+    if (baseMediaType !== "text/plain" && baseMediaType !== "text/markdown") {
+      return null;
+    }
+    if (!primaryRep.checksum || !primaryRep.mediaType) return null;
+    const basePath = config.services.filesystem.path;
+    const projectRoot = config._metadata?.projectRoot;
+    const repStore = new FilesystemRepresentationStore3({ basePath }, projectRoot);
+    const contentBuffer = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
+    return decodeRepresentation3(contentBuffer, primaryRep.mediaType);
+  }
+};
+
+// src/index.ts
+var PACKAGE_NAME = "@semiont/make-meaning";
+var VERSION = "0.1.0";
+export {
+  AnnotationContext,
+  AnnotationDetection,
+  GraphContext,
+  PACKAGE_NAME,
+  ResourceContext,
+  VERSION
+};
+//# sourceMappingURL=index.js.map