infiniloom-node 0.6.2 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infiniloom-node",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Node.js bindings for Infiniloom - AST-aware code context engine for RAG and vector databases. Tree-sitter parsing, PageRank ranking, BLAKE3 content-addressable chunks, 27+ tokenizers.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -64,18 +64,53 @@
     "artifacts": "napi artifacts",
     "build": "napi build --platform --release",
     "build:debug": "napi build --platform",
-    "prepublishOnly": "napi prepublish -t npm",
+    "build:types": "tsc -p tsconfig.json --declaration --emitDeclarationOnly --outDir .",
+    "prepublishOnly": "napi prepublish -t npm && npm run build:types",
     "test": "node --test",
+    "typecheck": "tsc --noEmit",
     "version": "napi version"
   },
+  "dependencies": {
+    "zod": "^3.23.0"
+  },
   "devDependencies": {
-    "@napi-rs/cli": "^2.18.0"
+    "@napi-rs/cli": "^2.18.0",
+    "typescript": "^5.3.0"
   },
   "files": [
     "index.js",
     "index.d.ts",
+    "types.ts",
+    "types.d.ts",
+    "schemas.ts",
+    "schemas.d.ts",
+    "schemas.js",
+    "tsconfig.json",
     "*.node"
   ],
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.js",
+      "import": "./index.js"
+    },
+    "./types": {
+      "types": "./types.d.ts",
+      "require": "./types.js",
+      "import": "./types.js"
+    },
+    "./schemas": {
+      "types": "./schemas.d.ts",
+      "require": "./schemas.js",
+      "import": "./schemas.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "types": ["./types.d.ts"],
+      "schemas": ["./schemas.d.ts"]
+    }
+  },
   "bugs": {
     "url": "https://github.com/Topos-Labs/infiniloom/issues"
   },

package/schemas.ts

@@ -0,0 +1,691 @@
+/**
+ * Zod schemas for runtime validation of infiniloom-node options
+ *
+ * These schemas provide runtime validation with helpful error messages.
+ * Use them when accepting options from external sources (API calls, config files, etc.)
+ *
+ * Usage:
+ * ```typescript
+ * import { PackOptionsSchema, validatePackOptions } from 'infiniloom-node/schemas';
+ * import { pack } from 'infiniloom-node';
+ *
+ * // Validate options from external source
+ * const result = PackOptionsSchema.safeParse(userInput);
+ * if (!result.success) {
+ *   console.error('Invalid options:', result.error.format());
+ *   return;
+ * }
+ *
+ * // Or use the helper function
+ * const options = validatePackOptions(userInput);
+ * const output = pack('./repo', options);
+ * ```
+ */
+
+import { z } from 'zod';
+
+// ============================================================================
+// Enum Schemas
+// ============================================================================
+
+/**
+ * Output format enum schema
+ */
+export const OutputFormatSchema = z.enum([
+  'xml',
+  'markdown',
+  'json',
+  'yaml',
+  'toon',
+  'plain',
+]);
+export type OutputFormat = z.infer<typeof OutputFormatSchema>;
+
+/**
+ * Tokenizer model enum schema
+ */
+export const TokenizerModelSchema = z.enum([
+  // OpenAI models (exact tokenization via tiktoken)
+  'gpt-5.2',
+  'gpt-5.2-pro',
+  'gpt-5.1',
+  'gpt-5.1-mini',
+  'gpt-5.1-codex',
+  'gpt-5',
+  'gpt-5-mini',
+  'gpt-5-nano',
+  'o4-mini',
+  'o3',
+  'o3-mini',
+  'o1',
+  'o1-mini',
+  'o1-preview',
+  'gpt-4o',
+  'gpt-4o-mini',
+  'gpt-4',
+  'gpt-4-turbo',
+  'gpt-3.5-turbo',
+  // Anthropic
+  'claude',
+  // Google
+  'gemini',
+  'gemini-1.5',
+  'gemini-2.0',
+  // Meta
+  'llama',
+  'llama-3',
+  'llama-3.1',
+  'llama-3.2',
+  'codellama',
+  // Mistral
+  'mistral',
+  'mixtral',
+  // DeepSeek
+  'deepseek',
+  'deepseek-v3',
+  // Alibaba
+  'qwen',
+  'qwen-2.5',
+  // Cohere
+  'cohere',
+  'command-r',
+  // xAI
+  'grok',
+]);
+export type TokenizerModel = z.infer<typeof TokenizerModelSchema>;
+
+/**
+ * Compression level enum schema
+ */
+export const CompressionLevelSchema = z.enum([
+  'none',
+  'minimal',
+  'balanced',
+  'aggressive',
+  'extreme',
+  'focused',
+  'semantic',
+]);
+export type CompressionLevel = z.infer<typeof CompressionLevelSchema>;
+
+/**
+ * Security severity enum schema
+ */
+export const SecuritySeveritySchema = z.enum([
+  'critical',
+  'high',
+  'medium',
+  'low',
+  'info',
+]);
+export type SecuritySeverity = z.infer<typeof SecuritySeveritySchema>;
+
+/**
+ * Symbol kind enum schema
+ */
+export const SymbolKindSchema = z.enum([
+  'function',
+  'method',
+  'class',
+  'struct',
+  'interface',
+  'trait',
+  'enum',
+  'constant',
+  'variable',
+  'import',
+  'export',
+  'type',
+  'module',
+  'macro',
+]);
+export type SymbolKind = z.infer<typeof SymbolKindSchema>;
+
+/**
+ * Visibility enum schema
+ */
+export const VisibilitySchema = z.enum([
+  'public',
+  'private',
+  'protected',
+  'internal',
+]);
+export type Visibility = z.infer<typeof VisibilitySchema>;
+
+/**
+ * Chunk strategy enum schema
+ */
+export const ChunkStrategySchema = z.enum([
+  'fixed',
+  'file',
+  'module',
+  'symbol',
+  'semantic',
+  'dependency',
+]);
+export type ChunkStrategy = z.infer<typeof ChunkStrategySchema>;
+
+/**
+ * Impact level enum schema
+ */
+export const ImpactLevelSchema = z.enum([
+  'low',
+  'medium',
+  'high',
+  'critical',
+]);
+export type ImpactLevel = z.infer<typeof ImpactLevelSchema>;
+
+/**
+ * Git status enum schema
+ */
+export const GitStatusSchema = z.enum([
+  'Added',
+  'Modified',
+  'Deleted',
+  'Renamed',
+  'Copied',
+  'Unknown',
+]);
+export type GitStatus = z.infer<typeof GitStatusSchema>;
+
+/**
+ * Change type enum schema
+ */
+export const ChangeTypeSchema = z.enum([
+  'added',
+  'modified',
+  'deleted',
+]);
+export type ChangeType = z.infer<typeof ChangeTypeSchema>;
+
+/**
+ * Breaking change severity enum schema
+ */
+export const ChangeSeveritySchema = z.enum([
+  'critical',
+  'high',
+  'medium',
+  'low',
+]);
+export type ChangeSeverity = z.infer<typeof ChangeSeveritySchema>;
+
+// ============================================================================
+// Option Schemas
+// ============================================================================
+
+/**
+ * Pack options schema with full validation
+ */
+export const PackOptionsSchema = z.object({
+  format: OutputFormatSchema.optional(),
+  model: TokenizerModelSchema.optional(),
+  compression: CompressionLevelSchema.optional(),
+  mapBudget: z.number().int().nonnegative().max(10_000_000).optional(),
+  maxSymbols: z.number().int().positive().max(10_000).optional(),
+  skipSecurity: z.boolean().optional(),
+  redactSecrets: z.boolean().optional(),
+  skipSymbols: z.boolean().optional(),
+  include: z.array(z.string().max(256)).max(100).optional(),
+  exclude: z.array(z.string().max(256)).max(100).optional(),
+  includeTests: z.boolean().optional(),
+  securityThreshold: SecuritySeveritySchema.optional(),
+  tokenBudget: z.number().int().nonnegative().max(10_000_000).optional(),
+  changedOnly: z.boolean().optional(),
+  baseSha: z.string().regex(/^[a-f0-9]{7,40}$/i).optional(),
+  headSha: z.string().regex(/^[a-f0-9]{7,40}$/i).optional(),
+  stagedOnly: z.boolean().optional(),
+  includeRelated: z.boolean().optional(),
+  relatedDepth: z.union([z.literal(1), z.literal(2), z.literal(3)]).optional(),
+}).strict();
+export type PackOptions = z.infer<typeof PackOptionsSchema>;
+
+/**
+ * Scan options schema
+ */
+export const ScanOptionsSchema = z.object({
+  model: TokenizerModelSchema.optional(),
+  include: z.array(z.string()).optional(),
+  exclude: z.array(z.string()).optional(),
+  includeTests: z.boolean().optional(),
+  applyDefaultIgnores: z.boolean().optional(),
+}).strict();
+export type ScanOptions = z.infer<typeof ScanOptionsSchema>;
+
+/**
+ * Chunk options schema
+ */
+export const ChunkOptionsSchema = z.object({
+  strategy: ChunkStrategySchema.optional(),
+  maxTokens: z.number().int().positive().max(100_000).optional(),
+  overlap: z.number().int().nonnegative().max(10_000).optional(),
+  model: TokenizerModelSchema.optional(),
+  format: OutputFormatSchema.optional(),
+  priorityFirst: z.boolean().optional(),
+  exclude: z.array(z.string().max(256)).max(100).optional(),
+}).strict();
+export type ChunkOptions = z.infer<typeof ChunkOptionsSchema>;
+
+/**
+ * Index options schema
+ */
+export const IndexOptionsSchema = z.object({
+  force: z.boolean().optional(),
+  includeTests: z.boolean().optional(),
+  maxFileSize: z.number().int().positive().max(100 * 1024 * 1024).optional(), // 100MB max
+  exclude: z.array(z.string().max(256)).max(100).optional(),
+  incremental: z.boolean().optional(),
+}).strict();
+export type IndexOptions = z.infer<typeof IndexOptionsSchema>;
+
+/**
+ * Diff context options schema
+ */
+export const DiffContextOptionsSchema = z.object({
+  depth: z.union([z.literal(1), z.literal(2), z.literal(3)]).optional(),
+  budget: z.number().int().positive().max(10_000_000).optional(),
+  includeDiff: z.boolean().optional(),
+  format: OutputFormatSchema.optional(),
+  model: TokenizerModelSchema.optional(),
+  exclude: z.array(z.string().max(256)).max(100).optional(),
+  include: z.array(z.string().max(256)).max(100).optional(),
+}).strict();
+export type DiffContextOptions = z.infer<typeof DiffContextOptionsSchema>;
+
+/**
+ * Impact options schema
+ */
+export const ImpactOptionsSchema = z.object({
+  depth: z.union([z.literal(1), z.literal(2), z.literal(3)]).optional(),
+  includeTests: z.boolean().optional(),
+  model: TokenizerModelSchema.optional(),
+  exclude: z.array(z.string().max(256)).max(100).optional(),
+  include: z.array(z.string().max(256)).max(100).optional(),
+}).strict();
+export type ImpactOptions = z.infer<typeof ImpactOptionsSchema>;
+
+/**
+ * Embed options schema
+ */
+export const EmbedOptionsSchema = z.object({
+  maxTokens: z.number().int().positive().max(100_000).optional(),
+  minTokens: z.number().int().nonnegative().max(10_000).optional(),
+  contextLines: z.number().int().nonnegative().max(1_000).optional(),
+  includeImports: z.boolean().optional(),
+  includeTopLevel: z.boolean().optional(),
+  includeTests: z.boolean().optional(),
+  securityScan: z.boolean().optional(),
+  includePatterns: z.array(z.string().max(256)).max(100).optional(),
+  excludePatterns: z.array(z.string().max(256)).max(100).optional(),
+  manifestPath: z.string().max(4096).refine(p => !p.includes('..'), { message: 'Path traversal not allowed' }).optional(),
+  diffOnly: z.boolean().optional(),
+}).strict();
+export type EmbedOptions = z.infer<typeof EmbedOptionsSchema>;
+
+/**
+ * Query filter schema
+ */
+export const QueryFilterSchema = z.object({
+  kinds: z.array(SymbolKindSchema).optional(),
+  excludeKinds: z.array(SymbolKindSchema).optional(),
+}).strict();
+export type QueryFilter = z.infer<typeof QueryFilterSchema>;
+
+/**
+ * Symbol filter schema
+ */
+export const SymbolFilterSchema = z.object({
+  kind: SymbolKindSchema.optional(),
+  visibility: VisibilitySchema.optional(),
+}).strict();
+export type SymbolFilter = z.infer<typeof SymbolFilterSchema>;
+
+/**
+ * Call graph options schema
+ */
+export const CallGraphOptionsSchema = z.object({
+  maxNodes: z.number().int().positive().max(100_000).optional(),
+  maxEdges: z.number().int().positive().max(100_000).optional(),
+}).strict();
+export type CallGraphOptions = z.infer<typeof CallGraphOptionsSchema>;
+
+/**
+ * Semantic compress options schema
+ */
+export const SemanticCompressOptionsSchema = z.object({
+  similarityThreshold: z.number().min(0).max(1).optional(),
+  budgetRatio: z.number().min(0).max(1).optional(),
+  minChunkSize: z.number().int().positive().max(100_000).optional(),
+  maxChunkSize: z.number().int().positive().max(100_000).optional(),
+}).strict();
+export type SemanticCompressOptions = z.infer<typeof SemanticCompressOptionsSchema>;
+
+/**
+ * Generate map options schema
+ */
+export const GenerateMapOptionsSchema = z.object({
+  budget: z.number().int().positive().max(10_000_000).optional(),
+  maxSymbols: z.number().int().positive().max(10_000).optional(),
+}).strict();
+export type GenerateMapOptions = z.infer<typeof GenerateMapOptionsSchema>;
+
+/**
+ * Transitive callers options schema
+ */
+export const TransitiveCallersOptionsSchema = z.object({
+  maxDepth: z.number().int().positive().max(100).optional(),
+  maxResults: z.number().int().positive().max(10_000).optional(),
+}).strict();
+export type TransitiveCallersOptions = z.infer<typeof TransitiveCallersOptionsSchema>;
+
+/**
+ * Call sites context options schema
+ */
+export const CallSitesContextOptionsSchema = z.object({
+  linesBefore: z.number().int().nonnegative().max(1_000).optional(),
+  linesAfter: z.number().int().nonnegative().max(1_000).optional(),
+}).strict();
+export type CallSitesContextOptions = z.infer<typeof CallSitesContextOptionsSchema>;
+
+/**
+ * Changed symbols filter schema
+ */
+export const ChangedSymbolsFilterSchema = z.object({
+  kinds: z.array(SymbolKindSchema).optional(),
+  excludeKinds: z.array(SymbolKindSchema).optional(),
+}).strict();
+export type ChangedSymbolsFilter = z.infer<typeof ChangedSymbolsFilterSchema>;
+
+/**
+ * Breaking change options schema
+ */
+export const BreakingChangeOptionsSchema = z.object({
+  oldRef: z.string().min(1),
+  newRef: z.string().min(1),
+}).strict();
+export type BreakingChangeOptions = z.infer<typeof BreakingChangeOptionsSchema>;
+
+/**
+ * Dead code options schema
+ */
+export const DeadCodeOptionsSchema = z.object({
+  paths: z.array(z.string()).optional(),
+  languages: z.array(z.string()).optional(),
+}).strict();
+export type DeadCodeOptions = z.infer<typeof DeadCodeOptionsSchema>;
+
+/**
+ * Multi-repo entry schema
+ */
+export const MultiRepoEntrySchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  path: z.string().min(1),
+}).strict();
+export type MultiRepoEntry = z.infer<typeof MultiRepoEntrySchema>;
+
+/**
+ * Multi-repo options schema
+ */
+export const MultiRepoOptionsSchema = z.object({
+  repositories: z.array(MultiRepoEntrySchema),
+}).strict();
+export type MultiRepoOptions = z.infer<typeof MultiRepoOptionsSchema>;
+
+/**
+ * Extract documentation options schema
+ */
+export const ExtractDocOptionsSchema = z.object({
+  language: z.string().min(1),
+}).strict();
+export type ExtractDocOptions = z.infer<typeof ExtractDocOptionsSchema>;
+
+/**
+ * Complexity options schema
+ */
+export const ComplexityOptionsSchema = z.object({
+  language: z.string().min(1),
+}).strict();
+export type ComplexityOptions = z.infer<typeof ComplexityOptionsSchema>;
+
+// ============================================================================
+// Validation Helper Functions
+// ============================================================================
+
+/**
+ * Validate pack options with detailed error messages
+ * @throws {z.ZodError} if validation fails
+ */
+export function validatePackOptions(input: unknown): PackOptions {
+  return PackOptionsSchema.parse(input);
+}
+
+/**
+ * Safely validate pack options, returns result object
+ */
+export function safeValidatePackOptions(input: unknown): z.SafeParseReturnType<unknown, PackOptions> {
+  return PackOptionsSchema.safeParse(input);
+}
+
+/**
+ * Validate scan options
+ * @throws {z.ZodError} if validation fails
+ */
+export function validateScanOptions(input: unknown): ScanOptions {
+  return ScanOptionsSchema.parse(input);
+}
+
+/**
+ * Safely validate scan options
+ */
+export function safeValidateScanOptions(input: unknown): z.SafeParseReturnType<unknown, ScanOptions> {
+  return ScanOptionsSchema.safeParse(input);
+}
+
+/**
+ * Validate chunk options
+ * @throws {z.ZodError} if validation fails
+ */
+export function validateChunkOptions(input: unknown): ChunkOptions {
+  return ChunkOptionsSchema.parse(input);
+}
+
+/**
+ * Safely validate chunk options
+ */
+export function safeValidateChunkOptions(input: unknown): z.SafeParseReturnType<unknown, ChunkOptions> {
+  return ChunkOptionsSchema.safeParse(input);
+}
+
+/**
+ * Validate embed options
+ * @throws {z.ZodError} if validation fails
+ */
+export function validateEmbedOptions(input: unknown): EmbedOptions {
+  return EmbedOptionsSchema.parse(input);
+}
+
+/**
+ * Safely validate embed options
+ */
+export function safeValidateEmbedOptions(input: unknown): z.SafeParseReturnType<unknown, EmbedOptions> {
+  return EmbedOptionsSchema.safeParse(input);
+}
+
+/**
+ * Validate index options
+ * @throws {z.ZodError} if validation fails
+ */
+export function validateIndexOptions(input: unknown): IndexOptions {
+  return IndexOptionsSchema.parse(input);
+}
+
+/**
+ * Safely validate index options
+ */
+export function safeValidateIndexOptions(input: unknown): z.SafeParseReturnType<unknown, IndexOptions> {
+  return IndexOptionsSchema.safeParse(input);
+}
+
+/**
+ * Validate diff context options
+ * @throws {z.ZodError} if validation fails
+ */
+export function validateDiffContextOptions(input: unknown): DiffContextOptions {
+  return DiffContextOptionsSchema.parse(input);
+}
+
+/**
+ * Safely validate diff context options
+ */
+export function safeValidateDiffContextOptions(input: unknown): z.SafeParseReturnType<unknown, DiffContextOptions> {
+  return DiffContextOptionsSchema.safeParse(input);
+}
+
+/**
+ * Validate impact options
+ * @throws {z.ZodError} if validation fails
+ */
+export function validateImpactOptions(input: unknown): ImpactOptions {
+  return ImpactOptionsSchema.parse(input);
+}
+
+/**
+ * Safely validate impact options
+ */
+export function safeValidateImpactOptions(input: unknown): z.SafeParseReturnType<unknown, ImpactOptions> {
+  return ImpactOptionsSchema.safeParse(input);
+}
+
+// ============================================================================
+// Output Schemas (for validating return values)
+// ============================================================================
+
+/**
+ * Language stat schema
+ */
+export const LanguageStatSchema = z.object({
+  language: z.string(),
+  files: z.number().int().nonnegative(),
+  lines: z.number().int().nonnegative(),
+  percentage: z.number().min(0).max(100),
+});
+export type LanguageStat = z.infer<typeof LanguageStatSchema>;
+
+/**
+ * Scan stats schema
+ */
+export const ScanStatsSchema = z.object({
+  name: z.string(),
+  totalFiles: z.number().int().nonnegative(),
+  totalLines: z.number().int().nonnegative(),
+  totalTokens: z.number().int().nonnegative(),
+  primaryLanguage: z.string().optional(),
+  languages: z.array(LanguageStatSchema),
+  securityFindings: z.number().int().nonnegative(),
+});
+export type ScanStats = z.infer<typeof ScanStatsSchema>;
+
+/**
+ * Security finding schema
+ */
+export const SecurityFindingSchema = z.object({
+  file: z.string(),
+  line: z.number().int().positive(),
+  severity: z.string(),
+  kind: z.string(),
+  pattern: z.string(),
+});
+export type SecurityFinding = z.infer<typeof SecurityFindingSchema>;
+
+/**
+ * Index status schema
+ */
+export const IndexStatusSchema = z.object({
+  exists: z.boolean(),
+  fileCount: z.number().int().nonnegative(),
+  symbolCount: z.number().int().nonnegative(),
+  lastBuilt: z.string().optional(),
+  version: z.string().optional(),
+  filesUpdated: z.number().int().nonnegative().optional(),
+  incremental: z.boolean().optional(),
+});
+export type IndexStatus = z.infer<typeof IndexStatusSchema>;
+
+/**
+ * Symbol info schema
+ */
+export const SymbolInfoSchema = z.object({
+  id: z.number().int().nonnegative(),
+  name: z.string(),
+  kind: z.string(),
+  file: z.string(),
+  line: z.number().int().positive(),
+  endLine: z.number().int().positive(),
+  signature: z.string().optional(),
+  visibility: z.string(),
+});
+export type SymbolInfo = z.infer<typeof SymbolInfoSchema>;
+
+/**
+ * Embed chunk schema
+ */
+export const EmbedChunkSchema = z.object({
+  id: z.string().regex(/^ec_[a-f0-9]{32}$/),
+  fullHash: z.string(),
+  content: z.string(),
+  tokens: z.number().int().nonnegative(),
+  kind: z.string(),
+  source: z.object({
+    file: z.string(),
+    linesStart: z.number().int().positive(),
+    linesEnd: z.number().int().positive(),
+    symbol: z.string(),
+    fqn: z.string().optional(),
+    language: z.string(),
+    parent: z.string().optional(),
+    visibility: z.string(),
+    isTest: z.boolean(),
+  }),
+  context: z.object({
+    docstring: z.string().optional(),
+    comments: z.array(z.string()),
+    signature: z.string().optional(),
+    calls: z.array(z.string()),
+    calledBy: z.array(z.string()),
+    imports: z.array(z.string()),
+    tags: z.array(z.string()),
+    linesOfCode: z.number().int().nonnegative(),
+    maxNestingDepth: z.number().int().nonnegative(),
+  }),
+  part: z.object({
+    part: z.number().int().positive(),
+    of: z.number().int().positive(),
+    parentId: z.string(),
+    parentSignature: z.string().optional(),
+  }).optional(),
+});
+export type EmbedChunk = z.infer<typeof EmbedChunkSchema>;
+
+/**
+ * Embed diff summary schema
+ */
+export const EmbedDiffSummarySchema = z.object({
+  added: z.number().int().nonnegative(),
+  modified: z.number().int().nonnegative(),
+  removed: z.number().int().nonnegative(),
+  unchanged: z.number().int().nonnegative(),
+  totalChunks: z.number().int().nonnegative(),
+});
+export type EmbedDiffSummary = z.infer<typeof EmbedDiffSummarySchema>;
+
+/**
+ * Embed result schema
+ */
+export const EmbedResultSchema = z.object({
+  chunks: z.array(EmbedChunkSchema),
+  diff: EmbedDiffSummarySchema.optional(),
+  manifestVersion: z.number().int().nonnegative(),
+  elapsedMs: z.number().int().nonnegative(),
+});
+export type EmbedResult = z.infer<typeof EmbedResultSchema>;

package/tsconfig.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": ".",
+    "strict": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": [
+    "types.ts",
+    "schemas.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "*.node",
+    "*.js"
+  ]
+}

package/types.ts

@@ -0,0 +1,588 @@
+/**
+ * Strict TypeScript types for infiniloom-node
+ *
+ * These types provide string literal unions for better type safety
+ * compared to the auto-generated index.d.ts which uses generic strings.
+ *
+ * Usage:
+ * ```typescript
+ * import type { StrictPackOptions, OutputFormat, TokenizerModel } from 'infiniloom-node/types';
+ * import { pack } from 'infiniloom-node';
+ *
+ * const options: StrictPackOptions = {
+ *   format: 'xml',  // Type-checked!
+ *   model: 'claude',
+ *   compression: 'balanced'
+ * };
+ *
+ * const output = pack('./repo', options);
+ * ```
+ */
+
+// Re-export base types from auto-generated index
+export type {
+  ScanStats,
+  LanguageStat,
+  GitFileStatus,
+  GitChangedFile,
+  GitCommit,
+  GitBlameLine,
+  GitDiffLine,
+  GitDiffHunk,
+  SecurityFinding,
+  IndexStatus,
+  SymbolInfo,
+  ReferenceInfo,
+  CallGraphEdge,
+  CallGraphStats,
+  CallGraph,
+  DependencyCycle,
+  SymbolSourceResult,
+  RepoChunk,
+  AffectedSymbol,
+  DiffFileContext,
+  ContextSymbolInfo,
+  CallSite,
+  CallSiteWithContext,
+  ChangedSymbolInfo,
+  TransitiveCallerInfo,
+  EmbedChunkSource,
+  EmbedChunkContext,
+  EmbedChunkPart,
+  EmbedChunk,
+  EmbedDiffSummary,
+  EmbedResult,
+  EmbedManifestStatus,
+  JsTypeInfo,
+  JsParameterInfo,
+  JsGenericParam,
+  JsTypeSignature,
+  JsParamDoc,
+  JsReturnDoc,
+  JsThrowsDoc,
+  JsExample,
+  JsDocumentation,
+  JsAncestorInfo,
+  JsTypeHierarchy,
+  JsHalsteadMetrics,
+  JsLocMetrics,
+  JsComplexityMetrics,
+  JsUnusedExport,
+  JsUnreachableCode,
+  JsUnusedSymbol,
+  JsUnusedImport,
+  JsUnusedVariable,
+  JsDeadCodeInfo,
+  JsBreakingChange,
+  JsBreakingChangeSummary,
+  JsBreakingChangeReport,
+  JsRepoEntry,
+  JsCrossRepoLink,
+  JsUnifiedSymbolRef,
+  JsMultiRepoStats,
+} from './index';
+
+// ============================================================================
+// String Literal Union Types
+// ============================================================================
+
+/**
+ * Output format for pack/chunk operations
+ * - xml: Optimized for Claude (CDATA sections, structured XML)
+ * - markdown: Optimized for GPT models (fenced code blocks)
+ * - json: Machine-readable JSON format
+ * - yaml: Optimized for Gemini (query at end)
+ * - toon: Token-efficient format (30-40% fewer tokens)
+ * - plain: Plain text format
+ */
+export type OutputFormat = 'xml' | 'markdown' | 'json' | 'yaml' | 'toon' | 'plain';
+
+/**
+ * Supported LLM tokenizer models
+ *
+ * OpenAI models (exact via tiktoken):
+ * - gpt-5.2, gpt-5.1, gpt-5, o4-mini, o3, o1, gpt-4o, gpt-4o-mini: o200k_base encoding
+ * - gpt-4, gpt-4-turbo, gpt-3.5-turbo: cl100k_base encoding
+ *
+ * Other models (calibrated estimation):
+ * - claude: Anthropic Claude models
+ * - gemini, gemini-1.5, gemini-2.0: Google Gemini models
+ * - llama, llama-3, llama-3.1, llama-3.2, codellama: Meta Llama models
+ * - mistral, mixtral: Mistral AI models
+ * - deepseek, deepseek-v3: DeepSeek models
+ * - qwen, qwen-2.5: Alibaba Qwen models
+ * - cohere, command-r: Cohere models
+ * - grok: xAI Grok models
+ */
+export type TokenizerModel =
+  // OpenAI models (exact tokenization via tiktoken)
+  | 'gpt-5.2'
+  | 'gpt-5.2-pro'
+  | 'gpt-5.1'
+  | 'gpt-5.1-mini'
+  | 'gpt-5.1-codex'
+  | 'gpt-5'
+  | 'gpt-5-mini'
+  | 'gpt-5-nano'
+  | 'o4-mini'
+  | 'o3'
+  | 'o3-mini'
+  | 'o1'
+  | 'o1-mini'
+  | 'o1-preview'
+  | 'gpt-4o'
+  | 'gpt-4o-mini'
+  | 'gpt-4'
+  | 'gpt-4-turbo'
+  | 'gpt-3.5-turbo'
+  // Anthropic
+  | 'claude'
+  // Google
+  | 'gemini'
+  | 'gemini-1.5'
+  | 'gemini-2.0'
+  // Meta
+  | 'llama'
+  | 'llama-3'
+  | 'llama-3.1'
+  | 'llama-3.2'
+  | 'codellama'
+  // Mistral
+  | 'mistral'
+  | 'mixtral'
+  // DeepSeek
+  | 'deepseek'
+  | 'deepseek-v3'
+  // Alibaba
+  | 'qwen'
+  | 'qwen-2.5'
+  // Cohere
+  | 'cohere'
+  | 'command-r'
+  // xAI
+  | 'grok';
+
+/**
+ * Compression level for output
+ * - none: No compression, full output
+ * - minimal: Light compression (remove blank lines)
+ * - balanced: Moderate compression (recommended)
+ * - aggressive: Heavy compression (remove comments, simplify)
+ * - extreme: Maximum compression (signatures only)
+ * - focused: Focus on key symbols
+ * - semantic: AI-aware semantic compression
+ */
+export type CompressionLevel =
+  | 'none'
+  | 'minimal'
+  | 'balanced'
+  | 'aggressive'
+  | 'extreme'
+  | 'focused'
+  | 'semantic';
+
+/**
+ * Security severity levels
+ */
+export type SecuritySeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+
+/**
+ * Git file status
+ */
+export type GitStatus = 'Added' | 'Modified' | 'Deleted' | 'Renamed' | 'Copied' | 'Unknown';
+
+/**
+ * Diff line change type
+ */
+export type DiffChangeType = 'add' | 'remove' | 'context';
+
+/**
+ * Symbol kinds (matches Rust SymbolKind enum)
+ */
+export type SymbolKind =
+  | 'function'
+  | 'method'
+  | 'class'
+  | 'struct'
+  | 'interface'
+  | 'trait'
+  | 'enum'
+  | 'constant'
+  | 'variable'
+  | 'import'
+  | 'export'
+  | 'type'
+  | 'module'
+  | 'macro';
+
+/**
+ * Symbol visibility
+ */
+export type Visibility = 'public' | 'private' | 'protected' | 'internal';
+
+/**
+ * Impact type for affected symbols
+ */
+export type ImpactType = 'direct' | 'caller' | 'callee' | 'dependent';
+
+/**
+ * Impact level for analysis results
+ */
+export type ImpactLevel = 'low' | 'medium' | 'high' | 'critical';
+
+/**
+ * Reference kind
+ */
+export type ReferenceKind = 'call' | 'import' | 'inherit' | 'implement';
+
+/**
+ * Context symbol reason
+ */
+export type ContextReason = 'changed' | 'caller' | 'callee' | 'dependent';
+
+/**
+ * Change type for symbols
+ */
+export type ChangeType = 'added' | 'modified' | 'deleted';
+
+/**
+ * Chunking strategy
+ */
+export type ChunkStrategy =
+  | 'fixed'
+  | 'file'
+  | 'module'
+  | 'symbol'
+  | 'semantic'
+  | 'dependency';
+
+/**
+ * Embed chunk kind (matches Rust ChunkKind enum)
+ */
+export type EmbedChunkKind =
+  | 'function'
+  | 'method'
+  | 'class'
+  | 'struct'
+  | 'enum'
+  | 'interface'
+  | 'trait'
+  | 'module'
+  | 'constant'
+  | 'variable'
+  | 'imports'
+  | 'top_level'
+  | 'function_part'
+  | 'class_part';
+
+/**
+ * Breaking change type
+ */
+export type BreakingChangeType =
+  | 'removed'
+  | 'signature_changed'
+  | 'type_changed'
+  | 'visibility_reduced'
+  | 'parameter_added'
+  | 'parameter_removed'
+  | 'return_type_changed';
+
+/**
+ * Breaking change severity
+ */
+export type ChangeSeverity = 'critical' | 'high' | 'medium' | 'low';
+
+/**
+ * Cross-repo link type
+ */
+export type CrossRepoLinkType = 'import' | 'call' | 'inherit' | 'implement';
+
+/**
+ * Variance for generic parameters
+ */
+export type GenericVariance = 'invariant' | 'covariant' | 'contravariant' | 'bivariant';
+
+/**
+ * Parameter kind
+ */
+export type ParameterKind = 'positional' | 'named' | 'rest' | 'keyword_only' | 'positional_only';
+
+// ============================================================================
+// Strict Option Interfaces
+// ============================================================================
+
+/**
+ * Strict pack options with literal union types
+ */
+export interface StrictPackOptions {
+  /** Output format with strict typing */
+  format?: OutputFormat;
+  /** Target model with strict typing */
+  model?: TokenizerModel;
+  /** Compression level with strict typing */
+  compression?: CompressionLevel;
+  /** Token budget for repository map */
+  mapBudget?: number;
+  /** Maximum number of symbols in map */
+  maxSymbols?: number;
+  /** Skip security scanning */
+  skipSecurity?: boolean;
+  /** Redact detected secrets in output */
+  redactSecrets?: boolean;
+  /** Skip symbol extraction */
+  skipSymbols?: boolean;
+  /** Glob patterns to include */
+  include?: readonly string[];
+  /** Glob patterns to exclude */
+  exclude?: readonly string[];
+  /** Include test files */
+  includeTests?: boolean;
+  /** Minimum security severity to block on */
+  securityThreshold?: SecuritySeverity;
+  /** Token budget for total output (0 = no limit) */
+  tokenBudget?: number;
+  /** Only include files changed in git */
+  changedOnly?: boolean;
+  /** Base SHA/ref for diff comparison */
+  baseSha?: string;
+  /** Head SHA/ref for diff comparison */
+  headSha?: string;
+  /** Include staged changes only */
+  stagedOnly?: boolean;
+  /** Include related files */
+  includeRelated?: boolean;
+  /** Depth for related file traversal (1-3) */
+  relatedDepth?: 1 | 2 | 3;
+}
+
+/**
+ * Strict scan options with literal union types
+ */
+export interface StrictScanOptions {
+  /** Target model for token counting */
+  model?: TokenizerModel;
+  /** Glob patterns to include */
+  include?: readonly string[];
+  /** Glob patterns to exclude */
+  exclude?: readonly string[];
+  /** Include test files */
+  includeTests?: boolean;
+  /** Apply default ignores */
+  applyDefaultIgnores?: boolean;
+}
+
+/**
+ * Strict chunk options with literal union types
+ */
+export interface StrictChunkOptions {
+  /** Chunking strategy */
+  strategy?: ChunkStrategy;
+  /** Maximum tokens per chunk */
+  maxTokens?: number;
+  /** Token overlap between chunks */
+  overlap?: number;
+  /** Target model for token counting */
+  model?: TokenizerModel;
+  /** Output format */
+  format?: OutputFormat;
+  /** Sort chunks by priority */
+  priorityFirst?: boolean;
+  /** Directories/patterns to exclude */
+  exclude?: readonly string[];
+}
+
+/**
+ * Strict diff context options
+ */
+export interface StrictDiffContextOptions {
+  /** Depth of context expansion (1-3) */
+  depth?: 1 | 2 | 3;
+  /** Token budget for context */
+  budget?: number;
+  /** Include the actual diff content */
+  includeDiff?: boolean;
+  /** Output format */
+  format?: OutputFormat;
+  /** Target model for token counting */
+  model?: TokenizerModel;
+  /** Glob patterns to exclude */
+  exclude?: readonly string[];
+  /** Glob patterns to include */
+  include?: readonly string[];
+}
+
+/**
+ * Strict impact options
+ */
+export interface StrictImpactOptions {
+  /** Depth of dependency traversal (1-3) */
+  depth?: 1 | 2 | 3;
+  /** Include test files in analysis */
+  includeTests?: boolean;
+  /** Target model for token counting */
+  model?: TokenizerModel;
+  /** Glob patterns to exclude */
+  exclude?: readonly string[];
+  /** Glob patterns to include */
+  include?: readonly string[];
+}
+
+/**
+ * Strict embed options
+ */
+export interface StrictEmbedOptions {
+  /** Maximum tokens per chunk */
+  maxTokens?: number;
+  /** Minimum tokens for a chunk */
+  minTokens?: number;
+  /** Lines of context around symbols */
+  contextLines?: number;
+  /** Include imports in chunks */
+  includeImports?: boolean;
+  /** Include top-level code */
+  includeTopLevel?: boolean;
+  /** Include test files */
+  includeTests?: boolean;
+  /** Enable secret scanning */
+  securityScan?: boolean;
+  /** Include patterns (glob) */
+  includePatterns?: readonly string[];
+  /** Exclude patterns (glob) */
+  excludePatterns?: readonly string[];
+  /** Path to manifest file */
+  manifestPath?: string;
+  /** Only return changed chunks (diff mode) */
+  diffOnly?: boolean;
+}
+
+/**
+ * Strict query filter
+ */
+export interface StrictQueryFilter {
+  /** Filter by symbol kinds */
+  kinds?: readonly SymbolKind[];
+  /** Exclude specific kinds */
+  excludeKinds?: readonly SymbolKind[];
+}
+
+/**
+ * Strict symbol filter
+ */
+export interface StrictSymbolFilter {
+  /** Filter by symbol kind */
+  kind?: SymbolKind;
+  /** Filter by visibility */
+  visibility?: Visibility;
+}
+
+/**
+ * Strict index options
+ */
+export interface StrictIndexOptions {
+  /** Force full rebuild */
+  force?: boolean;
+  /** Include test files */
+  includeTests?: boolean;
+  /** Maximum file size to index (bytes) */
+  maxFileSize?: number;
+  /** Directories/patterns to exclude */
+  exclude?: readonly string[];
+  /** Incremental update */
+  incremental?: boolean;
+}
+
+// ============================================================================
+// Type Guards
+// ============================================================================
+
+/**
+ * Type guard for OutputFormat
+ */
+export function isOutputFormat(value: unknown): value is OutputFormat {
+  return (
+    typeof value === 'string' &&
+    ['xml', 'markdown', 'json', 'yaml', 'toon', 'plain'].includes(value)
+  );
+}
+
+/**
+ * Type guard for TokenizerModel
+ */
+export function isTokenizerModel(value: unknown): value is TokenizerModel {
+  const models: TokenizerModel[] = [
+    // OpenAI models (exact tokenization via tiktoken)
+    'gpt-5.2', 'gpt-5.2-pro', 'gpt-5.1', 'gpt-5.1-mini', 'gpt-5.1-codex',
+    'gpt-5', 'gpt-5-mini', 'gpt-5-nano',
+    'o4-mini', 'o3', 'o3-mini', 'o1', 'o1-mini', 'o1-preview',
+    'gpt-4o', 'gpt-4o-mini', 'gpt-4', 'gpt-4-turbo', 'gpt-3.5-turbo',
+    // Anthropic
+    'claude',
+    // Google
+    'gemini', 'gemini-1.5', 'gemini-2.0',
+    // Meta
+    'llama', 'llama-3', 'llama-3.1', 'llama-3.2', 'codellama',
+    // Mistral
+    'mistral', 'mixtral',
+    // DeepSeek
+    'deepseek', 'deepseek-v3',
+    // Alibaba
+    'qwen', 'qwen-2.5',
+    // Cohere
+    'cohere', 'command-r',
+    // xAI
+    'grok',
+  ];
+  return typeof value === 'string' && models.includes(value as TokenizerModel);
+}
+
+/**
+ * Type guard for CompressionLevel
+ */
+export function isCompressionLevel(value: unknown): value is CompressionLevel {
+  return (
+    typeof value === 'string' &&
+    ['none', 'minimal', 'balanced', 'aggressive', 'extreme', 'focused', 'semantic'].includes(value)
+  );
+}
+
+/**
+ * Type guard for SymbolKind
+ */
+export function isSymbolKind(value: unknown): value is SymbolKind {
+  const kinds: SymbolKind[] = [
+    'function', 'method', 'class', 'struct', 'interface', 'trait',
+    'enum', 'constant', 'variable', 'import', 'export', 'type', 'module', 'macro',
+  ];
+  return typeof value === 'string' && kinds.includes(value as SymbolKind);
+}
+
+/**
+ * Type guard for SecuritySeverity
+ */
+export function isSecuritySeverity(value: unknown): value is SecuritySeverity {
+  return (
+    typeof value === 'string' &&
+    ['critical', 'high', 'medium', 'low', 'info'].includes(value)
+  );
+}
+
+// ============================================================================
+// Utility Types
+// ============================================================================
+
+/**
+ * Make specific properties required
+ */
+export type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
+
+/**
+ * Make all properties readonly and non-nullable
+ */
+export type Strict<T> = {
+  readonly [P in keyof T]-?: NonNullable<T[P]>;
+};
+
+/**
+ * Extract the element type from an array type
+ */
+export type ElementOf<T> = T extends readonly (infer E)[] ? E : never;