semantic-primitives 0.1.0

package/dist/primitives/number/number.d.ts

@@ -0,0 +1,154 @@
+/**
+ * SemanticNumber - LLM-enhanced number type with semantic understanding
+ *
+ * Extends the native JavaScript number with semantic operations including:
+ * - Natural language parsing
+ * - Context-aware equality comparison
+ * - Reasonableness validation
+ * - Unit inference and conversion
+ * - Human-friendly descriptions
+ *
+ * Implements shared interfaces:
+ * - Semantic<number> - Base semantic wrapper
+ * - Comparable<number | SemanticNumber> - Semantic equality comparison
+ * - ContextValidatable - Reasonableness checks
+ * - UnitConvertible<SemanticNumber> - Unit conversion
+ * - Describable - Human-friendly descriptions
+ */
+import type { LLMConfig, Message } from '../../llm/types.ts';
+import type { SemanticEqualsResult, ReasonableResult, InferUnitResult } from '../../shared/types.ts';
+import type { Semantic, Comparable, ContextValidatable, UnitConvertible, Describable } from '../../shared/interfaces.ts';
+export type { SemanticEqualsResult, ReasonableResult, InferUnitResult, } from '../../shared/types.ts';
+/** Options for semantic equality comparison */
+export interface SemanticEqualsOptions {
+    tolerance?: 'exact' | 'approximate' | number;
+}
+/** LLM client interface for dependency injection (compatible with shared LLMClientInterface) */
+export interface LLMClientInterface {
+    chat(options: {
+        messages: Message[];
+        systemPrompt?: string;
+    } & LLMConfig): Promise<{
+        content: string;
+    }>;
+}
+/**
+ * SemanticNumber class
+ * Wraps a numeric value with LLM-powered semantic operations
+ *
+ * Implements:
+ * - Semantic<number> - valueOf() returns the numeric value
+ * - Comparable<number | SemanticNumber> - semanticallyEquals() for comparison
+ * - ContextValidatable - isReasonable() for context-aware validation
+ * - UnitConvertible<SemanticNumber> - convert() and inferUnit()
+ * - Describable - describe() for human-friendly descriptions
+ */
+export declare class SemanticNumber implements Semantic<number>, Comparable<number | SemanticNumber>, ContextValidatable, UnitConvertible<SemanticNumber>, Describable {
+    private readonly _value;
+    private readonly _llmClient;
+    private readonly _llmConfig?;
+    /**
+     * Create a SemanticNumber instance
+     * @param value - The numeric value to wrap
+     * @param llmClient - Optional LLM client for dependency injection (useful for testing)
+     * @param llmConfig - Optional LLM configuration
+     */
+    constructor(value: number, llmClient?: LLMClientInterface, llmConfig?: LLMConfig);
+    /**
+     * Parse a number from natural language or formatted string
+     * Understands words, abbreviations, and localized formats
+     *
+     * @param input - Natural language or formatted number string
+     * @param context - Optional context for interpretation
+     * @param llmClient - Optional LLM client for dependency injection
+     * @param llmConfig - Optional LLM configuration
+     * @returns SemanticNumber instance
+     *
+     * @example
+     * SemanticNumber.from("twenty-five") // 25
+     * SemanticNumber.from("2.5k") // 2500
+     * SemanticNumber.from("$1,234.56") // 1234.56
+     * SemanticNumber.from("about a dozen") // 12
+     */
+    static from(input: string, context?: string, llmClient?: LLMClientInterface, llmConfig?: LLMConfig): Promise<SemanticNumber>;
+    /**
+     * Check if two numbers are semantically equivalent
+     * Considers approximate values and contextual equivalence
+     *
+     * @param other - Number to compare with
+     * @param options - Comparison options including tolerance
+     * @returns Equivalence result with confidence
+     *
+     * @example
+     * SemanticNumber.from(100).semanticallyEquals(99, { tolerance: "approximate" })
+     * // { equivalent: true, confidence: 0.95 }
+     */
+    semanticallyEquals(other: number | SemanticNumber, options?: SemanticEqualsOptions): Promise<SemanticEqualsResult>;
+    /**
+     * Validate if the number is reasonable for a given context
+     *
+     * @param context - What this number represents
+     * @returns Validation result with explanation
+     *
+     * @example
+     * SemanticNumber.from(150).isReasonable("human age")
+     * // { reasonable: false, explanation: "Human age rarely exceeds 120 years" }
+     */
+    isReasonable(context: string): Promise<ReasonableResult>;
+    /**
+     * Infer the likely unit for this number based on context
+     *
+     * @param context - Context describing what this number represents
+     * @returns Inferred unit with confidence
+     *
+     * @example
+     * SemanticNumber.from(72).inferUnit("body temperature")
+     * // { unit: "fahrenheit", confidence: 0.85 }
+     */
+    inferUnit(context: string): Promise<InferUnitResult>;
+    /**
+     * Convert to a different unit with semantic understanding
+     *
+     * @param toUnit - Target unit
+     * @param fromUnit - Source unit (optional, can be inferred)
+     * @returns Converted number
+     *
+     * @example
+     * SemanticNumber.from(100).convert("celsius", "fahrenheit")
+     * // SemanticNumber(37.78)
+     */
+    convert(toUnit: string, fromUnit?: string): Promise<SemanticNumber>;
+    /**
+     * Get a human-friendly description of the number's magnitude
+     *
+     * @param context - Optional context for more relevant description
+     * @returns Human-readable description
+     *
+     * @example
+     * SemanticNumber.from(1000000).describe()
+     * // "one million"
+     */
+    describe(context?: string): Promise<string>;
+    /**
+     * Get the raw numeric value
+     * @returns The underlying number
+     */
+    valueOf(): number;
+    /**
+     * Explain the number in a human-readable way.
+     * Implements Explainable interface.
+     *
+     * @param context - Optional context for the explanation
+     * @returns Human-readable explanation
+     */
+    explain(context?: string): Promise<string>;
+    /**
+     * Convert to string
+     */
+    toString(): string;
+    /**
+     * Convert to JSON
+     */
+    toJSON(): number;
+}
+//# sourceMappingURL=number.d.ts.map

package/dist/primitives/number/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../../src/primitives/number/number.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EACV,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EAChB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EACV,QAAQ,EACR,UAAU,EACV,kBAAkB,EAClB,eAAe,EACf,WAAW,EACZ,MAAM,4BAA4B,CAAC;AAiBpC,YAAY,EACV,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,GAChB,MAAM,uBAAuB,CAAC;AAE/B,+CAA+C;AAC/C,MAAM,WAAW,qBAAqB;IACpC,SAAS,CAAC,EAAE,OAAO,GAAG,aAAa,GAAG,MAAM,CAAC;CAC9C;AAED,gGAAgG;AAChG,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACzG;AAED;;;;;;;;;;GAUG;AACH,qBAAa,cACX,YACE,QAAQ,CAAC,MAAM,CAAC,EAChB,UAAU,CAAC,MAAM,GAAG,cAAc,CAAC,EACnC,kBAAkB,EAClB,eAAe,CAAC,cAAc,CAAC,EAC/B,WAAW;IAEb,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;IAChD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAY;IAExC;;;;;OAKG;gBAED,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,kBAAkB,EAC9B,SAAS,CAAC,EAAE,SAAS;IAOvB;;;;;;;;;;;;;;;OAeG;WACU,IAAI,CACf,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,kBAAkB,EAC9B,SAAS,CAAC,EAAE,SAAS,GACpB,OAAO,CAAC,cAAc,CAAC;IA0B1B;;;;;;;;;;;OAWG;IACG,kBAAkB,CACtB,KAAK,EAAE,MAAM,GAAG,cAAc,EAC9B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,oBAAoB,CAAC;IAkBhC;;;;;;;;;OASG;IACG,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAc9D;;;;;;;;;OASG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAc1D;;;;;;;;;;OAUG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAuBzE;;;;;;;;;OASG;IACG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAmBjD;;;OAGG;IACH,OAAO,IAAI,MAAM;IAIjB;;;;;;OAMG;IACG,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIhD;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,MAAM,IAAI,MAAM;CAGjB"}

package/dist/primitives/number/number.prompts.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Prompts for SemanticNumber LLM operations
+ * These prompts are used for various semantic number operations that require LLM understanding
+ */
+/**
+ * System prompt for number parsing operations
+ */
+export declare const PARSE_NUMBER_SYSTEM = "You are a number parsing assistant. Your task is to extract numeric values from natural language or formatted strings.\n\nRules:\n- Parse words (e.g., \"twenty-five\" -> 25)\n- Parse abbreviations (e.g., \"2.5k\" -> 2500, \"1M\" -> 1000000)\n- Parse formatted numbers (e.g., \"$1,234.56\" -> 1234.56)\n- Parse approximate terms (e.g., \"about a dozen\" -> 12, \"a few\" -> 3)\n- Handle fractions (e.g., \"half\" -> 0.5, \"a quarter\" -> 0.25)\n- Return null if the input cannot be parsed as a number\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for parsing numbers
+ */
+export declare function parseNumberPrompt(input: string, context?: string): string;
+/**
+ * System prompt for semantic equality comparison
+ */
+export declare const SEMANTIC_EQUALS_SYSTEM = "You are a number comparison assistant. Your task is to determine if two numbers are semantically equivalent based on context and tolerance.\n\nConsider:\n- Approximate equivalence when tolerance is \"approximate\"\n- Exact equivalence when tolerance is \"exact\"\n- Numeric tolerance when a number is provided\n- Context matters: in some domains small differences matter more than others\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for semantic equality
+ */
+export declare function semanticEqualsPrompt(value1: number, value2: number, tolerance: 'exact' | 'approximate' | number): string;
+/**
+ * System prompt for reasonableness validation
+ */
+export declare const IS_REASONABLE_SYSTEM = "You are a validation assistant. Your task is to determine if a given number is reasonable for a specific context.\n\nConsider:\n- Physical constraints (e.g., human age rarely exceeds 120)\n- Logical constraints (e.g., quantities cannot be negative)\n- Domain-specific norms (e.g., typical salary ranges)\n- Common sense expectations\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for reasonableness check
+ */
+export declare function isReasonablePrompt(value: number, context: string): string;
+/**
+ * System prompt for unit inference
+ */
+export declare const INFER_UNIT_SYSTEM = "You are a unit inference assistant. Your task is to infer the most likely unit for a number based on its value and context.\n\nConsider:\n- The numeric value (e.g., 72 for body temperature suggests Fahrenheit in US)\n- The context provided (e.g., \"body temperature\", \"speed limit\")\n- Regional conventions (e.g., US uses Fahrenheit, Europe uses Celsius)\n- Domain-specific standards (e.g., scientific measurements)\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for unit inference
+ */
+export declare function inferUnitPrompt(value: number, context: string): string;
+/**
+ * System prompt for unit conversion
+ */
+export declare const CONVERT_UNIT_SYSTEM = "You are a unit conversion assistant. Your task is to convert numbers between different units.\n\nYou must:\n- Apply correct conversion formulas\n- Handle temperature conversions (C to F: multiply by 9/5 and add 32)\n- Handle length conversions (m to ft, km to mi, etc.)\n- Handle weight conversions (kg to lb, etc.)\n- Handle any other standard unit conversions\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for unit conversion
+ */
+export declare function convertUnitPrompt(value: number, fromUnit: string, toUnit: string): string;
+/**
+ * System prompt for number description
+ */
+export declare const DESCRIBE_NUMBER_SYSTEM = "You are a number description assistant. Your task is to provide human-friendly descriptions of numbers, explaining their magnitude in understandable terms.\n\nConsider:\n- Large numbers: use words like \"million\", \"billion\"\n- Time-based context: convert seconds to readable durations\n- Contextual comparisons: relate to familiar concepts\n- Keep descriptions concise but informative\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for describing numbers
+ */
+export declare function describeNumberPrompt(value: number, context?: string): string;
+//# sourceMappingURL=number.prompts.d.ts.map

package/dist/primitives/number/number.prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.prompts.d.ts","sourceRoot":"","sources":["../../../src/primitives/number/number.prompts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB,giBAUK,CAAC;AAEtC;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAQzE;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,gbAQE,CAAC;AAEtC;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,OAAO,GAAG,aAAa,GAAG,MAAM,GAC1C,MAAM,CAgBR;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,yXAQI,CAAC;AAEtC;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAQzE;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,+cAQO,CAAC;AAEtC;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAQtE;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,sZASK,CAAC;AAEtC;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CASzF;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,gbAQE,CAAC;AAEtC;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ5E"}

package/dist/primitives/string/evals/classify.evals.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Evaluation dataset for SemanticString.classify()
+ * Tests classification of text into predefined categories
+ */
+import type { EvalDataset } from '../../../shared/eval-types.ts';
+export declare const dataset: EvalDataset;
+//# sourceMappingURL=classify.evals.d.ts.map

package/dist/primitives/string/evals/classify.evals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.evals.d.ts","sourceRoot":"","sources":["../../../../src/primitives/string/evals/classify.evals.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAEjE,eAAO,MAAM,OAAO,EAAE,WAmSrB,CAAC"}

package/dist/primitives/string/evals/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Evaluation datasets for SemanticString
+ */
+export { dataset as semanticallyEquals } from './semanticallyEquals.evals.ts';
+export { dataset as classify } from './classify.evals.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/primitives/string/evals/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/primitives/string/evals/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/primitives/string/evals/semanticallyEquals.evals.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Evaluation dataset for SemanticString.semanticallyEquals()
+ * Tests semantic comparison of strings for meaning equivalence
+ */
+import type { EvalDataset } from '../../../shared/eval-types.ts';
+export declare const dataset: EvalDataset;
+//# sourceMappingURL=semanticallyEquals.evals.d.ts.map

package/dist/primitives/string/evals/semanticallyEquals.evals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semanticallyEquals.evals.d.ts","sourceRoot":"","sources":["../../../../src/primitives/string/evals/semanticallyEquals.evals.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAEjE,eAAO,MAAM,OAAO,EAAE,WA6VrB,CAAC"}

package/dist/primitives/string/index.d.ts

@@ -0,0 +1,206 @@
+/**
+ * SemanticString - LLM-enhanced string with semantic understanding
+ *
+ * Extends native string capabilities with AI-powered semantic operations
+ * including meaning-aware comparisons, classification, and analysis.
+ *
+ * Implements shared interfaces:
+ * - Semantic<string> - Base semantic wrapper
+ * - Comparable<string | SemanticString> - Semantic equality comparison
+ * - Validatable - Rule-based validation
+ * - Classifiable - Category classification
+ * - Summarizable - Text summarization
+ * - SensitivityDetectable - Sensitive data detection
+ */
+import type { LLMClient } from '../../llm/client.ts';
+import type { SemanticEqualsResult, ClassifyResult, ValidateResult, DetectIntentResult, DetectLanguageResult, Correction } from '../../shared/types.ts';
+import type { Semantic, Comparable, Validatable, Classifiable, Summarizable, SensitivityDetectable } from '../../shared/interfaces.ts';
+export type { SemanticEqualsResult, ClassifyResult, ValidateResult, DetectIntentResult, DetectLanguageResult, Correction, } from '../../shared/types.ts';
+/** Result of sensitive information detection (alias for SensitiveResult) */
+export interface ContainsSensitiveResult {
+    hasSensitive: boolean;
+    types: string[];
+}
+/**
+ * SemanticString class - wraps a string with semantic capabilities
+ *
+ * Implements:
+ * - Semantic<string> - valueOf() returns the string value
+ * - Comparable<string | SemanticString> - semanticallyEquals() for comparison
+ * - Validatable - validate() for rule-based validation
+ * - Classifiable - classify() for categorization
+ * - Summarizable - summarize() for text summarization
+ * - SensitivityDetectable - containsSensitive() for PII detection
+ *
+ * @example
+ * ```ts
+ * const str = SemanticString.from("The meeting is cancelled");
+ * const result = await str.semanticallyEquals("Meeting has been called off");
+ * // { equivalent: true, confidence: 0.92 }
+ * ```
+ */
+export declare class SemanticString implements Semantic<string>, Comparable<string | SemanticString>, Validatable, Classifiable, Summarizable, SensitivityDetectable {
+    private readonly value;
+    private readonly client;
+    private constructor();
+    /**
+     * Create a SemanticString from a regular string
+     */
+    static from(value: string, client?: LLMClient): SemanticString;
+    /**
+     * Get the underlying string value
+     */
+    toString(): string;
+    /**
+     * Get the underlying string value
+     */
+    valueOf(): string;
+    /**
+     * Get the length of the string
+     */
+    get length(): number;
+    /**
+     * Check if two strings are semantically equivalent (same meaning).
+     * Understands synonyms, paraphrases, and different phrasings.
+     *
+     * @param other - String to compare with
+     * @param options - Comparison options
+     * @returns Equivalence result with confidence
+     *
+     * @example
+     * ```ts
+     * const str = SemanticString.from("purchase");
+     * await str.semanticallyEquals("buy");
+     * // { equivalent: true, confidence: 0.95 }
+     * ```
+     */
+    semanticallyEquals(other: string | SemanticString, options?: {
+        threshold?: number;
+        context?: string;
+    }): Promise<SemanticEqualsResult>;
+    /**
+     * Classify the string into one of the provided categories.
+     * Uses semantic understanding to match meaning, not just keywords.
+     *
+     * @param categories - Array of category names to classify into
+     * @param context - Optional context to improve classification
+     * @returns Best matching category with confidence
+     *
+     * @example
+     * ```ts
+     * const str = SemanticString.from("I can't log in to my account");
+     * await str.classify(["billing", "technical", "account", "general"]);
+     * // { category: "account", confidence: 0.89 }
+     * ```
+     */
+    classify(categories: string[], context?: string): Promise<ClassifyResult>;
+    /**
+     * Extract specific types of information from the string.
+     *
+     * @param types - Types of entities to extract (e.g., "email", "date", "name")
+     * @returns Object mapping types to extracted values
+     *
+     * @example
+     * ```ts
+     * const str = SemanticString.from("Contact John at john@example.com by Friday");
+     * await str.extract(["email", "name", "date"]);
+     * // { email: "john@example.com", name: "John", date: "Friday" }
+     * ```
+     */
+    extract(types: string[]): Promise<Record<string, string | string[] | null>>;
+    /**
+     * Validate the string against semantic rules (not just regex).
+     *
+     * @param rules - Natural language validation rules
+     * @returns Validation result with issues if any
+     *
+     * @example
+     * ```ts
+     * const str = SemanticString.from("Buy now!!!");
+     * await str.validate(["should be professional", "no excessive punctuation"]);
+     * // { valid: false, issues: ["excessive punctuation (!!!)"] }
+     * ```
+     */
+    validate(rules: string[]): Promise<ValidateResult>;
+    /**
+     * Determine the likely intent or purpose of the string.
+     *
+     * @returns Intent classification with confidence
+     *
+     * @example
+     * ```ts
+     * const str = SemanticString.from("How do I reset my password?");
+     * await str.detectIntent();
+     * // { intent: "question", subtype: "how-to", topic: "password-reset", confidence: 0.94 }
+     * ```
+     */
+    detectIntent(): Promise<DetectIntentResult>;
+    /**
+     * Detect the language of the string.
+     *
+     * @returns Detected language code with confidence
+     *
+     * @example
+     * ```ts
+     * const str = SemanticString.from("Bonjour le monde");
+     * await str.detectLanguage();
+     * // { language: "fr", confidence: 0.98 }
+     * ```
+     */
+    detectLanguage(): Promise<DetectLanguageResult>;
+    /**
+     * Check if the string contains sensitive information (PII, secrets, etc.).
+     *
+     * @returns Detection result with types of sensitive data found
+     *
+     * @example
+     * ```ts
+     * const str = SemanticString.from("My SSN is 123-45-6789");
+     * await str.containsSensitive();
+     * // { hasSensitive: true, types: ["ssn"] }
+     * ```
+     */
+    containsSensitive(): Promise<ContainsSensitiveResult>;
+    /**
+     * Get a semantic similarity score with another string (0-1).
+     *
+     * @param other - String to compare with
+     * @returns Similarity score from 0 (unrelated) to 1 (identical meaning)
+     *
+     * @example
+     * ```ts
+     * const str = SemanticString.from("happy");
+     * await str.similarity("joyful"); // 0.85
+     * await str.similarity("sad"); // 0.15
+     * ```
+     */
+    similarity(other: string | SemanticString): Promise<number>;
+    /**
+     * Summarize the string to a target length while preserving meaning.
+     *
+     * @param maxLength - Maximum character length for summary
+     * @returns Summarized string
+     *
+     * @example
+     * ```ts
+     * const str = SemanticString.from("The quick brown fox jumps over the lazy dog. This is a common pangram used for testing.");
+     * await str.summarize(50);
+     * // "A pangram about a fox jumping over a lazy dog."
+     * ```
+     */
+    summarize(maxLength: number): Promise<string>;
+    /**
+     * Suggest corrections for spelling, grammar, or style issues.
+     *
+     * @returns Array of suggested corrections
+     *
+     * @example
+     * ```ts
+     * const str = SemanticString.from("Their going to the store tommorow");
+     * await str.suggestCorrections();
+     * // [{ original: "Their", suggestion: "They're" }, { original: "tommorow", suggestion: "tomorrow" }]
+     * ```
+     */
+    suggestCorrections(): Promise<Correction[]>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/primitives/string/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/primitives/string/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,KAAK,EACV,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,UAAU,EACX,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EACV,QAAQ,EACR,UAAU,EACV,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,qBAAqB,EACtB,MAAM,4BAA4B,CAAC;AAepC,YAAY,EACV,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,UAAU,GACX,MAAM,uBAAuB,CAAC;AAE/B,4EAA4E;AAC5E,MAAM,WAAW,uBAAuB;IACtC,YAAY,EAAE,OAAO,CAAC;IACtB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,cACX,YACE,QAAQ,CAAC,MAAM,CAAC,EAChB,UAAU,CAAC,MAAM,GAAG,cAAc,CAAC,EACnC,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,qBAAqB;IAEvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IAEnC,OAAO;IAKP;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,cAAc;IAI9D;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,OAAO,IAAI,MAAM;IAIjB;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;;;;;;;;;;OAcG;IACG,kBAAkB,CACtB,KAAK,EAAE,MAAM,GAAG,cAAc,EAC9B,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GACjD,OAAO,CAAC,oBAAoB,CAAC;IAchC;;;;;;;;;;;;;;OAcG;IACG,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAM/E;;;;;;;;;;;;OAYG;IACG,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;IAMjF;;;;;;;;;;;;OAYG;IACG,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAMxD;;;;;;;;;;;OAWG;IACG,YAAY,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAMjD;;;;;;;;;;;OAWG;IACG,cAAc,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAMrD;;;;;;;;;;;OAWG;IACG,iBAAiB,IAAI,OAAO,CAAC,uBAAuB,CAAC;IAM3D;;;;;;;;;;;;OAYG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;IAQjE;;;;;;;;;;;;OAYG;IACG,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOnD;;;;;;;;;;;OAWG;IACG,kBAAkB,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;CAMlD"}

package/dist/primitives/string/string.prompts.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Prompts for SemanticString LLM operations
+ * Each prompt is designed to return structured JSON output
+ */
+/**
+ * Prompt for semantic equality comparison
+ */
+export declare function semanticallyEqualsPrompt(str1: string, str2: string, context?: string): string;
+/**
+ * Prompt for string classification
+ */
+export declare function classifyPrompt(text: string, categories: string[], context?: string): string;
+/**
+ * Prompt for entity extraction
+ */
+export declare function extractPrompt(text: string, types: string[]): string;
+/**
+ * Prompt for semantic validation
+ */
+export declare function validatePrompt(text: string, rules: string[]): string;
+/**
+ * Prompt for intent detection
+ */
+export declare function detectIntentPrompt(text: string): string;
+/**
+ * Prompt for language detection
+ */
+export declare function detectLanguagePrompt(text: string): string;
+/**
+ * Prompt for sensitive information detection
+ */
+export declare function containsSensitivePrompt(text: string): string;
+/**
+ * Prompt for semantic similarity scoring
+ */
+export declare function similarityPrompt(str1: string, str2: string): string;
+/**
+ * Prompt for text summarization
+ */
+export declare function summarizePrompt(text: string, maxLength: number): string;
+/**
+ * Prompt for correction suggestions
+ */
+export declare function suggestCorrectionsPrompt(text: string): string;
+//# sourceMappingURL=string.prompts.d.ts.map

package/dist/primitives/string/string.prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.prompts.d.ts","sourceRoot":"","sources":["../../../src/primitives/string/string.prompts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,CAkBR;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,CAgBR;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAanE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAgBpE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkBvD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAWzD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAmB5D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAmBnE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAevE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoB7D"}

package/dist/primitives/symbol/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SemanticSymbol module
+ * LLM-enhanced symbol type with semantic understanding
+ */
+export * from './symbol.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/primitives/symbol/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/primitives/symbol/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,aAAa,CAAC"}