semantic-primitives 0.1.0

package/dist/types/bun/bun.d.ts

@@ -0,0 +1,266 @@
+/**
+ * SemanticBun - LLM-enhanced Bun-specific APIs with semantic understanding
+ *
+ * Provides intelligent wrappers around Bun's file operations, server configuration,
+ * shell commands, and environment variable management.
+ *
+ * Core capabilities:
+ * - SemanticBunFile: File operations with content detection and explanation
+ * - SemanticServer: Server configuration analysis and suggestions
+ * - SemanticShell: Shell command safety checking and explanation
+ * - SemanticEnv: Environment variable validation and semantic lookup
+ */
+import type { LLMConfig, Message } from '../../llm/types.ts';
+import type { ValidateResult } from '../../shared/types.ts';
+export type { ValidateResult } from '../../shared/types.ts';
+/** Result of file type detection */
+export interface FileTypeResult {
+    type: string;
+    subtype?: string;
+    confidence: number;
+}
+/** Result of server configuration analysis */
+export interface ServerConfigAnalysis {
+    secure: boolean;
+    issues: string[];
+    suggestions: string[];
+}
+/** Result of command safety assessment */
+export interface CommandSafetyResult {
+    safe: boolean;
+    reason?: string;
+    risks: string[];
+}
+/** Suggestion for a safer command alternative */
+export interface SaferCommandSuggestion {
+    command: string;
+    reason: string;
+}
+/** Result of environment variable validation */
+export interface EnvValidationResult {
+    valid: boolean;
+    missing: string[];
+    suggestions: {
+        variable: string;
+        example: string;
+    }[];
+}
+/** Result of sensitive environment detection */
+export interface SensitiveEnvResult {
+    sensitive: string[];
+    recommendation: string;
+}
+/** LLM client interface for dependency injection */
+export interface BunLLMClientInterface {
+    chat(options: {
+        messages: Message[];
+        systemPrompt?: string;
+    } & LLMConfig): Promise<{
+        content: string;
+    }>;
+}
+/**
+ * SemanticBunFileRef - A reference to a file with semantic capabilities
+ *
+ * Provides LLM-enhanced operations on file references including:
+ * - Type detection with semantic understanding
+ * - Content explanation
+ * - Purpose-based validation
+ * - Standard file operations (text, json, exists)
+ */
+export declare class SemanticBunFileRef {
+    private readonly _path;
+    private readonly _llmClient;
+    private readonly _llmConfig?;
+    /**
+     * Create a SemanticBunFileRef instance
+     * @param path - The file path
+     * @param llmClient - Optional LLM client for dependency injection
+     * @param llmConfig - Optional LLM configuration
+     */
+    constructor(path: string, llmClient?: BunLLMClientInterface, llmConfig?: LLMConfig);
+    /**
+     * Get the file path
+     */
+    get path(): string;
+    /**
+     * Detect the file type semantically.
+     *
+     * @returns File type detection with confidence
+     *
+     * @example
+     * await fileRef.detectType()
+     * // { type: "json", subtype: "package-json", confidence: 0.95 }
+     */
+    detectType(): Promise<FileTypeResult>;
+    /**
+     * Read and explain the file contents.
+     *
+     * @returns Human-readable explanation of the file
+     *
+     * @example
+     * await fileRef.explain()
+     * // "Node.js package.json with 15 dependencies, configured for TypeScript"
+     */
+    explain(): Promise<string>;
+    /**
+     * Validate file contents for a specific purpose.
+     *
+     * @param purpose - Intended use of the file
+     * @returns Validation result with issues
+     *
+     * @example
+     * await fileRef.validateFor("production deployment")
+     * // { valid: false, issues: ["Contains development dependencies"] }
+     */
+    validateFor(purpose: string): Promise<ValidateResult>;
+    /**
+     * Read file as text with encoding detection.
+     *
+     * @returns File content as string
+     */
+    text(): Promise<string>;
+    /**
+     * Read and parse JSON with validation.
+     *
+     * @returns Parsed JSON content
+     */
+    json<T>(): Promise<T>;
+    /**
+     * Check if file exists and is accessible.
+     *
+     * @returns true if file exists
+     */
+    exists(): Promise<boolean>;
+}
+/**
+ * Analyze server configuration for issues.
+ *
+ * @param config - Server configuration object
+ * @param llmClient - Optional LLM client for dependency injection
+ * @param llmConfig - Optional LLM configuration
+ * @returns Configuration analysis with issues and suggestions
+ *
+ * @example
+ * analyzeServerConfig({ port: 3000 })
+ * // { secure: false, issues: ["No HTTPS configured"], suggestions: [...] }
+ */
+export declare function analyzeServerConfig(config: object, llmClient?: BunLLMClientInterface, llmConfig?: LLMConfig): Promise<ServerConfigAnalysis>;
+/**
+ * Suggest optimal server configuration.
+ *
+ * @param requirements - Server requirements
+ * @param llmClient - Optional LLM client for dependency injection
+ * @param llmConfig - Optional LLM configuration
+ * @returns Suggested server configuration
+ *
+ * @example
+ * suggestServerConfig({ purpose: "REST API", scale: "medium" })
+ */
+export declare function suggestServerConfig(requirements: {
+    purpose: string;
+    scale?: 'small' | 'medium' | 'large';
+}, llmClient?: BunLLMClientInterface, llmConfig?: LLMConfig): Promise<object>;
+/**
+ * Check if a shell command is safe to execute.
+ *
+ * @param command - Command to check
+ * @param llmClient - Optional LLM client for dependency injection
+ * @param llmConfig - Optional LLM configuration
+ * @returns Safety assessment with risks
+ *
+ * @example
+ * isCommandSafe("rm -rf /")
+ * // { safe: false, reason: "Destructive command targeting root directory", risks: [...] }
+ */
+export declare function isCommandSafe(command: string, llmClient?: BunLLMClientInterface, llmConfig?: LLMConfig): Promise<CommandSafetyResult>;
+/**
+ * Explain what a shell command does.
+ *
+ * @param command - Command to explain
+ * @param llmClient - Optional LLM client for dependency injection
+ * @param llmConfig - Optional LLM configuration
+ * @returns Human-readable explanation
+ *
+ * @example
+ * explainCommand("find . -name '*.ts' | xargs wc -l")
+ * // "Counts total lines of code in all TypeScript files recursively"
+ */
+export declare function explainCommand(command: string, llmClient?: BunLLMClientInterface, llmConfig?: LLMConfig): Promise<string>;
+/**
+ * Suggest a safer alternative for a command.
+ *
+ * @param command - Command to improve
+ * @param llmClient - Optional LLM client for dependency injection
+ * @param llmConfig - Optional LLM configuration
+ * @returns Safer alternative or null if already safe
+ *
+ * @example
+ * suggestSaferCommand("rm file.txt")
+ * // { command: "rm -i file.txt", reason: "Interactive mode prevents accidental deletion" }
+ */
+export declare function suggestSaferCommand(command: string, llmClient?: BunLLMClientInterface, llmConfig?: LLMConfig): Promise<SaferCommandSuggestion | null>;
+/**
+ * Validate environment configuration.
+ *
+ * @param required - Required environment variable names
+ * @param llmClient - Optional LLM client for dependency injection
+ * @param llmConfig - Optional LLM configuration
+ * @returns Validation result with missing variables and suggestions
+ *
+ * @example
+ * validateEnv(["DATABASE_URL", "API_KEY"])
+ * // { valid: false, missing: ["API_KEY"], suggestions: [...] }
+ */
+export declare function validateEnv(required: string[], llmClient?: BunLLMClientInterface, llmConfig?: LLMConfig): Promise<EnvValidationResult>;
+/**
+ * Detect sensitive environment variables.
+ *
+ * @param llmClient - Optional LLM client for dependency injection
+ * @param llmConfig - Optional LLM configuration
+ * @returns Sensitive variable analysis with recommendations
+ *
+ * @example
+ * detectSensitiveEnv()
+ * // { sensitive: ["DATABASE_URL", "API_KEY"], recommendation: "Use secrets manager" }
+ */
+export declare function detectSensitiveEnv(llmClient?: BunLLMClientInterface, llmConfig?: LLMConfig): Promise<SensitiveEnvResult>;
+/**
+ * Get an env variable with semantic fallback.
+ *
+ * @param nameOrDescription - Variable name or semantic description
+ * @param llmClient - Optional LLM client for dependency injection
+ * @param llmConfig - Optional LLM configuration
+ * @returns Variable value or undefined
+ *
+ * @example
+ * getEnv("database connection string")
+ * // Matches DATABASE_URL, DB_CONNECTION, etc.
+ */
+export declare function getEnv(nameOrDescription: string, llmClient?: BunLLMClientInterface, llmConfig?: LLMConfig): Promise<string | undefined>;
+/**
+ * SemanticBun - Unified namespace for all semantic Bun operations
+ */
+export declare const SemanticBun: {
+    /**
+     * Create a semantic file reference.
+     *
+     * @param path - File path
+     * @param llmClient - Optional LLM client
+     * @param llmConfig - Optional LLM configuration
+     * @returns SemanticBunFileRef instance
+     *
+     * @example
+     * const config = await SemanticBun.file("config.json").json()
+     */
+    file(path: string, llmClient?: BunLLMClientInterface, llmConfig?: LLMConfig): SemanticBunFileRef;
+    analyzeServerConfig: typeof analyzeServerConfig;
+    suggestServerConfig: typeof suggestServerConfig;
+    isCommandSafe: typeof isCommandSafe;
+    explainCommand: typeof explainCommand;
+    suggestSaferCommand: typeof suggestSaferCommand;
+    validateEnv: typeof validateEnv;
+    detectSensitiveEnv: typeof detectSensitiveEnv;
+    getEnv: typeof getEnv;
+};
+//# sourceMappingURL=bun.d.ts.map

package/dist/types/bun/bun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.d.ts","sourceRoot":"","sources":["../../../src/types/bun/bun.ts"],"names":[],"mappings":"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"}

package/dist/types/bun/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * SemanticBun Module
+ * LLM-enhanced Bun-specific APIs with semantic understanding
+ */
+export { SemanticBun, SemanticBunFileRef, analyzeServerConfig, suggestServerConfig, isCommandSafe, explainCommand, suggestSaferCommand, validateEnv, detectSensitiveEnv, getEnv, type FileTypeResult, type ServerConfigAnalysis, type CommandSafetyResult, type SaferCommandSuggestion, type EnvValidationResult, type SensitiveEnvResult, type BunLLMClientInterface, } from './bun.ts';
+export type { ValidateResult } from '../../shared/types.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/bun/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/bun/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,cAAc,EACd,mBAAmB,EACnB,WAAW,EACX,kBAAkB,EAClB,MAAM,EACN,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,GAC3B,MAAM,UAAU,CAAC;AAGlB,YAAY,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/types/bun/prompts.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Prompts for SemanticBun LLM operations
+ * These prompts are used for various semantic Bun API operations that require LLM understanding
+ */
+/**
+ * System prompt for file type detection
+ */
+export declare const DETECT_FILE_TYPE_SYSTEM = "You are a file type detection assistant. Your task is to analyze file paths, names, and optionally content to determine the file type.\n\nConsider:\n- File extension and common naming patterns\n- Content structure if provided (JSON, YAML, XML, etc.)\n- Common configuration file patterns (package.json, tsconfig.json, .env, etc.)\n- Source code file patterns\n- Document and media file types\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for file type detection
+ */
+export declare function detectFileTypePrompt(path: string, contentPreview?: string): string;
+/**
+ * System prompt for file content explanation
+ */
+export declare const EXPLAIN_FILE_SYSTEM = "You are a file content explanation assistant. Your task is to explain what a file contains and its purpose in human-readable terms.\n\nConsider:\n- The file's purpose in a project context\n- Key configuration or content elements\n- Dependencies, scripts, or important settings\n- Potential issues or notable configurations\n\nProvide concise, informative explanations.\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for file explanation
+ */
+export declare function explainFilePrompt(path: string, content: string): string;
+/**
+ * System prompt for file validation for purpose
+ */
+export declare const VALIDATE_FILE_FOR_SYSTEM = "You are a file validation assistant. Your task is to validate file contents for specific use cases and purposes.\n\nConsider:\n- Required fields or configurations for the purpose\n- Security concerns (exposed secrets, debug settings, etc.)\n- Best practices for the file type\n- Production vs development configurations\n- Missing or incorrect settings\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for purpose validation
+ */
+export declare function validateFileForPrompt(path: string, content: string, purpose: string): string;
+/**
+ * System prompt for server configuration analysis
+ */
+export declare const ANALYZE_SERVER_CONFIG_SYSTEM = "You are a Bun server configuration analyst. Your task is to analyze Bun.serve() configurations for security, performance, and best practices.\n\nConsider:\n- HTTPS/TLS configuration\n- CORS settings\n- Rate limiting\n- Request validation\n- Error handling\n- WebSocket configuration\n- Development vs production settings\n- Port and hostname security\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for server config analysis
+ */
+export declare function analyzeServerConfigPrompt(config: string): string;
+/**
+ * System prompt for server configuration suggestions
+ */
+export declare const SUGGEST_SERVER_CONFIG_SYSTEM = "You are a Bun server configuration expert. Your task is to suggest optimal server configurations based on requirements.\n\nConsider:\n- Purpose (REST API, static files, WebSocket, etc.)\n- Scale requirements\n- Security best practices\n- Performance optimizations\n- Common middleware needs\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for server config suggestions
+ */
+export declare function suggestServerConfigPrompt(purpose: string, scale?: 'small' | 'medium' | 'large'): string;
+/**
+ * System prompt for command safety assessment
+ */
+export declare const IS_COMMAND_SAFE_SYSTEM = "You are a shell command safety analyst. Your task is to assess whether shell commands are safe to execute.\n\nConsider these risk factors:\n- Destructive operations (rm, del, format, etc.)\n- System-wide impact (sudo, admin commands)\n- Data exfiltration risks\n- Privilege escalation\n- Network operations\n- File permission changes\n- Environment variable exposure\n- Command injection vulnerabilities\n- Piping to dangerous commands\n\nClassify risks by severity and provide clear explanations.\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for command safety check
+ */
+export declare function isCommandSafePrompt(command: string): string;
+/**
+ * System prompt for command explanation
+ */
+export declare const EXPLAIN_COMMAND_SYSTEM = "You are a shell command explanation assistant. Your task is to explain what shell commands do in human-readable terms.\n\nConsider:\n- The main command and its purpose\n- All flags and options\n- Piped commands and their effects\n- Redirections and their targets\n- Environment variables used\n- Overall effect of the command\n\nProvide clear, concise explanations suitable for developers.\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for command explanation
+ */
+export declare function explainCommandPrompt(command: string): string;
+/**
+ * System prompt for safer command suggestions
+ */
+export declare const SUGGEST_SAFER_COMMAND_SYSTEM = "You are a shell command safety advisor. Your task is to suggest safer alternatives to potentially risky shell commands.\n\nConsider:\n- Interactive modes for destructive operations\n- Dry-run options\n- Backup strategies\n- More specific targeting\n- Permission restrictions\n- Safer alternatives that achieve the same goal\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for safer command suggestion
+ */
+export declare function suggestSaferCommandPrompt(command: string): string;
+/**
+ * System prompt for environment validation
+ */
+export declare const VALIDATE_ENV_SYSTEM = "You are an environment variable validation assistant. Your task is to validate that required environment variables are properly configured.\n\nConsider:\n- Presence of required variables\n- Correct naming conventions\n- Common environment variable patterns\n- Suggestions for missing variables\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for environment validation
+ */
+export declare function validateEnvPrompt(required: string[], currentEnv: string[]): string;
+/**
+ * System prompt for sensitive env detection
+ */
+export declare const DETECT_SENSITIVE_ENV_SYSTEM = "You are a security analyst for environment variables. Your task is to identify sensitive environment variables that should be protected.\n\nSensitive variables typically include:\n- API keys and tokens\n- Database credentials\n- Encryption keys and secrets\n- OAuth credentials\n- Private keys\n- Connection strings with credentials\n- Service account credentials\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for sensitive env detection
+ */
+export declare function detectSensitiveEnvPrompt(envNames: string[]): string;
+/**
+ * System prompt for semantic env lookup
+ */
+export declare const GET_ENV_SEMANTIC_SYSTEM = "You are an environment variable matching assistant. Your task is to match semantic descriptions to environment variable names.\n\nConsider:\n- Common naming conventions (DATABASE_URL, DB_URL, DB_CONNECTION)\n- Abbreviations and variations\n- Purpose-based naming\n- Service-specific patterns\n\nAlways respond with valid JSON only.";
+/**
+ * User prompt template for semantic env lookup
+ */
+export declare function getEnvSemanticPrompt(description: string, availableEnvs: string[]): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/types/bun/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/types/bun/prompts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH;;GAEG;AACH,eAAO,MAAM,uBAAuB,obASC,CAAC;AAEtC;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,CAWlF;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,6ZAUK,CAAC;AAEtC;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CASvE;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB,6YASA,CAAC;AAEtC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAU5F;AAMD;;GAEG;AACH,eAAO,MAAM,4BAA4B,2YAYJ,CAAC;AAEtC;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAQhE;AAED;;GAEG;AACH,eAAO,MAAM,4BAA4B,+UASJ,CAAC;AAEtC;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAcvG;AAMD;;GAEG;AACH,eAAO,MAAM,sBAAsB,8hBAeE,CAAC;AAEtC;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAO3D;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,kbAYE,CAAC;AAEtC;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAO5D;AAED;;GAEG;AACH,eAAO,MAAM,4BAA4B,gXAUJ,CAAC;AAEtC;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAUjE;AAMD;;GAEG;AACH,eAAO,MAAM,mBAAmB,kVAQK,CAAC;AAEtC;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAQlF;AAED;;GAEG;AACH,eAAO,MAAM,2BAA2B,wZAWH,CAAC;AAEtC;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAOnE;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,gVAQC,CAAC;AAEtC;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,MAAM,CAQzF"}

package/dist/types/callable/callable.d.ts

@@ -0,0 +1,200 @@
+/**
+ * SemanticCallable
+ * A callable type with LLM-powered semantic understanding
+ *
+ * Implements:
+ * - Behavioral analysis and comparison
+ * - Signature inference from usage patterns
+ * - Intelligent argument validation
+ * - Test case generation
+ * - Issue detection
+ */
+import type { LLMClient } from '../../llm/client.ts';
+import type { SemanticEqualsResult, ValidateResult, DetectedIssue, SafetyResult } from '../../shared/types.ts';
+export type { SemanticEqualsResult, ValidateResult, DetectedIssue, SafetyResult };
+/** Inferred signature result */
+export interface InferredSignature {
+    params: string[];
+    return: string;
+    confidence: number;
+}
+/** Wrapper suggestion result */
+export interface WrapperSuggestion {
+    code: string;
+    reason: string;
+}
+/** Generated test case for callable (typed version) */
+export interface CallableTestCase<TInput extends unknown[] = unknown[], TOutput = unknown> {
+    inputs: TInput;
+    expectedOutput: TOutput;
+    description: string;
+}
+/**
+ * SemanticCallable - Function wrapper with LLM-powered semantic understanding
+ *
+ * Wraps a function and provides intelligent analysis, validation, and code generation.
+ */
+export declare class SemanticCallable<T extends (...args: never[]) => unknown> {
+    readonly [Symbol.toStringTag] = "SemanticCallable";
+    private readonly _fn;
+    private readonly _description?;
+    private readonly _client;
+    private _cachedSource?;
+    private constructor();
+    /**
+     * Wrap a function with semantic callable capabilities.
+     *
+     * @param fn - Function to wrap
+     * @param description - Optional description of what the function does
+     * @param client - Optional LLM client
+     * @returns SemanticCallable wrapper
+     *
+     * @example
+     * const calc = SemanticCallable.from((a, b) => a + b, "adds two numbers")
+     */
+    static from<T extends (...args: never[]) => unknown>(fn: T, description?: string, client?: LLMClient): SemanticCallable<T>;
+    /**
+     * Get the source code representation of the function.
+     * Uses Function.prototype.toString() for native functions.
+     */
+    private getSource;
+    /**
+     * Check if two callables are behaviorally equivalent.
+     * Same outputs for same inputs, regardless of implementation.
+     *
+     * @param other - Callable to compare
+     * @param testCases - Optional inputs to test with
+     * @returns Equivalence result with confidence
+     *
+     * @example
+     * fn1.semanticallyEquals(fn2, [[1, 2], [3, 4]])
+     * // { equivalent: true, confidence: 0.95 }
+     */
+    semanticallyEquals(other: ((...args: Parameters<T>) => ReturnType<T>) | SemanticCallable<T>, testCases?: Parameters<T>[]): Promise<SemanticEqualsResult>;
+    /**
+     * Explain what this callable does.
+     *
+     * @returns Human-readable explanation
+     *
+     * @example
+     * fn.explain()
+     * // "Takes two numbers and returns their sum, handling NaN edge cases"
+     */
+    explain(): Promise<string>;
+    /**
+     * Infer parameter types from usage patterns.
+     *
+     * @param sampleCalls - Sample inputs used to call the function
+     * @returns Inferred signature with confidence
+     *
+     * @example
+     * fn.inferSignature([[1, 2], ["a", "b"], [true, false]])
+     * // { params: ["number | string | boolean", "number | string | boolean"], return: "..." }
+     */
+    inferSignature(sampleCalls: Parameters<T>[]): Promise<InferredSignature>;
+    /**
+     * Generate TypeScript type definition for this callable.
+     *
+     * @returns Type definition string
+     *
+     * @example
+     * fn.generateTypeDefinition()
+     * // "type Calculator = (a: number, b: number) => number;"
+     */
+    generateTypeDefinition(): Promise<string>;
+    /**
+     * Validate inputs against semantic rules.
+     *
+     * @param args - Arguments to validate
+     * @param rules - Optional validation rules
+     * @returns Validation result
+     *
+     * @example
+     * divide.validateArgs([10, 0], ["divisor must not be zero"])
+     * // { valid: false, issues: ["divisor is zero"] }
+     */
+    validateArgs(args: Parameters<T>, rules?: string[]): Promise<ValidateResult>;
+    /**
+     * Generate test cases for this callable.
+     *
+     * @returns Generated test cases
+     *
+     * @example
+     * fn.generateTests()
+     * // [
+     * //   { inputs: [0, 0], expectedOutput: 0, description: "zero case" },
+     * //   { inputs: [1, -1], expectedOutput: 0, description: "opposite numbers" }
+     * // ]
+     */
+    generateTests(): Promise<CallableTestCase<Parameters<T>, ReturnType<T>>[]>;
+    /**
+     * Suggest type-safe wrapper or decorator.
+     *
+     * @returns Suggested wrapper code with reasoning
+     *
+     * @example
+     * fn.suggestWrapper()
+     * // { code: "function safeDivide(a: number, b: number): number | null { ... }", reason: "..." }
+     */
+    suggestWrapper(): Promise<WrapperSuggestion>;
+    /**
+     * Detect potential issues with the callable.
+     *
+     * @returns Detected issues with severity
+     *
+     * @example
+     * fn.detectIssues()
+     * // [{ issue: "No null check for optional param", severity: "warning" }]
+     */
+    detectIssues(): Promise<DetectedIssue[]>;
+    /**
+     * Check if the callable is safe to call with given arguments.
+     *
+     * @param args - Arguments to check
+     * @returns Safety assessment
+     *
+     * @example
+     * divide.isSafeToCall([10, 0])
+     * // { safe: false, reason: "Division by zero" }
+     */
+    isSafeToCall(args: Parameters<T>): Promise<SafetyResult>;
+    /**
+     * Call the underlying function.
+     *
+     * @param args - Arguments to pass to the function
+     * @returns Function result
+     *
+     * @example
+     * const result = add.call(1, 2)
+     * // 3
+     */
+    call(...args: Parameters<T>): ReturnType<T>;
+    /**
+     * Get the underlying function.
+     *
+     * @returns Original function
+     *
+     * @example
+     * const originalFn = semanticCallable.valueOf()
+     */
+    valueOf(): T;
+    /**
+     * Get the description of this callable.
+     *
+     * @returns Description if provided, undefined otherwise
+     */
+    getDescription(): string | undefined;
+    /**
+     * Get the function's name.
+     *
+     * @returns Function name or 'anonymous'
+     */
+    getName(): string;
+    /**
+     * Get the function's arity (number of expected arguments).
+     *
+     * @returns Number of parameters
+     */
+    getArity(): number;
+}
+//# sourceMappingURL=callable.d.ts.map

package/dist/types/callable/callable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callable.d.ts","sourceRoot":"","sources":["../../../src/types/callable/callable.ts"],"names":[],"mappings":"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"}

package/dist/types/callable/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SemanticCallable module
+ * LLM-enhanced callable type with semantic understanding
+ */
+export { SemanticCallable, type SemanticEqualsResult, type ValidateResult, type DetectedIssue, type SafetyResult, type InferredSignature, type WrapperSuggestion, type CallableTestCase, } from './callable.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/callable/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/callable/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,gBAAgB,EAChB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,eAAe,CAAC"}

package/dist/types/callable/prompts.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Prompts for SemanticCallable LLM operations
+ * These prompts enable intelligent function analysis, signature inference, and behavioral understanding
+ */
+/**
+ * System prompt for callable analysis tasks
+ */
+export declare const CALLABLE_SYSTEM_PROMPT = "You are an expert at analyzing TypeScript/JavaScript functions, understanding their behavior, and providing semantic insights about callable types.\n\nYou must respond with valid JSON only, no additional text or explanation.\n\nGuidelines:\n- Analyze function signatures, behavior, and usage patterns\n- Consider edge cases, type safety, and common programming patterns\n- Provide meaningful, contextual responses based on the function's purpose\n- Be precise with confidence scores based on available information";
+/**
+ * Prompt template for semantic equality comparison between callables
+ */
+export declare function createSemanticallyEqualsPrompt(fn1Source: string, fn2Source: string, fn1Description?: string, fn2Description?: string, testCases?: unknown[][]): string;
+/**
+ * Prompt template for explaining what a callable does
+ */
+export declare function createExplainPrompt(fnSource: string, description?: string): string;
+/**
+ * Prompt template for inferring function signature from sample calls
+ */
+export declare function createInferSignaturePrompt(fnSource: string, sampleCalls: unknown[][]): string;
+/**
+ * Prompt template for generating TypeScript type definition
+ */
+export declare function createGenerateTypeDefinitionPrompt(fnSource: string, description?: string, inferredParams?: string[], inferredReturn?: string): string;
+/**
+ * Prompt template for validating function arguments
+ */
+export declare function createValidateArgsPrompt(fnSource: string, args: unknown[], rules?: string[]): string;
+/**
+ * Prompt template for generating test cases
+ */
+export declare function createGenerateTestsPrompt(fnSource: string, description?: string): string;
+/**
+ * Prompt template for suggesting a type-safe wrapper
+ */
+export declare function createSuggestWrapperPrompt(fnSource: string, description?: string, detectedIssues?: string[]): string;
+/**
+ * Prompt template for detecting potential issues
+ */
+export declare function createDetectIssuesPrompt(fnSource: string, description?: string): string;
+/**
+ * Prompt template for checking if safe to call with arguments
+ */
+export declare function createIsSafeToCallPrompt(fnSource: string, args: unknown[], description?: string): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/types/callable/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/types/callable/prompts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB,sgBAQgC,CAAC;AAEpE;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,cAAc,CAAC,EAAE,MAAM,EACvB,cAAc,CAAC,EAAE,MAAM,EACvB,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,GACtB,MAAM,CAkCR;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,CAiBR;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,OAAO,EAAE,EAAE,GACvB,MAAM,CAoBR;AAED;;GAEG;AACH,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,MAAM,EACpB,cAAc,CAAC,EAAE,MAAM,EAAE,EACzB,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,CA4BR;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO,EAAE,EACf,KAAK,CAAC,EAAE,MAAM,EAAE,GACf,MAAM,CA+BR;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,CAyBR;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,MAAM,EACpB,cAAc,CAAC,EAAE,MAAM,EAAE,GACxB,MAAM,CA6BR;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,CA8BR;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO,EAAE,EACf,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,CAuBR"}