@struktur/sdk 2.1.1 → 2.2.0

package/src/debug/logger.ts

@@ -1,211 +0,0 @@
-import type { Artifact, ArtifactContent, ExtractionEvents, Usage, StepInfo, ProgressInfo, RetryInfo, TokenUsageInfo } from "../types";
-
-export type DebugLogger = ReturnType<typeof createDebugLogger>;
-
-export const createDebugLogger = (enabled: boolean) => {
-  const log = (entry: Record<string, unknown>) => {
-    if (!enabled) return;
-    const timestamp = new Date().toISOString();
-    const logEntry = { timestamp, ...entry };
-    process.stderr.write(JSON.stringify(logEntry) + "\n");
-  };
-
-  return {
-    // CLI initialization
-    cliInit: (data: { args: Record<string, unknown> }) => {
-      log({ type: "cli_init", ...data });
-    },
-
-    schemaLoaded: (data: { source: string; schemaSize: number }) => {
-      log({ type: "schema_loaded", ...data });
-    },
-
-    artifactsLoaded: (data: { 
-      count: number; 
-      artifacts: Array<{ id: string; type: string; contentCount: number; tokens?: number }>;
-      totalTokens: number;
-      totalImages: number;
-    }) => {
-      log({ type: "artifacts_loaded", ...data });
-    },
-
-    modelResolved: (data: { modelSpec: string; resolvedModel: string }) => {
-      log({ type: "model_resolved", ...data });
-    },
-
-    strategyCreated: (data: { strategy: string; config: Record<string, unknown> }) => {
-      log({ type: "strategy_created", ...data });
-    },
-
-    // Chunking
-    chunkingStart: (data: { 
-      artifactId: string; 
-      totalTokens: number; 
-      maxTokens: number;
-      maxImages?: number;
-    }) => {
-      log({ type: "chunking_start", ...data });
-    },
-
-    chunkingSplit: (data: {
-      artifactId: string;
-      originalContentCount: number;
-      splitContentCount: number;
-      splitReason: "text_too_long" | "content_limit";
-      originalTokens: number;
-      chunkSize: number;
-    }) => {
-      log({ type: "chunking_split", ...data });
-    },
-
-    chunkingResult: (data: {
-      artifactId: string;
-      chunksCreated: number;
-      chunkSizes: number[];
-    }) => {
-      log({ type: "chunking_result", ...data });
-    },
-
-    batchingStart: (data: {
-      totalArtifacts: number;
-      maxTokens: number;
-      maxImages?: number;
-      modelMaxTokens?: number;
-      effectiveMaxTokens: number;
-    }) => {
-      log({ type: "batching_start", ...data });
-    },
-
-    batchCreated: (data: {
-      batchIndex: number;
-      artifactCount: number;
-      totalTokens: number;
-      totalImages: number;
-      artifactIds: string[];
-    }) => {
-      log({ type: "batch_created", ...data });
-    },
-
-    batchingComplete: (data: {
-      totalBatches: number;
-      batches: Array<{ index: number; artifactCount: number; tokens: number; images: number }>;
-    }) => {
-      log({ type: "batching_complete", ...data });
-    },
-
-    // Strategy execution
-    strategyRunStart: (data: { strategy: string; estimatedSteps: number; artifactCount: number }) => {
-      log({ type: "strategy_run_start", ...data });
-    },
-
-    step: (data: StepInfo & { strategy: string }) => {
-      log({ type: "step", ...data });
-    },
-
-    progress: (data: ProgressInfo & { strategy: string; context?: string }) => {
-      log({ type: "progress", ...data });
-    },
-
-    // LLM calls
-    llmCallStart: (data: {
-      callId: string;
-      model: string;
-      schemaName?: string;
-      systemLength: number;
-      userLength: number;
-      artifactCount: number;
-    }) => {
-      log({ type: "llm_call_start", ...data });
-    },
-
-    llmCallComplete: (data: {
-      callId: string;
-      success: boolean;
-      inputTokens: number;
-      outputTokens: number;
-      totalTokens: number;
-      durationMs?: number;
-      error?: string;
-    }) => {
-      log({ type: "llm_call_complete", ...data });
-    },
-
-    // Retry events
-    retry: (data: RetryInfo & { callId: string }) => {
-      log({ type: "retry", ...data });
-    },
-
-    // Validation
-    validationStart: (data: { callId: string; attempt: number; maxAttempts: number; strict: boolean }) => {
-      log({ type: "validation_start", ...data });
-    },
-
-    validationSuccess: (data: { callId: string; attempt: number }) => {
-      log({ type: "validation_success", ...data });
-    },
-
-    validationFailed: (data: { callId: string; attempt: number; errors: unknown[] }) => {
-      log({ type: "validation_failed", ...data });
-    },
-
-    // Merging
-    mergeStart: (data: { mergeId: string; inputCount: number; strategy: string }) => {
-      log({ type: "merge_start", ...data });
-    },
-
-    mergeComplete: (data: { mergeId: string; success: boolean; error?: string }) => {
-      log({ type: "merge_complete", ...data });
-    },
-
-    // Deduplication
-    dedupeStart: (data: { dedupeId: string; itemCount: number }) => {
-      log({ type: "dedupe_start", ...data });
-    },
-
-    dedupeComplete: (data: { dedupeId: string; duplicatesFound: number; itemsRemoved: number }) => {
-      log({ type: "dedupe_complete", ...data });
-    },
-
-    // Token usage tracking
-    tokenUsage: (data: TokenUsageInfo & { context: string }) => {
-      log({ type: "token_usage", ...data });
-    },
-
-    // Results
-    extractionComplete: (data: {
-      success: boolean;
-      totalInputTokens: number;
-      totalOutputTokens: number;
-      totalTokens: number;
-      error?: string;
-    }) => {
-      log({ type: "extraction_complete", ...data });
-    },
-
-    // Prompt details (verbose)
-    promptSystem: (data: { callId: string; system: string }) => {
-      log({ type: "prompt_system", ...data });
-    },
-
-    promptUser: (data: { callId: string; user: unknown }) => {
-      log({ type: "prompt_user", ...data });
-    },
-
-    // Raw response
-    rawResponse: (data: { callId: string; response: unknown }) => {
-      log({ type: "raw_response", ...data });
-    },
-
-    // Smart merge details
-    smartMergeField: (data: {
-      mergeId: string;
-      field: string;
-      operation: "merge_arrays" | "merge_objects" | "replace" | "concat";
-      leftCount?: number;
-      rightCount?: number;
-      resultCount?: number;
-    }) => {
-      log({ type: "smart_merge_field", ...data });
-    },
-  };
-};

package/src/extract.test.ts

@@ -1,22 +0,0 @@
-import { test, expect } from "bun:test";
-import { extract } from "./extract";
-import type { ExtractionStrategy, ExtractionOptions } from "./types";
-
-test("extract delegates to strategy", async () => {
-  const strategy: ExtractionStrategy<{ ok: boolean }> = {
-    name: "mock",
-    run: async () => ({
-      data: { ok: true },
-      usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
-    }),
-  };
-
-  const options: ExtractionOptions<{ ok: boolean }> = {
-    artifacts: [],
-    schema: {},
-    strategy,
-  };
-
-  const result = await extract(options);
-  expect(result.data.ok).toBe(true);
-});

package/src/extract.ts

@@ -1,150 +0,0 @@
-import type { ExtractionOptions, ExtractionResult } from "./types";
-import { buildSchemaFromFields } from "./fields";
-
-const emptyUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-
-/**
- * Resolve and validate the schema from ExtractionOptions.
- * Exactly one of `schema` or `fields` must be provided.
- */
-const resolveSchema = <T>(options: ExtractionOptions<T>) => {
-  const hasSchema = options.schema !== undefined;
-  const hasFields = options.fields !== undefined;
-
-  if (hasSchema && hasFields) {
-    throw new Error(
-      "Provide either `schema` or `fields`, not both. They are mutually exclusive.",
-    );
-  }
-
-  if (!hasSchema && !hasFields) {
-    throw new Error(
-      "A schema definition is required. Provide `schema` (a JSON Schema object) or `fields` (a shorthand fields string).",
-    );
-  }
-
-  if (hasFields) {
-    return buildSchemaFromFields(options.fields as string);
-  }
-
-  return options.schema as NonNullable<typeof options.schema>;
-};
-
-export const extract = async <T>(
-  options: ExtractionOptions<T>,
-): Promise<ExtractionResult<T>> => {
-  const debug = options.debug;
-  const telemetry = options.telemetry;
-
-  // Initialize telemetry if provided
-  if (telemetry) {
-    await telemetry.initialize();
-  }
-
-  // Start root extraction span
-  const rootSpan = telemetry?.startSpan({
-    name: "struktur.extract",
-    kind: "CHAIN",
-    attributes: {
-      "extraction.strategy": options.strategy?.name ?? "default",
-      "extraction.artifacts.count": options.artifacts.length,
-    },
-  });
-
-  try {
-    // Validate mutual exclusion and resolve the concrete schema early so that
-    // every strategy receives a fully-populated options object.
-    let resolvedOptions: ExtractionOptions<T>;
-    try {
-      const schema = resolveSchema(options);
-      resolvedOptions = { ...options, schema };
-    } catch (error) {
-      debug?.extractionComplete({
-        success: false,
-        totalInputTokens: 0,
-        totalOutputTokens: 0,
-        totalTokens: 0,
-        error: (error as Error).message,
-      });
-
-      telemetry?.endSpan(rootSpan!, {
-        status: "error",
-        error: error as Error,
-      });
-      await telemetry?.shutdown();
-
-      return {
-        data: null as unknown as T,
-        usage: emptyUsage,
-        error: error as Error,
-      };
-    }
-
-    const total = resolvedOptions.strategy.getEstimatedSteps?.(resolvedOptions.artifacts);
-
-    debug?.strategyRunStart({
-      strategy: resolvedOptions.strategy.name,
-      estimatedSteps: total ?? 1,
-      artifactCount: resolvedOptions.artifacts.length,
-    });
-
-    await resolvedOptions.events?.onStep?.({ step: 1, total, label: "start" });
-    debug?.step({
-      step: 1,
-      total,
-      label: "start",
-      strategy: resolvedOptions.strategy.name,
-    });
-
-    const result = await resolvedOptions.strategy.run(resolvedOptions);
-
-    await resolvedOptions.events?.onStep?.({
-      step: total ?? 1,
-      total,
-      label: "complete",
-    });
-    debug?.step({
-      step: total ?? 1,
-      total,
-      label: "complete",
-      strategy: resolvedOptions.strategy.name,
-    });
-
-    debug?.extractionComplete({
-      success: !result.error,
-      totalInputTokens: result.usage.inputTokens,
-      totalOutputTokens: result.usage.outputTokens,
-      totalTokens: result.usage.totalTokens,
-      error: result.error?.message,
-    });
-
-    telemetry?.endSpan(rootSpan!, {
-      status: result.error ? "error" : "ok",
-      output: result.data,
-      error: result.error,
-    });
-    await telemetry?.shutdown();
-
-    return result;
-  } catch (error) {
-    debug?.extractionComplete({
-      success: false,
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalTokens: 0,
-      error: (error as Error).message,
-    });
-
-    telemetry?.endSpan(rootSpan!, {
-      status: "error",
-      error: error as Error,
-    });
-    await telemetry?.shutdown();
-
-    return {
-      data: null as unknown as T,
-      usage: emptyUsage,
-      error: error as Error,
-    };
-  }
-};