agentic-dataset-builder 0.1.0 → 0.2.0

package/dist/sources/codex.js

@@ -0,0 +1,261 @@
+import fg from 'fast-glob';
+import { z } from 'zod';
+import { Qwen35RecordSchema } from '../schemas/qwen35.js';
+import { readJsonl } from '../utils/jsonl.js';
+const EntrySchema = z.object({
+    timestamp: z.string().optional(),
+    type: z.string(),
+    payload: z.record(z.string(), z.unknown()).optional(),
+}).passthrough();
+class TurnBuilder {
+    sessionMeta;
+    turnId;
+    startTs;
+    messages = [];
+    pendingText = [];
+    pendingReasoning = [];
+    pendingToolCalls = [];
+    callNames = new Map();
+    tools = new Map();
+    lossyReasons = new Set();
+    lastTs;
+    lastAgentMessage;
+    constructor(sessionMeta, turnId, startTs) {
+        this.sessionMeta = sessionMeta;
+        this.turnId = turnId;
+        this.startTs = startTs;
+        this.lastTs = startTs;
+    }
+    ingest(entry) {
+        this.lastTs = entry.timestamp ?? this.lastTs;
+        const payload = (entry.payload ?? {});
+        if (entry.type === 'response_item')
+            this.ingestResponseItem(payload);
+        if (entry.type === 'event_msg')
+            this.ingestEvent(payload);
+    }
+    ingestResponseItem(payload) {
+        const type = asString(payload.type);
+        if (type === 'message')
+            this.ingestMessage(payload);
+        if (type === 'reasoning')
+            this.ingestReasoning(payload);
+        if (type === 'function_call')
+            this.ingestFunctionCall(payload);
+        if (type === 'function_call_output')
+            this.ingestFunctionCallOutput(payload);
+        if (type === 'custom_tool_call')
+            this.ingestCustomToolCall(payload);
+        if (type === 'custom_tool_call_output')
+            this.ingestCustomToolCallOutput(payload);
+    }
+    ingestEvent(payload) {
+        const type = asString(payload.type);
+        if (type === 'exec_command_end')
+            this.ingestExecCommandEnd(payload);
+        if (type === 'task_complete') {
+            const msg = asString(payload.last_agent_message);
+            if (msg)
+                this.lastAgentMessage = msg;
+        }
+        if (type === 'error' && asString(payload.message))
+            this.lossyReasons.add('turn_error');
+    }
+    ingestMessage(payload) {
+        const role = asString(payload.role);
+        const content = Array.isArray(payload.content) ? payload.content : [];
+        const text = extractCodexText(content);
+        if (role === 'assistant') {
+            if (text)
+                this.pendingText.push(text);
+            return;
+        }
+        this.flushAssistant();
+        if (role === 'user')
+            this.messages.push({ role: 'user', content: text });
+        else if (role === 'developer' && text)
+            this.messages.push({ role: 'system', content: text });
+    }
+    ingestReasoning(payload) {
+        const summary = Array.isArray(payload.summary) ? payload.summary : [];
+        const visible = summary
+            .map((item) => (item && typeof item === 'object' ? asString(item.text) ?? asString(item.summary_text) : undefined))
+            .filter(Boolean);
+        const content = asString(payload.content);
+        if (content)
+            visible.push(content);
+        if (visible.length)
+            this.pendingReasoning.push(...visible);
+        else if (payload.encrypted_content)
+            this.lossyReasons.add('encrypted_reasoning_without_summary');
+    }
+    ingestFunctionCall(payload) {
+        const name = asString(payload.name) ?? 'tool';
+        const callId = asString(payload.call_id);
+        const args = parseJsonObject(payload.arguments);
+        this.pendingToolCalls.push({ type: 'function', id: callId, function: { name, arguments: args } });
+        if (callId)
+            this.callNames.set(callId, name);
+        this.tools.set(name, { name });
+    }
+    ingestCustomToolCall(payload) {
+        const name = asString(payload.name) ?? 'custom_tool';
+        const callId = asString(payload.call_id);
+        this.pendingToolCalls.push({
+            type: 'function',
+            id: callId,
+            function: { name, arguments: { input: payload.input, status: payload.status } },
+        });
+        if (callId)
+            this.callNames.set(callId, name);
+        this.tools.set(name, { name });
+    }
+    ingestFunctionCallOutput(payload) {
+        this.flushAssistant();
+        const callId = asString(payload.call_id);
+        const name = callId ? this.callNames.get(callId) ?? 'tool' : 'tool';
+        const output = typeof payload.output === 'string' ? payload.output : JSON.stringify(payload.output);
+        this.messages.push({ role: 'tool', name, tool_call_id: callId, content: output });
+        this.tools.set(name, { name });
+    }
+    ingestCustomToolCallOutput(payload) {
+        this.ingestFunctionCallOutput(payload);
+    }
+    ingestExecCommandEnd(payload) {
+        this.flushAssistant();
+        const callId = asString(payload.call_id);
+        const name = callId ? this.callNames.get(callId) ?? 'exec_command' : 'exec_command';
+        this.tools.set(name, { name });
+        this.messages.push({
+            role: 'tool',
+            name,
+            tool_call_id: callId,
+            content: JSON.stringify({
+                command: payload.command,
+                cwd: payload.cwd,
+                aggregated_output: payload.aggregated_output,
+                exit_code: payload.exit_code,
+                status: payload.status,
+                duration: payload.duration,
+            }),
+        });
+    }
+    flushAssistant() {
+        if (!this.pendingText.length && !this.pendingReasoning.length && !this.pendingToolCalls.length)
+            return;
+        const message = { role: 'assistant', content: this.pendingText.join('\n\n') };
+        if (this.pendingReasoning.length)
+            message.reasoning_content = this.pendingReasoning.join('\n\n');
+        if (this.pendingToolCalls.length)
+            message.tool_calls = [...this.pendingToolCalls];
+        this.messages.push(message);
+        this.pendingText = [];
+        this.pendingReasoning = [];
+        this.pendingToolCalls = [];
+    }
+    finalize() {
+        if (this.lastAgentMessage && !this.pendingText.length) {
+            this.pendingText.push(this.lastAgentMessage);
+            this.lossyReasons.add('synthetic_last_agent_message');
+        }
+        this.flushAssistant();
+        if (!this.messages.some((message) => message.role === 'user'))
+            return null;
+        return Qwen35RecordSchema.parse({
+            id: `${asString(this.sessionMeta.id) ?? 'codex'}:${this.turnId}`,
+            request_id: this.turnId,
+            messages: this.messages,
+            tools: [...this.tools.values()],
+            meta: {
+                endpoint: 'codex/turn',
+                status: this.lossyReasons.has('turn_error') ? 500 : 200,
+                ts: this.lastTs,
+                key: asString(this.sessionMeta.id),
+                source: `codex:session=${asString(this.sessionMeta.id)}:turn=${this.turnId}:cwd=${asString(this.sessionMeta.cwd)}`,
+                requested_model: asString(this.sessionMeta.model),
+                actual_model: asString(this.sessionMeta.model),
+                stream: false,
+                thinking_level: asString(this.sessionMeta.reasoning_effort),
+                reasoning_summary_mode: 'codex_reasoning_summary',
+                thinking_type: 'codex_turn',
+                tool_spec_count: this.tools.size,
+                tool_choice: { mode: 'session_trace' },
+                request_contains_non_text_content: false,
+                request_image_block_count: 0,
+                request_video_block_count: 0,
+                request_tool_call_block_count: 0,
+                request_tool_result_block_count: 0,
+                request_thinking_block_count: 0,
+                response_contains_non_text_content: false,
+                response_image_block_count: 0,
+                response_video_block_count: 0,
+                response_tool_call_block_count: this.messages.filter((m) => m.role === 'assistant').reduce((sum, m) => sum + (m.tool_calls?.length ?? 0), 0),
+                response_tool_result_block_count: this.messages.filter((m) => m.role === 'tool').length,
+                response_thinking_block_count: this.messages.filter((m) => m.role === 'assistant' && typeof m.reasoning_content === 'string' && m.reasoning_content.length > 0).length,
+                request_truncated: false,
+                response_truncated: false,
+                lossy_source: this.lossyReasons.size > 0,
+                lossy_reasons: [...this.lossyReasons],
+            },
+        });
+    }
+}
+export async function collectCodexRecords(root) {
+    const files = await fg('**/*.jsonl', { cwd: root, absolute: true, onlyFiles: true });
+    const records = [];
+    for (const file of files.sort()) {
+        const entries = (await readJsonl(file)).map((entry) => EntrySchema.parse(entry));
+        const sessionMeta = (entries.find((entry) => entry.type === 'session_meta')?.payload ?? {});
+        let builder = null;
+        for (const entry of entries) {
+            const payload = (entry.payload ?? {});
+            if (entry.type === 'turn_context') {
+                sessionMeta.model = payload.model;
+                sessionMeta.reasoning_effort = payload.effort;
+            }
+            if (entry.type === 'event_msg' && payload.type === 'task_started') {
+                builder = new TurnBuilder(sessionMeta, asString(payload.turn_id) ?? entry.timestamp ?? 'turn', entry.timestamp ?? '');
+                continue;
+            }
+            if (!builder)
+                continue;
+            builder.ingest(entry);
+            if (entry.type === 'event_msg' && payload.type === 'task_complete') {
+                const record = builder.finalize();
+                if (record)
+                    records.push(record);
+                builder = null;
+            }
+        }
+    }
+    return records;
+}
+function parseJsonObject(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value))
+        return value;
+    if (typeof value !== 'string')
+        return {};
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : { value: parsed };
+    }
+    catch {
+        return { raw: value };
+    }
+}
+function extractCodexText(content) {
+    return content
+        .map((item) => {
+        const type = asString(item.type);
+        if ((type === 'input_text' || type === 'output_text') && typeof item.text === 'string')
+            return item.text;
+        if (type === 'input_image')
+            return '[image]';
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}

package/dist/sources/pi.d.ts

@@ -0,0 +1,2 @@
+import { type Qwen35Record } from '../schemas/qwen35.js';
+export declare function collectPiRecords(root: string): Promise<Qwen35Record[]>;

package/dist/sources/pi.js

@@ -0,0 +1,276 @@
+import fs from 'node:fs';
+import fg from 'fast-glob';
+import { z } from 'zod';
+import { Qwen35RecordSchema } from '../schemas/qwen35.js';
+import { isFile } from '../utils/common.js';
+import { readJsonl } from '../utils/jsonl.js';
+const SessionEntrySchema = z.object({
+    type: z.string(),
+    id: z.string().optional(),
+    parentId: z.string().nullable().optional(),
+    timestamp: z.string().optional(),
+}).passthrough();
+export async function collectPiRecords(root) {
+    const files = await fg('**/*.jsonl', { cwd: root, absolute: true, onlyFiles: true });
+    const records = [];
+    for (const file of files.sort()) {
+        const rows = (await readJsonl(file)).map((row) => SessionEntrySchema.parse(row));
+        if (!rows.length)
+            continue;
+        const header = rows[0];
+        const body = rows.slice(1);
+        const byId = new Map();
+        const children = new Map();
+        for (const entry of body) {
+            if (!entry.id)
+                continue;
+            byId.set(entry.id, entry);
+            const key = entry.parentId ?? null;
+            const bucket = children.get(key) ?? [];
+            bucket.push(entry.id);
+            children.set(key, bucket);
+        }
+        const leaves = [...byId.keys()].filter((id) => !children.get(id)?.length).sort();
+        for (const leaf of leaves) {
+            const pathEntries = branchEntries(leaf, byId);
+            const record = buildPiRecord(pathEntries, header, file, leaves.length > 1);
+            records.push(Qwen35RecordSchema.parse(record));
+        }
+    }
+    return records;
+}
+function branchEntries(leaf, byId) {
+    const ordered = [];
+    let current = leaf;
+    while (current) {
+        const entry = byId.get(current);
+        if (!entry)
+            break;
+        ordered.push(entry);
+        current = entry.parentId ?? null;
+    }
+    return ordered.reverse();
+}
+function buildPiRecord(entries, header, sourceFile, branched) {
+    const messages = [];
+    const tools = new Map();
+    const lossyReasons = new Set();
+    const models = [];
+    const thinkingLevels = [];
+    for (const entry of entries) {
+        if (entry.type === 'model_change') {
+            const provider = asString(entry.provider);
+            const modelId = asString(entry.modelId);
+            if (modelId)
+                models.push(provider ? `${provider}/${modelId}` : modelId);
+            continue;
+        }
+        if (entry.type === 'thinking_level_change') {
+            const level = asString(entry.thinkingLevel);
+            if (level)
+                thinkingLevels.push(level);
+            continue;
+        }
+        if (entry.type === 'message') {
+            const msg = entry.message;
+            if (!msg)
+                continue;
+            const role = asString(msg.role);
+            if (role === 'user') {
+                messages.push({ role: 'user', content: normalizeContent(msg.content, lossyReasons, 'user') });
+            }
+            else if (role === 'assistant') {
+                messages.push(normalizeAssistant(msg, tools, lossyReasons));
+            }
+            else if (role === 'toolResult') {
+                const toolName = asString(msg.toolName) ?? 'tool';
+                tools.set(toolName, { name: toolName });
+                messages.push({
+                    role: 'tool',
+                    name: toolName,
+                    tool_call_id: asString(msg.toolCallId),
+                    content: normalizeContent(msg.content, lossyReasons, 'tool_result'),
+                });
+            }
+            else if (role === 'bashExecution') {
+                tools.set('bash', { name: 'bash' });
+                messages.push({ role: 'tool', name: 'bash', content: formatBash(msg, lossyReasons) });
+            }
+            continue;
+        }
+        if (entry.type === 'branch_summary') {
+            const summary = asString(entry.summary);
+            if (summary) {
+                lossyReasons.add('synthetic_branch_summary');
+                messages.push({ role: 'assistant', content: `[branch_summary]\n${summary}` });
+            }
+            continue;
+        }
+        if (entry.type === 'compaction') {
+            const summary = asString(entry.summary);
+            if (summary) {
+                lossyReasons.add('synthetic_compaction_summary');
+                messages.push({ role: 'assistant', content: `[compaction_summary]\n${summary}` });
+            }
+        }
+    }
+    if (branched)
+        lossyReasons.add('session_tree_branch_selected');
+    if (new Set(models).size > 1)
+        lossyReasons.add('multiple_models_on_branch');
+    if (new Set(thinkingLevels).size > 1)
+        lossyReasons.add('multiple_thinking_levels_on_branch');
+    const meta = buildMeta(messages, {
+        endpoint: 'pi/session_branch',
+        ts: asString(entries.at(-1)?.timestamp) ?? asString(header.timestamp) ?? '',
+        key: asString(header.id) ?? undefined,
+        source: `${sourceFile}#leaf=${entries.at(-1)?.id ?? ''}`,
+        requested_model: models[0] ?? undefined,
+        actual_model: models.at(-1) ?? undefined,
+        thinking_level: thinkingLevels.at(-1) ?? undefined,
+        tool_spec_count: tools.size,
+        tool_choice: { mode: 'session_trace' },
+        reasoning_summary_mode: 'pi_session_branch',
+        thinking_type: 'pi_session',
+        lossy_reasons: [...lossyReasons],
+    });
+    return {
+        id: `${asString(header.id) ?? 'pi'}:${entries.at(-1)?.id ?? 'leaf'}`,
+        request_id: asString(header.id) ?? undefined,
+        messages,
+        tools: [...tools.values()],
+        meta,
+    };
+}
+function normalizeAssistant(msg, tools, lossyReasons) {
+    const content = msg.content;
+    const textBlocks = [];
+    const reasoning = [];
+    const toolCalls = [];
+    if (Array.isArray(content)) {
+        for (const raw of content) {
+            if (!raw || typeof raw !== 'object')
+                continue;
+            const block = raw;
+            const type = asString(block.type);
+            if (type === 'text') {
+                textBlocks.push({ type: 'text', text: asString(block.text) ?? '' });
+            }
+            else if (type === 'thinking') {
+                const thinking = asString(block.thinking);
+                if (thinking)
+                    reasoning.push(thinking);
+                if (!thinking && asString(block.thinkingSignature))
+                    lossyReasons.add('encrypted_reasoning_without_visible_text');
+            }
+            else if (type === 'toolCall') {
+                const name = asString(block.name) ?? 'tool';
+                tools.set(name, { name });
+                toolCalls.push({
+                    type: 'function',
+                    id: asString(block.id),
+                    function: {
+                        name,
+                        arguments: isRecord(block.arguments) ? block.arguments : {},
+                    },
+                });
+            }
+        }
+    }
+    const assistant = {
+        role: 'assistant',
+        content: textBlocks.length === 1 ? textBlocks[0].text : textBlocks,
+    };
+    if (reasoning.length)
+        assistant.reasoning_content = reasoning.join('\n\n');
+    if (toolCalls.length)
+        assistant.tool_calls = toolCalls;
+    return assistant;
+}
+function formatBash(msg, lossyReasons) {
+    const truncated = Boolean(msg.truncated);
+    let output = asString(msg.output) ?? '';
+    const fullOutputPath = asString(msg.fullOutputPath) ?? asString(msg.details?.fullOutputPath);
+    if (truncated && fullOutputPath) {
+        if (isFile(fullOutputPath)) {
+            output = fs.readFileSync(fullOutputPath, 'utf8');
+        }
+        else {
+            lossyReasons.add('missing_embedded_full_output');
+        }
+    }
+    return JSON.stringify({
+        command: asString(msg.command),
+        exit_code: asNumber(msg.exitCode),
+        cancelled: Boolean(msg.cancelled),
+        truncated,
+        exclude_from_context: Boolean(msg.excludeFromContext),
+        output,
+    });
+}
+function normalizeContent(content, lossyReasons, prefix) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content)) {
+        lossyReasons.add(`${prefix}_nonstandard_content`);
+        return JSON.stringify(content);
+    }
+    const blocks = [];
+    for (const raw of content) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const block = raw;
+        const type = asString(block.type);
+        if (type === 'text')
+            blocks.push({ type: 'text', text: asString(block.text) ?? '' });
+    }
+    if (blocks.length === 1)
+        return blocks[0].text;
+    return blocks;
+}
+function buildMeta(messages, seed) {
+    const assistantMessages = messages.filter((m) => m.role === 'assistant');
+    const toolMessages = messages.filter((m) => m.role === 'tool');
+    return {
+        endpoint: seed.endpoint,
+        status: 200,
+        ts: seed.ts,
+        key: seed.key,
+        source: seed.source,
+        requested_model: seed.requested_model,
+        actual_model: seed.actual_model,
+        stream: false,
+        thinking_level: seed.thinking_level,
+        reasoning_summary_mode: seed.reasoning_summary_mode,
+        thinking_type: seed.thinking_type,
+        thinking_budget_tokens: undefined,
+        max_output_tokens: undefined,
+        tool_spec_count: seed.tool_spec_count,
+        tool_choice: seed.tool_choice,
+        request_contains_non_text_content: false,
+        request_image_block_count: 0,
+        request_video_block_count: 0,
+        request_tool_call_block_count: 0,
+        request_tool_result_block_count: 0,
+        request_thinking_block_count: 0,
+        response_contains_non_text_content: false,
+        response_image_block_count: 0,
+        response_video_block_count: 0,
+        response_tool_call_block_count: assistantMessages.reduce((sum, msg) => sum + (msg.tool_calls?.length ?? 0), 0),
+        response_tool_result_block_count: toolMessages.length,
+        response_thinking_block_count: assistantMessages.filter((msg) => typeof msg.reasoning_content === 'string' && msg.reasoning_content.length > 0).length,
+        request_truncated: false,
+        response_truncated: Array.isArray(seed.lossy_reasons) ? seed.lossy_reasons.includes('missing_embedded_full_output') : false,
+        lossy_source: seed.lossy_reasons.length > 0,
+        lossy_reasons: seed.lossy_reasons,
+    };
+}
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === 'number' ? value : undefined;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/utils/common.d.ts

@@ -0,0 +1,7 @@
+export declare function compactText(value: string, limit?: number): string;
+export declare function ensureDir(dir: string): Promise<void>;
+export declare function timestampDir(prefix: string): string;
+export declare function safeReadFile(filePath: string): string | null;
+export declare function isFile(filePath: string): boolean;
+export declare function walkObject(value: unknown, visit: (obj: Record<string, unknown>) => void): void;
+export declare function resolveChildren(base: string, ...parts: string[]): string;

package/dist/utils/common.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function compactText(value, limit = 120) {
+    const oneLine = value.replace(/\s+/g, ' ').trim();
+    return oneLine.length <= limit ? oneLine : `${oneLine.slice(0, limit - 3)}...`;
+}
+export async function ensureDir(dir) {
+    await fs.promises.mkdir(dir, { recursive: true });
+}
+export function timestampDir(prefix) {
+    const now = new Date();
+    const stamp = now.toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, '');
+    return `${prefix}-${stamp}`;
+}
+export function safeReadFile(filePath) {
+    try {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export function isFile(filePath) {
+    try {
+        return fs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function walkObject(value, visit) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            walkObject(item, visit);
+        return;
+    }
+    if (value && typeof value === 'object') {
+        const obj = value;
+        visit(obj);
+        for (const child of Object.values(obj))
+            walkObject(child, visit);
+    }
+}
+export function resolveChildren(base, ...parts) {
+    return path.resolve(base, ...parts);
+}

package/dist/utils/jsonl.d.ts

@@ -0,0 +1,2 @@
+export declare function readJsonl(filePath: string): Promise<unknown[]>;
+export declare function writeJsonl(filePath: string, rows: unknown[]): Promise<void>;

package/dist/utils/jsonl.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs';
+import readline from 'node:readline';
+export async function readJsonl(filePath) {
+    const rows = [];
+    const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        rows.push(JSON.parse(trimmed));
+    }
+    return rows;
+}
+export async function writeJsonl(filePath, rows) {
+    await fs.promises.writeFile(filePath, rows.map((row) => JSON.stringify(row)).join('\n') + (rows.length ? '\n' : ''), 'utf8');
+}

package/package.json

@@ -1,7 +1,9 @@
 {
   "name": "agentic-dataset-builder",
-  "version": "0.1.0",
-  "description": "One-shot local dataset builder for Pi and Codex session histories",
+  "version": "0.2.0",
+  "description": "Pure TypeScript agentic dataset builder for Pi, Codex, and Claude Code history",
+  "license": "MIT",
+  "type": "module",
   "homepage": "https://github.com/Dominic789654/agentic-dataset-builder",
   "repository": {
     "type": "git",
@@ -10,31 +12,41 @@
   "bugs": {
     "url": "https://github.com/Dominic789654/agentic-dataset-builder/issues"
   },
-  "license": "MIT",
   "keywords": [
     "agentic",
     "dataset",
     "pi",
     "codex",
+    "claude",
     "qwen",
+    "zod",
     "parquet"
   ],
+  "bin": {
+    "agentic-dataset-builder": "./dist/cli.js"
+  },
   "files": [
-    "bin",
-    "run.py",
-    "requirements.txt",
+    "dist",
     "README.md",
-    "LICENSE",
-    "agentic_dataset"
+    "LICENSE"
   ],
-  "bin": {
-    "agentic-dataset-builder": "./bin/agentic-dataset-builder.js"
-  },
-  "type": "module",
   "engines": {
     "node": ">=18"
   },
   "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/cli.ts",
+    "check": "tsc -p tsconfig.json --noEmit",
     "pack:check": "npm pack --dry-run"
+  },
+  "dependencies": {
+    "fast-glob": "^3.3.3",
+    "parquetjs-lite": "^0.8.7",
+    "zod": "^4.1.11"
+  },
+  "devDependencies": {
+    "@types/node": "^24.7.2",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
   }
 }

package/agentic_dataset/__init__.py

@@ -1 +0,0 @@
-"""Agentic dataset builder package."""