@semiont/ontology 0.2.28-build.40

package/README.md

@@ -0,0 +1,198 @@
+# @semiont/ontology
+
+[![npm version](https://img.shields.io/npm/v/@semiont/ontology)](https://www.npmjs.com/package/@semiont/ontology)
+[![Tests](https://github.com/The-AI-Alliance/semiont/actions/workflows/package-tests.yml/badge.svg)](https://github.com/The-AI-Alliance/semiont/actions/workflows/package-tests.yml?query=branch%3Amain+is%3Asuccess+job%3A%22Test+ontology%22)
+
+Entity types, tag schemas, and tag extraction utilities for the Semiont annotation system.
+
+## Overview
+
+This package consolidates ontology-related code that was previously scattered across the codebase:
+- **Entity types**: Semantic categories for tagging resources and annotations (Person, Organization, Location, etc.)
+- **Tag schemas**: Structural analysis frameworks (IRAC for legal, IMRAD for scientific, Toulmin for argumentation)
+- **Tag extraction**: Utilities for extracting tag information from W3C annotations
+
+## Installation
+
+```bash
+npm install @semiont/ontology
+```
+
+## Usage
+
+### Entity Types
+
+Default entity types used throughout the system:
+
+```typescript
+import { DEFAULT_ENTITY_TYPES } from '@semiont/ontology';
+
+console.log(DEFAULT_ENTITY_TYPES);
+// ['Person', 'Organization', 'Location', 'Event', 'Concept',
+//  'Product', 'Technology', 'Date', 'Author']
+```
+
+### Tag Schemas
+
+Three built-in tag schemas for structural document analysis:
+
+```typescript
+import {
+  TAG_SCHEMAS,
+  getTagSchema,
+  getAllTagSchemas,
+  getTagSchemasByDomain
+} from '@semiont/ontology';
+
+// Get a specific schema
+const iracSchema = getTagSchema('legal-irac');
+// Returns: { id: 'legal-irac', name: 'Legal Analysis (IRAC)',
+//           domain: 'legal', tags: [...] }
+
+// Get all schemas
+const allSchemas = getAllTagSchemas();
+// Returns array of all 3 schemas
+
+// Get schemas by domain
+const legalSchemas = getTagSchemasByDomain('legal');
+// Returns schemas where domain === 'legal'
+```
+
+Available schemas (from [src/tag-schemas.ts](src/tag-schemas.ts)):
+- `legal-irac`: Legal Analysis (IRAC) - Issue, Rule, Application, Conclusion
+- `scientific-imrad`: Scientific Paper (IMRAD) - Introduction, Methods, Results, Discussion
+- `argument-toulmin`: Argument Structure (Toulmin) - Claim, Evidence, Warrant, Counterargument, Rebuttal
+
+### Entity Extraction
+
+Extract entity types from annotation bodies:
+
+```typescript
+import { getEntityTypes } from '@semiont/ontology';
+import type { components } from '@semiont/api-client';
+
+type Annotation = components['schemas']['Annotation'];
+
+const annotation: Annotation = {
+  motivation: 'linking',
+  body: [
+    { type: 'TextualBody', purpose: 'tagging', value: 'Person' },
+    { type: 'TextualBody', purpose: 'tagging', value: 'Organization' },
+    { type: 'SpecificResource', source: 'resource://abc123' }
+  ],
+  target: 'resource://xyz789'
+};
+
+const entityTypes = getEntityTypes(annotation);
+// Returns: ['Person', 'Organization']
+```
+
+From [src/entity-extraction.ts](src/entity-extraction.ts): Extracts values from `TextualBody` items where `purpose === 'tagging'`.
+
+### Tag Extraction
+
+Extract tag categories and schema IDs from tag annotations:
+
+```typescript
+import { getTagCategory, getTagSchemaId } from '@semiont/ontology';
+
+const tagAnnotation = {
+  motivation: 'tagging',
+  body: [
+    { type: 'TextualBody', purpose: 'tagging', value: 'Issue' },
+    { type: 'TextualBody', purpose: 'classifying', value: 'legal-irac' }
+  ],
+  target: { source: 'resource://doc123', selector: { /* ... */ } }
+};
+
+const category = getTagCategory(tagAnnotation);
+// Returns: 'Issue'
+
+const schemaId = getTagSchemaId(tagAnnotation);
+// Returns: 'legal-irac'
+```
+
+From [src/tag-extraction.ts](src/tag-extraction.ts): Tag annotations use dual-body structure with `purpose: 'tagging'` for category and `purpose: 'classifying'` for schema ID.
+
+### Tag Schema Helpers
+
+```typescript
+import { isValidCategory, getSchemaCategory } from '@semiont/ontology';
+
+// Check if a category exists in a schema
+const isValid = isValidCategory('legal-irac', 'Issue');
+// Returns: true
+
+const invalid = isValidCategory('legal-irac', 'Conclusion');
+// Returns: true (all 4 IRAC categories are valid)
+
+const notValid = isValidCategory('legal-irac', 'Introduction');
+// Returns: false (Introduction is IMRAD, not IRAC)
+
+// Get category details
+const category = getSchemaCategory('legal-irac', 'Rule');
+// Returns: {
+//   name: 'Rule',
+//   description: 'The relevant law, statute, or legal principle',
+//   examples: ['What law applies?', 'What is the legal standard?', ...]
+// }
+```
+
+## Tag Collections
+
+Type definitions for graph database tag collection operations:
+
+```typescript
+import type { TagCollection, TagCollectionOperations } from '@semiont/ontology';
+
+// TagCollection interface for stored collections
+interface TagCollection {
+  id: string;
+  collectionType: 'entity-types';
+  tags: string[];
+  created: Date;
+  updatedAt: Date;
+}
+
+// TagCollectionOperations interface for graph database implementations
+interface TagCollectionOperations {
+  getEntityTypes(): Promise<string[]>;
+  addEntityType(tag: string): Promise<void>;
+  addEntityTypes(tags: string[]): Promise<void>;
+  hasEntityTypesCollection(): Promise<boolean>;
+  initializeCollections(): Promise<void>;
+}
+```
+
+From [src/tag-collections.ts](src/tag-collections.ts): Interfaces for managing entity type collections in graph databases.
+
+## Dependencies
+
+- `@semiont/api-client`: For W3C annotation type definitions
+
+## Package Structure
+
+```
+packages/ontology/
+├── src/
+│   ├── index.ts                # Public API exports
+│   ├── entity-types.ts         # DEFAULT_ENTITY_TYPES
+│   ├── tag-collections.ts      # TagCollection interfaces
+│   ├── tag-schemas.ts          # TAG_SCHEMAS registry
+│   ├── entity-extraction.ts    # getEntityTypes utility
+│   ├── tag-extraction.ts       # getTagCategory, getTagSchemaId
+│   └── bootstrap.ts            # Re-export note (actual bootstrap in backend)
+├── package.json
+├── tsconfig.json
+├── tsup.config.ts
+└── README.md
+```
+
+## Notes
+
+- **Bootstrap service**: The entity types bootstrap logic remains in `apps/backend/src/bootstrap/entity-types-bootstrap.ts` to avoid circular dependency with `@semiont/core`.
+- **Annotation type guards**: Type guards like `isHighlight()`, `isReference()`, etc. remain in `@semiont/api-client` as the OpenAPI spec is the source of truth for W3C motivations.
+
+## License
+
+Apache-2.0

package/dist/index.d.ts

@@ -0,0 +1,132 @@
+import { components } from '@semiont/api-client';
+
+/**
+ * Default entity types for the Semiont system
+ *
+ * Entity types are used to tag resources and annotations with semantic categories.
+ * These types serve as initial seed data for the entity types collection.
+ */
+declare const DEFAULT_ENTITY_TYPES: string[];
+
+/**
+ * Tag Collections Management
+ *
+ * Stores entity types in the graph database as append-only collections.
+ * Provides interface for graph database implementations to manage entity type collections.
+ */
+interface TagCollection {
+    id: string;
+    collectionType: 'entity-types';
+    tags: string[];
+    created: Date;
+    updatedAt: Date;
+}
+interface TagCollectionOperations {
+    /**
+     * Get or create collections with auto-seeding
+     */
+    getEntityTypes(): Promise<string[]>;
+    /**
+     * Append new tag (no duplicates)
+     */
+    addEntityType(tag: string): Promise<void>;
+    /**
+     * Bulk append tags
+     */
+    addEntityTypes(tags: string[]): Promise<void>;
+    /**
+     * Check if collections exist
+     */
+    hasEntityTypesCollection(): Promise<boolean>;
+    /**
+     * Initialize collections with seed data if they don't exist
+     */
+    initializeCollections(): Promise<void>;
+}
+
+/**
+ * Tag Schema Registry
+ *
+ * Defines structural analysis frameworks for automatic tagging detection.
+ * Each schema provides categories that passages can be classified into
+ * based on their structural role (not their semantic content).
+ *
+ * Examples: IRAC (legal), IMRAD (scientific), Toulmin (argumentation)
+ */
+interface TagCategory {
+    name: string;
+    description: string;
+    examples: string[];
+}
+interface TagSchema {
+    id: string;
+    name: string;
+    description: string;
+    domain: 'legal' | 'scientific' | 'general';
+    tags: TagCategory[];
+}
+declare const TAG_SCHEMAS: Record<string, TagSchema>;
+/**
+ * Get a tag schema by ID
+ */
+declare function getTagSchema(schemaId: string): TagSchema | null;
+/**
+ * Get all available tag schemas
+ */
+declare function getAllTagSchemas(): TagSchema[];
+/**
+ * Get tag schemas filtered by domain
+ */
+declare function getTagSchemasByDomain(domain: 'legal' | 'scientific' | 'general'): TagSchema[];
+/**
+ * Validate that a category name is valid for a schema
+ */
+declare function isValidCategory(schemaId: string, categoryName: string): boolean;
+/**
+ * Get a specific category from a schema
+ */
+declare function getSchemaCategory(schemaId: string, categoryName: string): TagCategory | null;
+
+/**
+ * Entity Type Extraction Utilities
+ *
+ * Extract entity types from annotation bodies.
+ * Entity types are stored as TextualBody with purpose: "tagging"
+ */
+
+type Annotation$1 = components['schemas']['Annotation'];
+/**
+ * Extract entity types from annotation bodies
+ * Entity types are stored as TextualBody with purpose: "tagging"
+ * Accepts any object with a body property matching Annotation['body']
+ */
+declare function getEntityTypes(annotation: {
+    body: Annotation$1['body'];
+}): string[];
+
+/**
+ * Tag Schema Extraction Utilities
+ *
+ * Extract tag categories and schema IDs from tag annotations.
+ * Tags use dual-body structure:
+ * - First body has purpose: "tagging" with category value
+ * - Second body has purpose: "classifying" with schema ID
+ */
+
+type Annotation = components['schemas']['Annotation'];
+/**
+ * Extract tag category from a tag annotation's body
+ * Tags use dual-body structure: first body has purpose: "tagging" with category value
+ * @param annotation - The annotation to extract category from
+ * @returns The tag category (e.g., "Issue", "Rule"), or undefined if not a tag or no category found
+ */
+declare function getTagCategory(annotation: Annotation): string | undefined;
+/**
+ * Extract tag schema ID from a tag annotation's body
+ * Tags use dual-body structure: second body has purpose: "classifying" with schema ID
+ * @param annotation - The annotation to extract schema ID from
+ * @returns The schema ID (e.g., "legal-irac"), or undefined if not a tag or no schema found
+ */
+declare function getTagSchemaId(annotation: Annotation): string | undefined;
+
+export { DEFAULT_ENTITY_TYPES, TAG_SCHEMAS, type TagCategory, type TagCollection, type TagCollectionOperations, type TagSchema, getAllTagSchemas, getEntityTypes, getSchemaCategory, getTagCategory, getTagSchema, getTagSchemaId, getTagSchemasByDomain, isValidCategory };

package/dist/index.js

@@ -0,0 +1,231 @@
+// src/entity-types.ts
+var DEFAULT_ENTITY_TYPES = [
+  "Person",
+  "Organization",
+  "Location",
+  "Event",
+  "Concept",
+  "Product",
+  "Technology",
+  "Date",
+  "Author"
+];
+
+// src/tag-schemas.ts
+var TAG_SCHEMAS = {
+  "legal-irac": {
+    id: "legal-irac",
+    name: "Legal Analysis (IRAC)",
+    description: "Issue, Rule, Application, Conclusion framework for legal reasoning",
+    domain: "legal",
+    tags: [
+      {
+        name: "Issue",
+        description: "The legal question or problem to be resolved",
+        examples: [
+          "What is the central legal question?",
+          "What must the court decide?",
+          "What is the dispute about?"
+        ]
+      },
+      {
+        name: "Rule",
+        description: "The relevant law, statute, or legal principle",
+        examples: [
+          "What law applies?",
+          "What is the legal standard?",
+          "What statute governs this case?"
+        ]
+      },
+      {
+        name: "Application",
+        description: "How the rule applies to the specific facts",
+        examples: [
+          "How does the law apply to these facts?",
+          "Analysis of the case",
+          "How do the facts satisfy the legal standard?"
+        ]
+      },
+      {
+        name: "Conclusion",
+        description: "The resolution or outcome based on the analysis",
+        examples: [
+          "What is the court's decision?",
+          "What is the final judgment?",
+          "What is the holding?"
+        ]
+      }
+    ]
+  },
+  "scientific-imrad": {
+    id: "scientific-imrad",
+    name: "Scientific Paper (IMRAD)",
+    description: "Introduction, Methods, Results, Discussion structure for research papers",
+    domain: "scientific",
+    tags: [
+      {
+        name: "Introduction",
+        description: "Background, context, and research question",
+        examples: [
+          "What is the research question?",
+          "Why is this important?",
+          "What is the hypothesis?"
+        ]
+      },
+      {
+        name: "Methods",
+        description: "Experimental design and procedures",
+        examples: [
+          "How was the study conducted?",
+          "What methods were used?",
+          "What was the experimental design?"
+        ]
+      },
+      {
+        name: "Results",
+        description: "Findings and observations",
+        examples: [
+          "What did the study find?",
+          "What are the data?",
+          "What were the observations?"
+        ]
+      },
+      {
+        name: "Discussion",
+        description: "Interpretation and implications of results",
+        examples: [
+          "What do the results mean?",
+          "What are the implications?",
+          "How do these findings relate to prior work?"
+        ]
+      }
+    ]
+  },
+  "argument-toulmin": {
+    id: "argument-toulmin",
+    name: "Argument Structure (Toulmin)",
+    description: "Claim, Evidence, Warrant, Counterargument, Rebuttal framework for argumentation",
+    domain: "general",
+    tags: [
+      {
+        name: "Claim",
+        description: "The main assertion or thesis",
+        examples: [
+          "What is being argued?",
+          "What is the main point?",
+          "What position is being taken?"
+        ]
+      },
+      {
+        name: "Evidence",
+        description: "Data or facts supporting the claim",
+        examples: [
+          "What supports this claim?",
+          "What are the facts?",
+          "What data is provided?"
+        ]
+      },
+      {
+        name: "Warrant",
+        description: "Reasoning connecting evidence to claim",
+        examples: [
+          "Why does this evidence support the claim?",
+          "What is the logic?",
+          "How does this reasoning work?"
+        ]
+      },
+      {
+        name: "Counterargument",
+        description: "Opposing viewpoints or objections",
+        examples: [
+          "What are the objections?",
+          "What do critics say?",
+          "What are alternative views?"
+        ]
+      },
+      {
+        name: "Rebuttal",
+        description: "Response to counterarguments",
+        examples: [
+          "How is the objection addressed?",
+          "Why is the counterargument wrong?",
+          "How is the criticism answered?"
+        ]
+      }
+    ]
+  }
+};
+function getTagSchema(schemaId) {
+  return TAG_SCHEMAS[schemaId] || null;
+}
+function getAllTagSchemas() {
+  return Object.values(TAG_SCHEMAS);
+}
+function getTagSchemasByDomain(domain) {
+  return Object.values(TAG_SCHEMAS).filter((schema) => schema.domain === domain);
+}
+function isValidCategory(schemaId, categoryName) {
+  const schema = getTagSchema(schemaId);
+  if (!schema) return false;
+  return schema.tags.some((tag) => tag.name === categoryName);
+}
+function getSchemaCategory(schemaId, categoryName) {
+  const schema = getTagSchema(schemaId);
+  if (!schema) return null;
+  return schema.tags.find((tag) => tag.name === categoryName) || null;
+}
+
+// src/entity-extraction.ts
+function getEntityTypes(annotation) {
+  if (Array.isArray(annotation.body)) {
+    const entityTags = [];
+    for (const item of annotation.body) {
+      if (typeof item === "object" && item !== null && "type" in item && "value" in item && "purpose" in item) {
+        const itemType = item.type;
+        const itemValue = item.value;
+        const itemPurpose = item.purpose;
+        if (itemType === "TextualBody" && itemPurpose === "tagging" && typeof itemValue === "string" && itemValue.length > 0) {
+          entityTags.push(itemValue);
+        }
+      }
+    }
+    return entityTags;
+  }
+  return [];
+}
+
+// src/tag-extraction.ts
+function isTag(annotation) {
+  return annotation.motivation === "tagging";
+}
+function getTagCategory(annotation) {
+  if (!isTag(annotation)) return void 0;
+  const bodies = Array.isArray(annotation.body) ? annotation.body : [annotation.body];
+  const taggingBody = bodies.find((b) => b && "purpose" in b && b.purpose === "tagging");
+  if (taggingBody && "value" in taggingBody) {
+    return taggingBody.value;
+  }
+  return void 0;
+}
+function getTagSchemaId(annotation) {
+  if (!isTag(annotation)) return void 0;
+  const bodies = Array.isArray(annotation.body) ? annotation.body : [annotation.body];
+  const classifyingBody = bodies.find((b) => b && "purpose" in b && b.purpose === "classifying");
+  if (classifyingBody && "value" in classifyingBody) {
+    return classifyingBody.value;
+  }
+  return void 0;
+}
+export {
+  DEFAULT_ENTITY_TYPES,
+  TAG_SCHEMAS,
+  getAllTagSchemas,
+  getEntityTypes,
+  getSchemaCategory,
+  getTagCategory,
+  getTagSchema,
+  getTagSchemaId,
+  getTagSchemasByDomain,
+  isValidCategory
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/entity-types.ts","../src/tag-schemas.ts","../src/entity-extraction.ts","../src/tag-extraction.ts"],"sourcesContent":["/**\n * Default entity types for the Semiont system\n *\n * Entity types are used to tag resources and annotations with semantic categories.\n * These types serve as initial seed data for the entity types collection.\n */\nexport const DEFAULT_ENTITY_TYPES = [\n  'Person',\n  'Organization',\n  'Location',\n  'Event',\n  'Concept',\n  'Product',\n  'Technology',\n  'Date',\n  'Author'\n];\n","/**\n * Tag Schema Registry\n *\n * Defines structural analysis frameworks for automatic tagging detection.\n * Each schema provides categories that passages can be classified into\n * based on their structural role (not their semantic content).\n *\n * Examples: IRAC (legal), IMRAD (scientific), Toulmin (argumentation)\n */\n\nexport interface TagCategory {\n  name: string;\n  description: string;\n  examples: string[];\n}\n\nexport interface TagSchema {\n  id: string;\n  name: string;\n  description: string;\n  domain: 'legal' | 'scientific' | 'general';\n  tags: TagCategory[];\n}\n\nexport const TAG_SCHEMAS: Record<string, TagSchema> = {\n  'legal-irac': {\n    id: 'legal-irac',\n    name: 'Legal Analysis (IRAC)',\n    description: 'Issue, Rule, Application, Conclusion framework for legal reasoning',\n    domain: 'legal',\n    tags: [\n      {\n        name: 'Issue',\n        description: 'The legal question or problem to be resolved',\n        examples: [\n          'What is the central legal question?',\n          'What must the court decide?',\n          'What is the dispute about?'\n        ]\n      },\n      {\n        name: 'Rule',\n        description: 'The relevant law, statute, or legal principle',\n        examples: [\n          'What law applies?',\n          'What is the legal standard?',\n          'What statute governs this case?'\n        ]\n      },\n      {\n        name: 'Application',\n        description: 'How the rule applies to the specific facts',\n        examples: [\n          'How does the law apply to these facts?',\n          'Analysis of the case',\n          'How do the facts satisfy the legal standard?'\n        ]\n      },\n      {\n        name: 'Conclusion',\n        description: 'The resolution or outcome based on the analysis',\n        examples: [\n          'What is the court\\'s decision?',\n          'What is the final judgment?',\n          'What is the holding?'\n        ]\n      }\n    ]\n  },\n\n  'scientific-imrad': {\n    id: 'scientific-imrad',\n    name: 'Scientific Paper (IMRAD)',\n    description: 'Introduction, Methods, Results, Discussion structure for research papers',\n    domain: 'scientific',\n    tags: [\n      {\n        name: 'Introduction',\n        description: 'Background, context, and research question',\n        examples: [\n          'What is the research question?',\n          'Why is this important?',\n          'What is the hypothesis?'\n        ]\n      },\n      {\n        name: 'Methods',\n        description: 'Experimental design and procedures',\n        examples: [\n          'How was the study conducted?',\n          'What methods were used?',\n          'What was the experimental design?'\n        ]\n      },\n      {\n        name: 'Results',\n        description: 'Findings and observations',\n        examples: [\n          'What did the study find?',\n          'What are the data?',\n          'What were the observations?'\n        ]\n      },\n      {\n        name: 'Discussion',\n        description: 'Interpretation and implications of results',\n        examples: [\n          'What do the results mean?',\n          'What are the implications?',\n          'How do these findings relate to prior work?'\n        ]\n      }\n    ]\n  },\n\n  'argument-toulmin': {\n    id: 'argument-toulmin',\n    name: 'Argument Structure (Toulmin)',\n    description: 'Claim, Evidence, Warrant, Counterargument, Rebuttal framework for argumentation',\n    domain: 'general',\n    tags: [\n      {\n        name: 'Claim',\n        description: 'The main assertion or thesis',\n        examples: [\n          'What is being argued?',\n          'What is the main point?',\n          'What position is being taken?'\n        ]\n      },\n      {\n        name: 'Evidence',\n        description: 'Data or facts supporting the claim',\n        examples: [\n          'What supports this claim?',\n          'What are the facts?',\n          'What data is provided?'\n        ]\n      },\n      {\n        name: 'Warrant',\n        description: 'Reasoning connecting evidence to claim',\n        examples: [\n          'Why does this evidence support the claim?',\n          'What is the logic?',\n          'How does this reasoning work?'\n        ]\n      },\n      {\n        name: 'Counterargument',\n        description: 'Opposing viewpoints or objections',\n        examples: [\n          'What are the objections?',\n          'What do critics say?',\n          'What are alternative views?'\n        ]\n      },\n      {\n        name: 'Rebuttal',\n        description: 'Response to counterarguments',\n        examples: [\n          'How is the objection addressed?',\n          'Why is the counterargument wrong?',\n          'How is the criticism answered?'\n        ]\n      }\n    ]\n  }\n};\n\n/**\n * Get a tag schema by ID\n */\nexport function getTagSchema(schemaId: string): TagSchema | null {\n  return TAG_SCHEMAS[schemaId] || null;\n}\n\n/**\n * Get all available tag schemas\n */\nexport function getAllTagSchemas(): TagSchema[] {\n  return Object.values(TAG_SCHEMAS);\n}\n\n/**\n * Get tag schemas filtered by domain\n */\nexport function getTagSchemasByDomain(domain: 'legal' | 'scientific' | 'general'): TagSchema[] {\n  return Object.values(TAG_SCHEMAS).filter(schema => schema.domain === domain);\n}\n\n/**\n * Validate that a category name is valid for a schema\n */\nexport function isValidCategory(schemaId: string, categoryName: string): boolean {\n  const schema = getTagSchema(schemaId);\n  if (!schema) return false;\n  return schema.tags.some(tag => tag.name === categoryName);\n}\n\n/**\n * Get a specific category from a schema\n */\nexport function getSchemaCategory(schemaId: string, categoryName: string): TagCategory | null {\n  const schema = getTagSchema(schemaId);\n  if (!schema) return null;\n  return schema.tags.find(tag => tag.name === categoryName) || null;\n}\n","/**\n * Entity Type Extraction Utilities\n *\n * Extract entity types from annotation bodies.\n * Entity types are stored as TextualBody with purpose: \"tagging\"\n */\n\nimport type { components } from '@semiont/api-client';\n\ntype Annotation = components['schemas']['Annotation'];\n\n/**\n * Extract entity types from annotation bodies\n * Entity types are stored as TextualBody with purpose: \"tagging\"\n * Accepts any object with a body property matching Annotation['body']\n */\nexport function getEntityTypes(annotation: { body: Annotation['body'] }): string[] {\n  // Extract from TextualBody bodies with purpose: \"tagging\"\n  if (Array.isArray(annotation.body)) {\n    const entityTags: string[] = [];\n\n    for (const item of annotation.body) {\n      // Runtime check for TextualBody with tagging purpose\n      // TypeScript incorrectly narrows the union type here, so we use runtime checks only\n      if (\n        typeof item === 'object' &&\n        item !== null &&\n        'type' in item &&\n        'value' in item &&\n        'purpose' in item\n      ) {\n        // Access properties as unknown first to avoid TypeScript narrowing issues\n        const itemType = (item as { type: unknown }).type;\n        const itemValue = (item as { value: unknown }).value;\n        const itemPurpose = (item as { purpose: unknown }).purpose;\n\n        if (itemType === 'TextualBody' && itemPurpose === 'tagging' && typeof itemValue === 'string' && itemValue.length > 0) {\n          entityTags.push(itemValue);\n        }\n      }\n    }\n\n    return entityTags;\n  }\n\n  return [];\n}\n","/**\n * Tag Schema Extraction Utilities\n *\n * Extract tag categories and schema IDs from tag annotations.\n * Tags use dual-body structure:\n * - First body has purpose: \"tagging\" with category value\n * - Second body has purpose: \"classifying\" with schema ID\n */\n\nimport type { components } from '@semiont/api-client';\n\ntype Annotation = components['schemas']['Annotation'];\n\n/**\n * Type guard to check if an annotation is a tag\n */\nfunction isTag(annotation: Annotation): boolean {\n  return annotation.motivation === 'tagging';\n}\n\n/**\n * Extract tag category from a tag annotation's body\n * Tags use dual-body structure: first body has purpose: \"tagging\" with category value\n * @param annotation - The annotation to extract category from\n * @returns The tag category (e.g., \"Issue\", \"Rule\"), or undefined if not a tag or no category found\n */\nexport function getTagCategory(annotation: Annotation): string | undefined {\n  if (!isTag(annotation)) return undefined;\n  const bodies = Array.isArray(annotation.body) ? annotation.body : [annotation.body];\n  const taggingBody = bodies.find(b => b && 'purpose' in b && b.purpose === 'tagging');\n  if (taggingBody && 'value' in taggingBody) {\n    return taggingBody.value;\n  }\n  return undefined;\n}\n\n/**\n * Extract tag schema ID from a tag annotation's body\n * Tags use dual-body structure: second body has purpose: \"classifying\" with schema ID\n * @param annotation - The annotation to extract schema ID from\n * @returns The schema ID (e.g., \"legal-irac\"), or undefined if not a tag or no schema found\n */\nexport function getTagSchemaId(annotation: Annotation): string | undefined {\n  if (!isTag(annotation)) return undefined;\n  const bodies = Array.isArray(annotation.body) ? annotation.body : [annotation.body];\n  const classifyingBody = bodies.find(b => b && 'purpose' in b && b.purpose === 'classifying');\n  if (classifyingBody && 'value' in classifyingBody) {\n    return classifyingBody.value;\n  }\n  return undefined;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@semiont/ontology",
+  "version": "0.2.28-build.40",
+  "type": "module",
+  "description": "Entity types, tag schemas, and W3C annotation vocabularies",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "npm run typecheck && tsup",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@semiont/api-client": "*"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.1",
+    "typescript": "^5.6.3",
+    "vitest": "^3.2.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "ontology",
+    "entity-types",
+    "tag-schemas",
+    "w3c",
+    "annotations",
+    "vocabularies"
+  ],
+  "author": "The AI Alliance",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/The-AI-Alliance/semiont.git",
+    "directory": "packages/ontology"
+  }
+}