@cephalization/phoenix-insight 0.1.0

package/dist/snapshot/index.js

@@ -0,0 +1,262 @@
+// Export all snapshot modules
+export { createPhoenixClient, PhoenixClientError, } from "./client.js";
+export { fetchProjects } from "./projects.js";
+export { snapshotSpans } from "./spans.js";
+export { fetchDatasets } from "./datasets.js";
+export { fetchExperiments } from "./experiments.js";
+export { fetchPrompts } from "./prompts.js";
+export { generateContext } from "./context.js";
+import { createPhoenixClient, PhoenixClientError, } from "./client.js";
+import { fetchProjects } from "./projects.js";
+import { snapshotSpans } from "./spans.js";
+import { fetchDatasets } from "./datasets.js";
+import { fetchExperiments } from "./experiments.js";
+import { fetchPrompts } from "./prompts.js";
+import { generateContext } from "./context.js";
+import { SnapshotProgress } from "../progress.js";
+/**
+ * Orchestrates all data fetchers to create a complete Phoenix snapshot
+ * @param mode - The execution mode (sandbox or local)
+ * @param options - Snapshot options including server URL and limits
+ */
+export async function createSnapshot(mode, options) {
+    const { baseURL, apiKey, spansPerProject = 1000, startTime, endTime, showProgress = false, } = options;
+    // Create progress indicator
+    const progress = new SnapshotProgress(showProgress);
+    progress.start("Creating Phoenix data snapshot");
+    // Create Phoenix client
+    const clientConfig = {
+        baseURL,
+        apiKey,
+    };
+    const client = createPhoenixClient(clientConfig);
+    try {
+        // 1. Fetch projects first (required for spans)
+        progress.update("Fetching projects");
+        try {
+            await fetchProjects(client, mode);
+        }
+        catch (error) {
+            progress.fail("Failed to fetch projects");
+            throw new PhoenixClientError(`Failed to fetch projects: ${error instanceof Error ? error.message : String(error)}`, error instanceof PhoenixClientError ? error.code : "UNKNOWN_ERROR", error);
+        }
+        // 2. Fetch spans and other data in parallel
+        progress.update("Fetching all data", "spans, datasets, experiments, prompts");
+        const spansOptions = {
+            spansPerProject,
+            startTime,
+            endTime,
+        };
+        // Fetch all data types in parallel for better performance
+        const results = await Promise.allSettled([
+            snapshotSpans(client, mode, spansOptions),
+            fetchDatasets(client, mode),
+            fetchExperiments(client, mode),
+            fetchPrompts(client, mode),
+        ]);
+        // Check for failures and collect errors
+        const errors = [];
+        const dataTypes = ["spans", "datasets", "experiments", "prompts"];
+        results.forEach((result, index) => {
+            if (result.status === "rejected") {
+                errors.push({
+                    type: dataTypes[index] || "unknown",
+                    error: result.reason,
+                });
+            }
+        });
+        if (errors.length > 0) {
+            // Log individual errors
+            errors.forEach(({ type, error }) => {
+                console.error(`Warning: Failed to fetch ${type}:`, error instanceof Error ? error.message : String(error));
+            });
+            // If spans failed, that's critical - throw error
+            if (errors.some((e) => e.type === "spans")) {
+                progress.fail("Failed to fetch spans");
+                throw new PhoenixClientError(`Failed to fetch spans: ${errors.find((e) => e.type === "spans")?.error}`, "UNKNOWN_ERROR", errors);
+            }
+            // If all other data failed, throw error. If partial success, continue with warning
+            if (errors.length === 4) {
+                progress.fail("Failed to fetch all data");
+                throw new PhoenixClientError("Failed to fetch all data types", "UNKNOWN_ERROR", errors);
+            }
+        }
+        // 4. Generate context file
+        progress.update("Generating context");
+        await generateContext(mode, {
+            phoenixUrl: baseURL,
+            snapshotTime: new Date(),
+            spansPerProject,
+        });
+        // 5. Write metadata file
+        progress.update("Writing metadata");
+        const metadata = {
+            created_at: new Date().toISOString(),
+            phoenix_url: baseURL,
+            cursors: {
+                spans: {}, // TODO: Track span cursors when span fetching supports it
+                datasets: { last_fetch: new Date().toISOString() },
+                experiments: { last_fetch: new Date().toISOString() },
+                prompts: { last_fetch: new Date().toISOString() },
+            },
+            limits: {
+                spans_per_project: spansPerProject,
+            },
+        };
+        await mode.writeFile("/_meta/snapshot.json", JSON.stringify(metadata, null, 2));
+        progress.succeed("✅ Snapshot created successfully!");
+    }
+    catch (error) {
+        // Stop progress if not already stopped
+        progress.stop();
+        // Enhance error with context before rethrowing
+        if (error instanceof PhoenixClientError) {
+            throw error; // Already has good context
+        }
+        throw new PhoenixClientError(`Failed to create snapshot: ${error instanceof Error ? error.message : String(error)}`, "UNKNOWN_ERROR", error);
+    }
+}
+/**
+ * Loads existing snapshot metadata if available
+ * @param mode - The execution mode (sandbox or local)
+ * @returns The snapshot metadata or null if not found
+ */
+export async function loadSnapshotMetadata(mode) {
+    try {
+        const result = await mode.exec("cat /phoenix/_meta/snapshot.json 2>/dev/null");
+        if (result.exitCode === 0) {
+            return JSON.parse(result.stdout);
+        }
+    }
+    catch (error) {
+        // File doesn't exist or parse error
+    }
+    return null;
+}
+/**
+ * Creates an incremental snapshot, fetching only new/updated data
+ * @param mode - The execution mode (sandbox or local)
+ * @param options - Snapshot options including server URL and limits
+ */
+export async function createIncrementalSnapshot(mode, options) {
+    // Load existing metadata to get cursors
+    const existingMetadata = await loadSnapshotMetadata(mode);
+    if (!existingMetadata) {
+        // No existing snapshot, create a full one
+        await createSnapshot(mode, options);
+        return;
+    }
+    const { baseURL, apiKey, spansPerProject = 1000, showProgress = false, } = options;
+    // Create progress indicator
+    const progress = new SnapshotProgress(showProgress);
+    progress.start("Updating Phoenix data snapshot");
+    // Create Phoenix client
+    const clientConfig = {
+        baseURL,
+        apiKey,
+    };
+    const client = createPhoenixClient(clientConfig);
+    try {
+        // Show time since last snapshot
+        const lastSnapshotDate = new Date(existingMetadata.created_at);
+        const timeSince = formatTimeSince(lastSnapshotDate);
+        progress.update("Checking for updates", `last snapshot ${timeSince} ago`);
+        // For incremental updates, we'll need to:
+        // 1. Fetch projects (always fetch all as they're small)
+        progress.update("Updating projects");
+        await fetchProjects(client, mode);
+        // 2. Fetch spans and other data in parallel for better performance
+        progress.update("Fetching updates", "new spans and refreshing other data");
+        const spansOptions = {
+            spansPerProject,
+            // Use the last end time from previous snapshot as start time
+            startTime: existingMetadata.cursors.spans
+                ? Object.values(existingMetadata.cursors.spans)
+                    .map((cursor) => cursor.last_end_time)
+                    .filter(Boolean)
+                    .sort()
+                    .pop()
+                : undefined,
+        };
+        // For datasets/experiments/prompts, check if they've been updated
+        const datasetsLastFetch = existingMetadata.cursors.datasets?.last_fetch;
+        const experimentsLastFetch = existingMetadata.cursors.experiments?.last_fetch;
+        const promptsLastFetch = existingMetadata.cursors.prompts?.last_fetch;
+        // Fetch all data types in parallel
+        // For now, we'll refetch all as the API doesn't support filtering by updated_at
+        // In a future enhancement, we could check individual items for updates
+        const updateResults = await Promise.allSettled([
+            snapshotSpans(client, mode, spansOptions),
+            fetchDatasets(client, mode),
+            fetchExperiments(client, mode),
+            fetchPrompts(client, mode),
+        ]);
+        // Check for critical errors
+        const updateErrors = [];
+        const updateDataTypes = ["spans", "datasets", "experiments", "prompts"];
+        updateResults.forEach((result, index) => {
+            if (result.status === "rejected") {
+                updateErrors.push({
+                    type: updateDataTypes[index] || "unknown",
+                    error: result.reason,
+                });
+            }
+        });
+        if (updateErrors.length > 0) {
+            // Log individual errors
+            updateErrors.forEach(({ type, error }) => {
+                console.error(`Warning: Failed to update ${type}:`, error instanceof Error ? error.message : String(error));
+            });
+        }
+        // 4. Regenerate context with updated data
+        progress.update("Regenerating context");
+        await generateContext(mode, {
+            phoenixUrl: baseURL,
+            snapshotTime: new Date(),
+            spansPerProject,
+        });
+        // 5. Update metadata
+        progress.update("Updating metadata");
+        const updatedSpansCursors = existingMetadata.cursors.spans || {};
+        const metadata = {
+            created_at: new Date().toISOString(),
+            phoenix_url: baseURL,
+            cursors: {
+                spans: updatedSpansCursors,
+                datasets: { last_fetch: new Date().toISOString() },
+                experiments: { last_fetch: new Date().toISOString() },
+                prompts: { last_fetch: new Date().toISOString() },
+            },
+            limits: {
+                spans_per_project: spansPerProject,
+            },
+        };
+        await mode.writeFile("/_meta/snapshot.json", JSON.stringify(metadata, null, 2));
+        progress.succeed("✅ Incremental update complete!");
+    }
+    catch (error) {
+        // Stop progress if not already stopped
+        progress.stop();
+        // Enhance error with context before rethrowing
+        if (error instanceof PhoenixClientError) {
+            throw error; // Already has good context
+        }
+        throw new PhoenixClientError(`Failed to create incremental snapshot: ${error instanceof Error ? error.message : String(error)}`, "UNKNOWN_ERROR", error);
+    }
+}
+/**
+ * Format time since a date in human-readable format
+ */
+function formatTimeSince(date) {
+    const seconds = Math.floor((new Date().getTime() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    const days = Math.floor(hours / 24);
+    return `${days}d`;
+}

package/dist/snapshot/projects.js

@@ -0,0 +1,44 @@
+import { withErrorHandling } from "./client.js";
+/**
+ * Converts an array of items to JSONL format (one JSON object per line)
+ */
+function toJSONL(items) {
+    return items.map((item) => JSON.stringify(item)).join("\n");
+}
+/**
+ * Fetches all projects and writes them to the filesystem
+ * @param client - The Phoenix client instance
+ * @param mode - The execution mode (sandbox or local)
+ */
+export async function fetchProjects(client, mode) {
+    // Fetch all projects with error handling
+    const projectsData = await withErrorHandling(async () => {
+        const response = await client.GET("/v1/projects", {
+            params: {
+                query: {
+                    include_experiment_projects: false,
+                },
+            },
+        });
+        if (!response.data) {
+            throw new Error("No data returned from projects endpoint");
+        }
+        return response.data;
+    }, "fetching projects");
+    // Extract projects from the response
+    const projects = projectsData.data || [];
+    // Write projects list as JSONL to /phoenix/projects/index.jsonl
+    const projectsPath = "/phoenix/projects/index.jsonl";
+    await mode.writeFile(projectsPath, toJSONL(projects));
+    // For each project, create a metadata.json file
+    for (const project of projects) {
+        const projectDir = `/phoenix/projects/${project.name}`;
+        const metadataPath = `${projectDir}/metadata.json`;
+        // Write project metadata
+        await mode.writeFile(metadataPath, JSON.stringify(project, null, 2));
+        // Create empty spans directory (will be populated by snapshot-spans task)
+        const spansDir = `${projectDir}/spans`;
+        // Create directory by writing a placeholder that will be overwritten later
+        await mode.writeFile(`${spansDir}/.gitkeep`, "");
+    }
+}

package/dist/snapshot/prompts.js

@@ -0,0 +1,199 @@
+import { withErrorHandling, extractData } from "./client.js";
+/**
+ * Converts an array to JSONL format
+ */
+function toJSONL(items) {
+    if (items.length === 0) {
+        return "";
+    }
+    return items.map((item) => JSON.stringify(item)).join("\n");
+}
+/**
+ * Converts a prompt template to markdown format
+ */
+function templateToMarkdown(template, templateFormat) {
+    // Handle string template
+    if (templateFormat === "STRING") {
+        if (typeof template === "string") {
+            return template;
+        }
+        // It might be wrapped in an object with type
+        if (template?.template && typeof template.template === "string") {
+            return template.template;
+        }
+        return JSON.stringify(template, null, 2);
+    }
+    // Handle chat template
+    const messages = template?.messages || [];
+    const lines = ["# Chat Template", ""];
+    for (const message of messages) {
+        lines.push(`## ${message.role}`);
+        lines.push("");
+        if (typeof message.content === "string") {
+            lines.push(message.content);
+        }
+        else if (Array.isArray(message.content)) {
+            // Handle multi-part content
+            for (const part of message.content) {
+                if (part.type === "text" && part.text) {
+                    lines.push(part.text);
+                }
+                else {
+                    // For non-text parts, show as JSON
+                    lines.push("```json");
+                    lines.push(JSON.stringify(part, null, 2));
+                    lines.push("```");
+                }
+            }
+        }
+        else {
+            // If content is not string or array, show as JSON
+            lines.push("```json");
+            lines.push(JSON.stringify(message.content, null, 2));
+            lines.push("```");
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Creates a markdown representation of a prompt version
+ */
+function createVersionMarkdown(version) {
+    const lines = [];
+    // Add metadata header
+    lines.push("---");
+    lines.push(`id: ${version.id}`);
+    if (version.model_name)
+        lines.push(`model_name: ${version.model_name}`);
+    if (version.model_provider)
+        lines.push(`model_provider: ${version.model_provider}`);
+    if (version.template_format)
+        lines.push(`template_format: ${version.template_format}`);
+    if (version.description)
+        lines.push(`description: ${version.description}`);
+    lines.push("---");
+    lines.push("");
+    // Add template content
+    if (version.template) {
+        lines.push(templateToMarkdown(version.template, version.template_format || "STRING"));
+        lines.push("");
+    }
+    // Add invocation parameters if present
+    if (version.invocation_parameters) {
+        lines.push("## Invocation Parameters");
+        lines.push("");
+        lines.push("```json");
+        lines.push(JSON.stringify(version.invocation_parameters, null, 2));
+        lines.push("```");
+        lines.push("");
+    }
+    // Add tools if present
+    if (version.tools) {
+        lines.push("## Tools");
+        lines.push("");
+        lines.push("```json");
+        lines.push(JSON.stringify(version.tools, null, 2));
+        lines.push("```");
+        lines.push("");
+    }
+    // Add response format if present
+    if (version.response_format) {
+        lines.push("## Response Format");
+        lines.push("");
+        lines.push("```json");
+        lines.push(JSON.stringify(version.response_format, null, 2));
+        lines.push("```");
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Fetches all prompts and their versions from Phoenix
+ */
+export async function fetchPrompts(client, mode, options = {}) {
+    const { limit = 100 } = options;
+    // Fetch all prompts with pagination
+    const prompts = [];
+    let cursor = null;
+    while (prompts.length < limit) {
+        const query = {
+            limit: Math.min(limit - prompts.length, 100),
+        };
+        if (cursor) {
+            query.cursor = cursor;
+        }
+        const response = await withErrorHandling(() => client.GET("/v1/prompts", { params: { query } }), "fetching prompts");
+        const data = extractData(response);
+        prompts.push(...data.data);
+        cursor = data.next_cursor;
+        // Stop if no more data
+        if (!cursor || data.data.length === 0) {
+            break;
+        }
+    }
+    // Write prompts index
+    await mode.writeFile("/phoenix/prompts/index.jsonl", toJSONL(prompts));
+    // Fetch versions for each prompt
+    for (const prompt of prompts) {
+        const safePromptName = prompt.name.replace(/[^a-zA-Z0-9-_]/g, "_");
+        // Write prompt metadata
+        await mode.writeFile(`/phoenix/prompts/${safePromptName}/metadata.json`, JSON.stringify({
+            id: prompt.id,
+            name: prompt.name,
+            description: prompt.description || null,
+            metadata: prompt.metadata || {},
+            source_prompt_id: prompt.source_prompt_id || null,
+            snapshot_timestamp: new Date().toISOString(),
+        }, null, 2));
+        // Fetch all versions for this prompt
+        const versions = [];
+        let versionCursor = null;
+        while (true) {
+            const versionQuery = {
+                limit: 100,
+            };
+            if (versionCursor) {
+                versionQuery.cursor = versionCursor;
+            }
+            const versionsResponse = await withErrorHandling(() => client.GET("/v1/prompts/{prompt_identifier}/versions", {
+                params: {
+                    path: { prompt_identifier: prompt.id },
+                    query: versionQuery,
+                },
+            }), `fetching versions for prompt ${prompt.name}`);
+            const versionsData = extractData(versionsResponse);
+            versions.push(...versionsData.data);
+            versionCursor = versionsData.next_cursor;
+            // Stop if no more data
+            if (!versionCursor || versionsData.data.length === 0) {
+                break;
+            }
+        }
+        // Write versions index as JSONL
+        await mode.writeFile(`/phoenix/prompts/${safePromptName}/versions/index.jsonl`, toJSONL(versions));
+        // Write each version as markdown
+        for (const version of versions) {
+            const versionId = version.id.replace(/[^a-zA-Z0-9-_]/g, "_");
+            const markdownContent = createVersionMarkdown(version);
+            await mode.writeFile(`/phoenix/prompts/${safePromptName}/versions/${versionId}.md`, markdownContent);
+        }
+        // Fetch and save the latest version separately for convenience
+        try {
+            const latestResponse = await withErrorHandling(() => client.GET("/v1/prompts/{prompt_identifier}/latest", {
+                params: {
+                    path: { prompt_identifier: prompt.id },
+                },
+            }), `fetching latest version for prompt ${prompt.name}`);
+            const latestData = extractData(latestResponse);
+            if (latestData.data) {
+                const latestMarkdownContent = createVersionMarkdown(latestData.data);
+                await mode.writeFile(`/phoenix/prompts/${safePromptName}/latest.md`, latestMarkdownContent);
+            }
+        }
+        catch (error) {
+            // If there's no latest version, that's okay - just skip it
+            console.warn(`No latest version available for prompt ${prompt.name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/snapshot/spans.js

@@ -0,0 +1,80 @@
+import { withErrorHandling } from "./client.js";
+/**
+ * Fetches spans for all projects and writes them to the snapshot
+ *
+ * @param client - Phoenix client instance
+ * @param mode - Execution mode for file operations
+ * @param options - Options for filtering and limiting spans
+ */
+export async function snapshotSpans(client, mode, options = {}) {
+    const { startTime, endTime, spansPerProject = 1000 } = options;
+    // Read projects index to get project names
+    const projectsIndexContent = await mode.exec("cat /phoenix/projects/index.jsonl");
+    if (!projectsIndexContent.stdout) {
+        // No projects, nothing to do
+        return;
+    }
+    const projectNames = projectsIndexContent.stdout
+        .trim()
+        .split("\n")
+        .filter((line) => line.length > 0)
+        .map((line) => {
+        const project = JSON.parse(line);
+        return project.name;
+    });
+    // Fetch spans for each project
+    for (const projectName of projectNames) {
+        await withErrorHandling(async () => {
+            const spans = [];
+            let cursor = null;
+            let totalFetched = 0;
+            // Paginate through spans until we reach the limit or no more data
+            while (totalFetched < spansPerProject) {
+                const query = {
+                    limit: Math.min(100, spansPerProject - totalFetched), // Fetch in chunks of 100
+                };
+                if (cursor) {
+                    query.cursor = cursor;
+                }
+                if (startTime) {
+                    query.start_time =
+                        startTime instanceof Date ? startTime.toISOString() : startTime;
+                }
+                if (endTime) {
+                    query.end_time =
+                        endTime instanceof Date ? endTime.toISOString() : endTime;
+                }
+                const response = await client.GET("/v1/projects/{project_identifier}/spans", {
+                    params: {
+                        path: {
+                            project_identifier: projectName,
+                        },
+                        query,
+                    },
+                });
+                if (response.error)
+                    throw response.error;
+                const data = response.data?.data ?? [];
+                spans.push(...data);
+                totalFetched += data.length;
+                cursor = response.data?.next_cursor ?? null;
+                // Stop if there's no more data
+                if (!cursor || data.length === 0) {
+                    break;
+                }
+            }
+            // Write spans to JSONL file
+            const jsonlContent = spans.map((span) => JSON.stringify(span)).join("\n");
+            await mode.writeFile(`/phoenix/projects/${projectName}/spans/index.jsonl`, jsonlContent);
+            // Write metadata about the spans snapshot
+            const metadata = {
+                project: projectName,
+                spanCount: spans.length,
+                startTime: startTime || null,
+                endTime: endTime || null,
+                snapshotTime: new Date().toISOString(),
+            };
+            await mode.writeFile(`/phoenix/projects/${projectName}/spans/metadata.json`, JSON.stringify(metadata, null, 2));
+        }, `fetching spans for project ${projectName}`);
+    }
+}

package/dist/tsconfig.esm.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/cli.ts","../src/index.ts","../src/progress.ts","../src/agent/index.ts","../src/commands/index.ts","../src/commands/px-fetch-more-spans.ts","../src/commands/px-fetch-more-trace.ts","../src/config/index.ts","../src/config/loader.ts","../src/config/schema.ts","../src/modes/index.ts","../src/modes/local.ts","../src/modes/sandbox.ts","../src/modes/types.ts","../src/observability/index.ts","../src/prompts/index.ts","../src/prompts/system.ts","../src/snapshot/client.ts","../src/snapshot/context.ts","../src/snapshot/datasets.ts","../src/snapshot/experiments.ts","../src/snapshot/index.ts","../src/snapshot/projects.ts","../src/snapshot/prompts.ts","../src/snapshot/spans.ts"],"version":"5.9.3"}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@cephalization/phoenix-insight",
+  "version": "0.1.0",
+  "description": "A CLI for Arize AI Phoenix data analysis with AI agents",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "phoenix-insight": "./dist/cli.js",
+    "pxi": "./dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "src",
+    "package.json"
+  ],
+  "keywords": [
+    "phoenix",
+    "cli",
+    "insight",
+    "arize",
+    "llmops",
+    "ai"
+  ],
+  "author": "oss@arize.com",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/cephalization/phoenix-insight#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cephalization/phoenix-insight.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cephalization/phoenix-insight/issues"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.0",
+    "@arizeai/phoenix-client": "^5.6.1",
+    "@arizeai/phoenix-otel": "^0.3.4",
+    "@opentelemetry/api": "1.9.0",
+    "ai": "^6.0.0",
+    "bash-tool": "^1.3.0",
+    "commander": "^12.0.0",
+    "just-bash": "^2.2.0",
+    "ora": "^9.0.0",
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.8",
+    "@types/node": "^18.19.0",
+    "rimraf": "^5.0.10",
+    "tsc-alias": "^1.8.11",
+    "tsx": "^4.21.0",
+    "typescript": "^5.8.2",
+    "vitest": "^2.1.9"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.esm.tsbuildinfo tsconfig.tsbuildinfo",
+    "prebuild": "pnpm run clean",
+    "build": "tsc --build tsconfig.esm.json",
+    "start": "node dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --typecheck"
+  }
+}