@lingjingai/scriptctl 0.63.14 → 0.63.15

package/dist/cli.d.ts

@@ -1,5 +1,214 @@
-import { Command } from "commander";
-import { type RunState } from "./cli/registry.js";
-import { type LlmComposition } from "./llm/composition.js";
-export declare function buildProgram(state: RunState, llm?: LlmComposition): Command;
-export declare function main(argv?: string[] | null, llm?: LlmComposition): Promise<number>;
+import { Command } from 'commander';
+
+interface RunState {
+    jsonMode: boolean;
+    exitCode: number;
+    format?: string;
+}
+
+declare const FAILURE_CODES: {
+    readonly policy: readonly ["content_blocked"];
+    readonly network: readonly ["dns_failed", "connection_refused", "connection_reset", "network_unreachable", "tls_failed", "network_failed"];
+    readonly timeout: readonly ["connect_timeout", "request_timeout", "media_processing_timeout"];
+    readonly rate_limit: readonly ["rate_limited"];
+    readonly authentication: readonly ["authentication_failed"];
+    readonly authorization: readonly ["permission_denied"];
+    readonly provider: readonly ["resource_not_found", "provider_unavailable", "request_rejected", "attempts_exhausted"];
+    readonly media: readonly ["media_upload_failed", "media_processing_failed", "media_too_large", "unsupported_media"];
+    readonly response: readonly ["output_truncated", "empty_response", "malformed_response"];
+    readonly pipeline: readonly ["serial_parse_failed", "source_mismatch", "pipeline_mismatch"];
+    readonly validation: readonly ["script_validation_failed"];
+    readonly cancelled: readonly ["cancelled"];
+    readonly unknown: readonly ["unknown", "legacy_unclassified"];
+};
+type FailureCodeByType = {
+    [Type in keyof typeof FAILURE_CODES]: (typeof FAILURE_CODES)[Type][number];
+};
+type FailureType = keyof typeof FAILURE_CODES;
+type FailureClassification = {
+    [Type in FailureType]: {
+        failure_type: Type;
+        failure_code: FailureCodeByType[Type];
+    };
+}[FailureType];
+type GeminiPolicySource = "prompt" | "candidate";
+type GeminiPolicyReason = "SAFETY" | "PROHIBITED_CONTENT" | "BLOCKLIST" | "SPII" | "RECITATION" | "IMAGE_SAFETY" | "IMAGE_PROHIBITED_CONTENT" | "IMAGE_RECITATION" | "ESCALATION" | "OTHER" | "UNSPECIFIED" | "UNKNOWN";
+interface ProviderSafetyRating {
+    category: string;
+    probability: string;
+    blocked: boolean;
+}
+interface FailureContext {
+    provider?: string;
+    model?: string;
+    operation?: string;
+    http_status?: number;
+    system_code?: string;
+    provider_source?: GeminiPolicySource;
+    provider_reason?: GeminiPolicyReason;
+    provider_reason_raw?: string;
+    finish_message?: string;
+    safety_ratings?: ProviderSafetyRating[];
+    details?: string[];
+}
+type OperationalFailure = FailureClassification & FailureContext & {
+    retryable: boolean;
+    message: string;
+};
+
+type LlmProtocol = "anthropic" | "openai-compatible" | "google-gemini";
+type LlmTaskId = "direct.episode-titles" | "direct.batch-extract" | "direct.episode-synopsis" | "direct.synopsis-reduction" | "direct.script-synopsis" | "direct.asset-grouping" | "direct.asset-curation" | "direct.asset-curation-audit" | "direct.location-canonicalization" | "direct.state-curation" | "direct.state-binding" | "metadata.global" | "metadata.descriptions" | "synopsis.chunk" | "synopsis.episode" | "synopsis.arc" | "synopsis.script-overview" | "ingest.body-start" | "ingest.arc-summary" | "ingest.text-normalize" | "ingest.episode-assets" | "ingest.name-fix" | "ingest.mention-resolve" | "ingest.asset-extract" | "ingest.asset-curate" | "ingest.asset-recall" | "ingest.asset-refine" | "ingest.state-reconcile" | "ingest.asset-audit" | "ingest.speaker-audit" | "ingest.video-serial";
+type JsonSchema = Record<string, unknown>;
+interface TextGenerationRequest {
+    system: string;
+    user: string;
+    maxOutputTokens: number;
+    responseFormat?: "json_object";
+    signal?: AbortSignal;
+}
+interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: JsonSchema;
+}
+interface ToolGenerationRequest extends TextGenerationRequest {
+    tool: ToolDefinition;
+}
+interface TokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedInputTokens?: number;
+    cacheCreationTokens?: number;
+}
+interface TextGenerationResponse {
+    text: string;
+    finishReason: string;
+    attempts: number;
+    usage?: TokenUsage;
+    raw?: unknown;
+}
+interface ToolGenerationResponse {
+    input: unknown;
+    finishReason: string;
+    attempts: number;
+    usage?: TokenUsage;
+    raw?: unknown;
+}
+interface VideoFileHandle {
+    name: string;
+    uri: string;
+    mimeType: string;
+}
+type VideoUploadMode = "file-api" | "base64";
+type VideoMediaInput = {
+    kind: "file-api";
+    file: VideoFileHandle;
+} | {
+    kind: "base64";
+    data: string;
+    mimeType: string;
+} | {
+    kind: "local";
+    path: string;
+    mimeType: string;
+} | {
+    kind: "local-fallback";
+    path: string;
+    mimeType: string;
+    primaryFailure: OperationalFailure;
+};
+type VideoProviderCredential = {
+    kind: "literal";
+    value: string;
+} | {
+    kind: "env";
+    name: string;
+};
+interface VideoProviderOverrides {
+    provider?: "gemini" | "doubao";
+    baseUrl?: string;
+    apiKey?: VideoProviderCredential;
+    model?: string;
+}
+interface LlmExecutorOptions {
+    videoProvider?: VideoProviderOverrides;
+}
+interface VideoGenerationRequest {
+    media: VideoMediaInput;
+    system?: string;
+    user: string;
+    fps: number;
+    maxOutputTokens: number;
+    responseJsonSchema?: JsonSchema;
+    localPath?: string;
+    localMime?: string;
+    signal?: AbortSignal;
+}
+interface VideoGenerationResponse {
+    text: string;
+    finishReason: string;
+    attempts: number;
+    usage?: TokenUsage;
+    raw?: unknown;
+}
+interface TaskVideoPort {
+    prepare(localPath: string, mimeType: string, mode: VideoUploadMode, signal?: AbortSignal): Promise<VideoMediaInput>;
+    generate(request: Omit<VideoGenerationRequest, "maxOutputTokens">): Promise<VideoGenerationResponse>;
+    release(media: VideoMediaInput, signal?: AbortSignal): Promise<void>;
+}
+interface LlmRouteInfo {
+    task: LlmTaskId;
+    profile: string;
+    provider: string;
+    protocol: LlmProtocol;
+    baseUrl: string | null;
+    model: string;
+    fingerprint: string;
+}
+interface LlmRouteUsage extends LlmRouteInfo {
+    calls: number;
+    succeeded: number;
+    failed: number;
+    reused: number;
+    attempts: number;
+    durationMs: number;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    cacheCreationTokens: number;
+}
+type LlmUsageStatus = "succeeded" | "failed" | "reused";
+interface LlmUsageEvent extends LlmRouteInfo {
+    sequence: number;
+    status: LlmUsageStatus;
+    attempts: number;
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    cacheCreationTokens: number;
+    errorCode?: LlmErrorCode;
+}
+interface LlmTaskExecutor {
+    generateText(task: LlmTaskId, request: Omit<TextGenerationRequest, "maxOutputTokens">): Promise<TextGenerationResponse>;
+    generateTool(task: LlmTaskId, request: Omit<ToolGenerationRequest, "maxOutputTokens">): Promise<ToolGenerationResponse>;
+    videoPort(task: LlmTaskId): TaskVideoPort;
+    route(task: LlmTaskId): LlmRouteInfo;
+    routes(): LlmRouteInfo[];
+    recordReuse(task: LlmTaskId): void;
+    usage(): LlmRouteUsage[];
+    usageEvents(): LlmUsageEvent[];
+    readonly configSource: "builtin" | "file";
+}
+type LlmErrorCode = "auth" | "permission_denied" | "endpoint" | "network" | "timeout" | "rate_limited" | "request_failed" | "truncated" | "content_filtered" | "empty_response" | "invalid_response" | "cancelled";
+
+interface LlmComposition {
+    createExecutor(configPath?: string, options?: LlmExecutorOptions): LlmTaskExecutor;
+}
+
+declare function buildProgram(state: RunState, llm?: LlmComposition): Command;
+declare function main(argv?: string[] | null, llm?: LlmComposition): Promise<number>;
+
+export { buildProgram, main };

package/dist/cli.js

@@ -1,187 +1 @@
-import { Command, CommanderError } from "commander";
-import { CliError, EXIT_OK, EXIT_USAGE } from "./common.js";
-import { formatFailure } from "./failures.js";
-import { registerAuthoringCommands } from "./cli/register-authoring.js";
-import { registerToolCommands } from "./cli/register-tools.js";
-import { registerReviewCommand } from "./cli/register-review.js";
-import { registerScriptCommands } from "./cli/register-script.js";
-import { registerWorkflowCommands } from "./cli/register-workflows.js";
-import { loadLocalEnv } from "./infra/env.js";
-import { PRODUCTION_LLM_COMPOSITION } from "./llm/composition.js";
-import { LlmTransportError } from "./llm/types.js";
-import { emitError } from "./output.js";
-import { packageVersion } from "./package-root.js";
-export function buildProgram(state, llm = PRODUCTION_LLM_COMPOSITION) {
-    const program = new Command("scriptctl")
-        .description("Read, edit, ingest, and publish structured scripts")
-        .usage("<command> [options]")
-        .exitOverride()
-        .allowExcessArguments(false)
-        .allowUnknownOption(false)
-        .showHelpAfterError(false)
-        .configureOutput({
-        writeOut: (text) => process.stdout.write(text),
-        writeErr: () => {
-            // Commander errors are emitted once through the scriptctl error model.
-        },
-    })
-        .option("-j, --json", "Output structured JSON")
-        .option("--format <format>", "Output format (addr)")
-        .version(packageVersion(), "-v, --version", "Show the scriptctl version");
-    registerWorkflowCommands(program, state, llm);
-    registerScriptCommands(program, state);
-    registerAuthoringCommands(program, state);
-    registerReviewCommand(program, state);
-    registerToolCommands(program, state);
-    return program;
-}
-function optionFor(command, token) {
-    const flag = token.split("=", 1)[0];
-    let current = command;
-    while (current) {
-        const option = current.options.find((candidate) => candidate.short === flag || candidate.long === flag);
-        if (option)
-            return option;
-        current = current.parent;
-    }
-    return undefined;
-}
-function scanShortOptions(command, token) {
-    if (!token.startsWith("-") || token.startsWith("--") || token.length < 2) {
-        return { recognized: false, json: false, hasAttachedValue: false };
-    }
-    let json = false;
-    for (let index = 1; index < token.length; index += 1) {
-        const option = optionFor(command, `-${token[index]}`);
-        if (!option?.short) {
-            return { recognized: false, json: false, hasAttachedValue: false };
-        }
-        if (option.short === "-j")
-            json = true;
-        if (option.required || option.optional) {
-            return {
-                recognized: true,
-                json,
-                valueOption: option,
-                hasAttachedValue: index < token.length - 1,
-            };
-        }
-    }
-    return { recognized: true, json, hasAttachedValue: false };
-}
-function isRecognizedOptionToken(command, token) {
-    if (token === "--")
-        return true;
-    if (token.startsWith("--"))
-        return optionFor(command, token) !== undefined;
-    return scanShortOptions(command, token).recognized;
-}
-function consumesNextValue(command, option, next) {
-    if (next === undefined || next === "--")
-        return false;
-    if (option.required)
-        return !isRecognizedOptionToken(command, next);
-    return option.optional && !next.startsWith("-");
-}
-function initialJsonMode(program, args) {
-    let command = program;
-    for (let index = 0; index < args.length; index += 1) {
-        const token = args[index];
-        if (token === "--")
-            break;
-        if (token.startsWith("--")) {
-            if (token === "--json")
-                return true;
-            const option = optionFor(command, token);
-            if (option
-                && !token.includes("=")
-                && consumesNextValue(command, option, args[index + 1]))
-                index += 1;
-            continue;
-        }
-        if (token.startsWith("-")) {
-            const scanned = scanShortOptions(command, token);
-            if (scanned.recognized && scanned.json)
-                return true;
-            if (scanned.recognized
-                && scanned.valueOption
-                && !scanned.hasAttachedValue
-                && consumesNextValue(command, scanned.valueOption, args[index + 1]))
-                index += 1;
-            continue;
-        }
-        const child = command.commands.find((candidate) => candidate.name() === token);
-        if (child)
-            command = child;
-    }
-    return false;
-}
-function helpTarget(program, args) {
-    let command = program;
-    for (let index = 0; index < args.length; index += 1) {
-        const token = args[index];
-        if (token.startsWith("-")) {
-            const option = optionFor(command, token);
-            if (option && !token.includes("=") && (option.required || option.optional))
-                index += 1;
-            continue;
-        }
-        const child = command.commands.find((candidate) => candidate.name() === token);
-        if (!child)
-            break;
-        command = child;
-    }
-    const names = [];
-    let current = command;
-    while (current && current.parent) {
-        names.unshift(current.name());
-        current = current.parent;
-    }
-    return ["scriptctl", ...names, "--help"].join(" ");
-}
-function commanderMessage(error) {
-    return error.message.replace(/^error:\s*/i, "").replace(/\.$/, "");
-}
-export async function main(argv = null, llm = PRODUCTION_LLM_COMPOSITION) {
-    loadLocalEnv();
-    const args = argv ?? process.argv.slice(2);
-    const state = { jsonMode: false, exitCode: EXIT_OK };
-    const program = buildProgram(state, llm);
-    state.jsonMode = initialJsonMode(program, args);
-    if (args.length === 0) {
-        program.outputHelp();
-        return EXIT_OK;
-    }
-    try {
-        await program.parseAsync(args, { from: "user" });
-        return state.exitCode;
-    }
-    catch (error) {
-        if (error instanceof CommanderError) {
-            if (error.code === "commander.help"
-                || error.code === "commander.helpDisplayed"
-                || error.code === "commander.version") {
-                return EXIT_OK;
-            }
-            return emitError(new CliError(commanderMessage(error), {
-                exitCode: EXIT_USAGE,
-                errorCode: "USAGE_ERROR",
-                hint: `Run '${helpTarget(program, args)}'.`,
-            }), state.jsonMode);
-        }
-        if (error instanceof CliError)
-            return emitError(error, state.jsonMode);
-        if (error instanceof LlmTransportError) {
-            return emitError(new CliError(formatFailure(error.failure), {
-                exitCode: 70,
-                errorCode: "RUNTIME_ERROR",
-            }), state.jsonMode);
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        return emitError(new CliError(message, {
-            exitCode: 70,
-            errorCode: "RUNTIME_ERROR",
-        }), state.jsonMode);
-    }
-}
-//# sourceMappingURL=cli.js.map
+import{a,b}from"./chunk-3LPIMYYI.js";export{a as buildProgram,b as main};