@laitszkin/apollo-toolkit 3.13.2 → 3.14.0

package/dist/lib/tools/find-github-issues.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findGitHubIssuesHandler = findGitHubIssuesHandler;
+// @ts-nocheck
+const node_child_process_1 = require("node:child_process");
+const ISSUE_FIELDS = 'number,title,state,updatedAt,url,labels,assignees';
+function parseArgs(argv) {
+    const args = {
+        repo: null,
+        state: 'open',
+        limit: 50,
+        label: [],
+        search: null,
+        output: 'table',
+    };
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        switch (arg) {
+            case '--repo':
+                if (i + 1 < argv.length)
+                    args.repo = argv[++i];
+                break;
+            case '--state':
+                if (i + 1 < argv.length) {
+                    const val = argv[++i];
+                    if (['open', 'closed', 'all'].includes(val))
+                        args.state = val;
+                }
+                break;
+            case '--limit':
+                if (i + 1 < argv.length) {
+                    const n = parseInt(argv[++i], 10);
+                    if (n > 0)
+                        args.limit = n;
+                }
+                break;
+            case '--label':
+                if (i + 1 < argv.length)
+                    args.label.push(argv[++i]);
+                break;
+            case '--search':
+                if (i + 1 < argv.length)
+                    args.search = argv[++i];
+                break;
+            case '--output':
+                if (i + 1 < argv.length) {
+                    const val = argv[++i];
+                    if (val === 'table' || val === 'json')
+                        args.output = val;
+                }
+                break;
+            default:
+                break;
+        }
+        i++;
+    }
+    return args;
+}
+function runGh(cmdArgs) {
+    return new Promise((resolve) => {
+        (0, node_child_process_1.execFile)('gh', cmdArgs, { maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (error) {
+                resolve({
+                    stdout: stdout || '',
+                    stderr: stderr || '',
+                    exitCode: error.status ?? 1,
+                });
+            }
+            else {
+                resolve({ stdout: stdout || '', stderr: stderr || '', exitCode: 0 });
+            }
+        });
+    });
+}
+function buildCommand(args) {
+    const cmd = [
+        'issue',
+        'list',
+        '--state',
+        args.state,
+        '--limit',
+        String(args.limit),
+        '--json',
+        ISSUE_FIELDS,
+    ];
+    if (args.repo) {
+        cmd.push('--repo', args.repo);
+    }
+    for (const label of args.label) {
+        cmd.push('--label', label);
+    }
+    if (args.search) {
+        cmd.push('--search', args.search);
+    }
+    return cmd;
+}
+function truncate(text, width) {
+    if (text.length <= width)
+        return text;
+    if (width <= 3)
+        return text.slice(0, width);
+    return text.slice(0, width - 3) + '...';
+}
+function formatLabels(issue) {
+    const labels = issue.labels;
+    if (!labels)
+        return '';
+    const names = labels
+        .map((item) => String(item.name || ''))
+        .filter(Boolean);
+    return names.join(',');
+}
+function formatAssignees(issue) {
+    const assignees = issue.assignees;
+    if (!assignees)
+        return '-';
+    const logins = assignees
+        .map((item) => String(item.login || ''))
+        .filter(Boolean);
+    return logins.length > 0 ? logins.join(',') : '-';
+}
+function printTable(issues, context) {
+    const { stdout } = context;
+    const columns = {
+        number: 7,
+        title: 54,
+        labels: 22,
+        assignees: 18,
+        updated: 20,
+    };
+    const header = `${'NUMBER'.padEnd(columns.number)} ` +
+        `${'TITLE'.padEnd(columns.title)} ` +
+        `${'LABELS'.padEnd(columns.labels)} ` +
+        `${'ASSIGNEES'.padEnd(columns.assignees)} ` +
+        `${'UPDATED'.padEnd(columns.updated)}`;
+    stdout.write(header + '\n');
+    stdout.write('-'.repeat(header.length) + '\n');
+    for (const issue of issues) {
+        const number = `#${issue.number ?? ''}`;
+        const title = truncate(String(issue.title ?? ''), columns.title);
+        const labels = truncate(formatLabels(issue), columns.labels);
+        const assignees = truncate(formatAssignees(issue), columns.assignees);
+        const updated = truncate(String(issue.updatedAt ?? ''), columns.updated);
+        const row = `${number.padEnd(columns.number)} ` +
+            `${title.padEnd(columns.title)} ` +
+            `${labels.padEnd(columns.labels)} ` +
+            `${assignees.padEnd(columns.assignees)} ` +
+            `${updated.padEnd(columns.updated)}`;
+        stdout.write(row + '\n');
+    }
+}
+async function findGitHubIssuesHandler(argv, context) {
+    const { stdout, stderr } = context;
+    const args = parseArgs(argv);
+    const cmd = buildCommand(args);
+    const result = await runGh(cmd);
+    if (result.exitCode !== 0) {
+        stderr.write(result.stderr.trim() || 'gh issue list failed.\n');
+        return result.exitCode;
+    }
+    let issues;
+    try {
+        issues = JSON.parse(result.stdout);
+    }
+    catch {
+        stderr.write('Error: unable to parse gh output as JSON.\n');
+        return 1;
+    }
+    if (args.output === 'json') {
+        stdout.write(JSON.stringify(issues, null, 2) + '\n');
+        return 0;
+    }
+    printTable(issues, context);
+    return 0;
+}

package/dist/lib/tools/generate-storyboard-images.d.ts

@@ -0,0 +1,2 @@
+import type { ToolContext } from '../types';
+export declare function generateStoryboardImagesHandler(args: string[], context: ToolContext): Promise<number>;

package/dist/lib/tools/generate-storyboard-images.js

@@ -0,0 +1,419 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStoryboardImagesHandler = generateStoryboardImagesHandler;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_http_1 = __importDefault(require("node:http"));
+function parseArgs(args) {
+    const parsed = {
+        contentName: null,
+        projectDir: '.',
+        envFile: null,
+        apiUrl: null,
+        apiKey: null,
+        promptsFile: null,
+        prompts: [],
+        imageModel: null,
+        aspectRatio: null,
+        imageSize: null,
+        quality: null,
+        style: null,
+        help: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--help' || arg === '-h') {
+            parsed.help = true;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            const eqIndex = arg.indexOf('=');
+            let key;
+            let value;
+            if (eqIndex !== -1) {
+                key = arg.slice(2, eqIndex);
+                value = arg.slice(eqIndex + 1);
+            }
+            else {
+                key = arg.slice(2);
+                if (key === 'prompt') {
+                    // --prompt can be multiple
+                    value = args[++i] || '';
+                    parsed.prompts.push(value);
+                    continue;
+                }
+                value = args[++i] || '';
+            }
+            switch (key) {
+                case 'input':
+                case 'content-name':
+                    parsed.contentName = value;
+                    break;
+                case 'project-dir':
+                    parsed.projectDir = value;
+                    break;
+                case 'env-file':
+                    parsed.envFile = value;
+                    break;
+                case 'api-url':
+                    parsed.apiUrl = value;
+                    break;
+                case 'api-key':
+                    parsed.apiKey = value;
+                    break;
+                case 'prompts-file':
+                    parsed.promptsFile = value;
+                    break;
+                case 'image-model':
+                    parsed.imageModel = value;
+                    break;
+                case 'aspect-ratio':
+                    parsed.aspectRatio = value;
+                    break;
+                case 'image-size':
+                case 'size':
+                    parsed.imageSize = value;
+                    break;
+                case 'quality':
+                    parsed.quality = value;
+                    break;
+                case 'style':
+                    parsed.style = value;
+                    break;
+            }
+        }
+        else if (!parsed.contentName && !arg.startsWith('-')) {
+            // positional: content name
+            parsed.contentName = arg;
+        }
+    }
+    return parsed;
+}
+function sanitizeComponent(name, fallback) {
+    return name
+        .replace(/[\\/:*?"<>|]+/g, '_')
+        .replace(/\s+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^[._]|[._]$/g, '') || fallback;
+}
+function uniquePath(filePath) {
+    if (!node_fs_1.default.existsSync(filePath))
+        return filePath;
+    const dir = node_path_1.default.dirname(filePath);
+    const ext = node_path_1.default.extname(filePath);
+    const base = node_path_1.default.basename(filePath, ext);
+    let index = 2;
+    while (node_fs_1.default.existsSync(node_path_1.default.join(dir, `${base}_${index}${ext}`))) {
+        index++;
+    }
+    return node_path_1.default.join(dir, `${base}_${index}${ext}`);
+}
+function postJson(baseUrl, endpoint, apiKey, payload) {
+    return new Promise((resolve, reject) => {
+        const url = `${baseUrl.replace(/\/+$/, '')}${endpoint}`;
+        const urlObj = new URL(url);
+        const body = JSON.stringify(payload);
+        const client = urlObj.protocol === 'https:' ? node_https_1.default : node_http_1.default;
+        const options = {
+            hostname: urlObj.hostname,
+            port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+            path: urlObj.pathname + urlObj.search,
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 180000,
+        };
+        const req = client.request(options, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => {
+                const raw = Buffer.concat(chunks).toString('utf-8');
+                try {
+                    resolve(JSON.parse(raw));
+                }
+                catch {
+                    reject(new Error(`Invalid JSON response: ${raw.slice(0, 200)}`));
+                }
+            });
+            res.on('error', reject);
+        });
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('API request timed out')); });
+        req.write(body);
+        req.end();
+    });
+}
+function fetchBinary(url) {
+    return new Promise((resolve, reject) => {
+        const urlObj = new URL(url);
+        const client = urlObj.protocol === 'https:' ? node_https_1.default : node_http_1.default;
+        client.get(url, { timeout: 180000 }, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks)));
+            res.on('error', reject);
+        }).on('error', reject);
+    });
+}
+function parsePromptEntries(raw) {
+    const items = [];
+    for (let i = 0; i < raw.length; i++) {
+        const item = raw[i];
+        if (typeof item === 'string') {
+            const prompt = item.trim();
+            if (!prompt)
+                throw new Error(`Empty prompt at index ${i}`);
+            items.push({ title: `scene-${i + 1}`, prompt });
+        }
+        else if (item && typeof item === 'object') {
+            const obj = item;
+            const prompt = String(obj.prompt || '').trim();
+            const title = String(obj.title || `scene-${i + 1}`).trim() || `scene-${i + 1}`;
+            if (!prompt)
+                throw new Error(`Empty prompt in object at index ${i}`);
+            items.push({ title, prompt });
+        }
+        else {
+            throw new Error(`Invalid item type at index ${i}: expected string or object`);
+        }
+    }
+    if (items.length === 0)
+        throw new Error('No prompts found.');
+    return items;
+}
+function parsePromptsFile(filePath) {
+    const raw = JSON.parse(node_fs_1.default.readFileSync(filePath, 'utf-8'));
+    if (Array.isArray(raw)) {
+        return parsePromptEntries(raw);
+    }
+    if (raw && typeof raw === 'object') {
+        const scenes = raw.scenes;
+        if (!Array.isArray(scenes) || scenes.length === 0) {
+            throw new Error('Object mode requires a top-level "scenes" array.');
+        }
+        const characters = {};
+        if (Array.isArray(raw.characters)) {
+            for (const char of raw.characters) {
+                if (!char || typeof char !== 'object')
+                    continue;
+                const c = char;
+                const id = String(c.id || '').trim();
+                if (id) {
+                    characters[id] = {
+                        name: String(c.name || ''),
+                        appearance: String(c.appearance || ''),
+                        outfit: String(c.outfit || ''),
+                        description: String(c.description || ''),
+                    };
+                }
+            }
+        }
+        const items = [];
+        for (let si = 0; si < scenes.length; si++) {
+            const scene = scenes[si];
+            if (!scene || typeof scene !== 'object') {
+                throw new Error(`Invalid scene at index ${si}: expected object.`);
+            }
+            const title = String(scene.title || `scene-${si + 1}`).trim() || `scene-${si + 1}`;
+            const description = String(scene.description || '').trim();
+            if (!description)
+                throw new Error(`Scene ${si}: 'description' is required.`);
+            let promptPayload = {
+                scene_title: title,
+                description,
+            };
+            const characterIds = [];
+            if (Array.isArray(scene.character_ids)) {
+                for (const cid of scene.character_ids) {
+                    characterIds.push(String(cid).trim());
+                }
+                const sceneChars = characterIds
+                    .map((cid) => characters[cid])
+                    .filter(Boolean);
+                if (sceneChars.length > 0) {
+                    promptPayload.characters = sceneChars;
+                }
+            }
+            if (scene.style)
+                promptPayload.style = String(scene.style);
+            if (scene.camera)
+                promptPayload.camera = String(scene.camera);
+            if (scene.lighting)
+                promptPayload.lighting = String(scene.lighting);
+            items.push({
+                title,
+                prompt: JSON.stringify(promptPayload, undefined, 0),
+            });
+        }
+        return items;
+    }
+    throw new Error('Top-level JSON must be an array or an object.');
+}
+async function generateStoryboardImagesHandler(args, context) {
+    const stdout = context.stdout || process.stdout;
+    const stderr = context.stderr || process.stderr;
+    try {
+        const opts = parseArgs(args);
+        if (opts.help || (!opts.contentName)) {
+            stdout.write(`Usage: apltk generate-storyboard-images --input <name> [options]
+
+Generate storyboard images from prompts via OpenAI-compatible API.
+
+Options:
+  --input, --content-name <name>  Output subfolder name under pictures/
+  --project-dir <path>            Project root (default: .)
+  --env-file <path>               Path to .env file
+  --api-url <url>                 API base URL for /images/generations
+  --api-key <key>                 API key
+  --prompts-file <path>           JSON file with prompt entries
+  --prompt <text>                 Image prompt (repeatable)
+  --image-model <model>           Image model (default: gpt-image-1)
+  --aspect-ratio <ratio>          Aspect ratio, e.g. 16:9
+  --image-size <size>             Image size, e.g. 1024x768
+  --quality <q>                   Image quality
+  --style <style>                 Image style
+
+Either --prompts-file or at least one --prompt is required.
+`);
+            return opts.contentName ? 1 : 0;
+        }
+        const projectDir = node_path_1.default.resolve(opts.projectDir);
+        const contentName = opts.contentName;
+        // Resolve API config
+        const sourceRoot = context.sourceRoot || node_path_1.default.resolve(__dirname, '..', '..');
+        // Try loading env file
+        const envFilePath = opts.envFile
+            ? node_path_1.default.resolve(opts.envFile)
+            : node_path_1.default.join(sourceRoot, 'openai-text-to-image-storyboard', '.env');
+        if (node_fs_1.default.existsSync(envFilePath)) {
+            const envContent = node_fs_1.default.readFileSync(envFilePath, 'utf-8');
+            for (const line of envContent.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#'))
+                    continue;
+                const eqIndex = trimmed.indexOf('=');
+                if (eqIndex === -1)
+                    continue;
+                let key = trimmed.slice(0, eqIndex).trim();
+                let val = trimmed.slice(eqIndex + 1).trim();
+                if (key.startsWith('export '))
+                    key = key.slice(7).trim();
+                // Strip quotes
+                if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+                    val = val.slice(1, -1);
+                }
+                if (!process.env[key]) {
+                    process.env[key] = val;
+                }
+            }
+        }
+        const apiUrl = opts.apiUrl || process.env.OPENAI_API_URL || '';
+        const apiKey = opts.apiKey || process.env.OPENAI_API_KEY || '';
+        const imageModel = opts.imageModel || process.env.OPENAI_IMAGE_MODEL || 'gpt-image-1';
+        const aspectRatio = opts.aspectRatio || process.env.OPENAI_IMAGE_RATIO || process.env.OPENAI_IMAGE_ASPECT_RATIO || null;
+        const imageSize = opts.imageSize || process.env.OPENAI_IMAGE_SIZE || null;
+        const quality = opts.quality || process.env.OPENAI_IMAGE_QUALITY || null;
+        const style = opts.style || process.env.OPENAI_IMAGE_STYLE || null;
+        if (!apiUrl) {
+            stderr.write('Error: Missing API URL. Set --api-url or OPENAI_API_URL.\n');
+            return 1;
+        }
+        if (!apiKey) {
+            stderr.write('Error: Missing API key. Set --api-key or OPENAI_API_KEY.\n');
+            return 1;
+        }
+        // Build prompt items
+        let promptItems;
+        if (opts.promptsFile) {
+            promptItems = parsePromptsFile(node_path_1.default.resolve(opts.promptsFile));
+        }
+        else if (opts.prompts.length > 0) {
+            promptItems = opts.prompts.map((p, i) => ({ title: `scene-${i + 1}`, prompt: p.trim() }));
+        }
+        else {
+            stderr.write('Error: Either --prompts-file or at least one --prompt is required.\n');
+            return 1;
+        }
+        if (promptItems.length === 0) {
+            stderr.write('Error: No prompts provided.\n');
+            return 1;
+        }
+        const outputDir = node_path_1.default.join(projectDir, 'pictures', sanitizeComponent(contentName, 'untitled-content'));
+        node_fs_1.default.mkdirSync(outputDir, { recursive: true });
+        const records = [];
+        for (let i = 0; i < promptItems.length; i++) {
+            const item = promptItems[i];
+            const titleSlug = sanitizeComponent(item.title, `scene-${i + 1}`);
+            const imagePath = uniquePath(node_path_1.default.join(outputDir, `${String(i + 1).padStart(2, '0')}_${titleSlug}.png`));
+            const payload = {
+                model: imageModel,
+                prompt: item.prompt,
+            };
+            if (aspectRatio)
+                payload.aspect_ratio = aspectRatio;
+            if (imageSize)
+                payload.size = imageSize;
+            if (quality)
+                payload.quality = quality;
+            if (style)
+                payload.style = style;
+            const response = await postJson(apiUrl, '/images/generations', apiKey, payload);
+            const data = response.data;
+            if (!Array.isArray(data) || data.length === 0) {
+                stderr.write(`Error: No image data returned for prompt ${i + 1}.\n`);
+                continue;
+            }
+            const first = data[0];
+            let imageBytes;
+            if (typeof first.b64_json === 'string') {
+                imageBytes = Buffer.from(first.b64_json, 'base64');
+            }
+            else if (typeof first.url === 'string') {
+                imageBytes = await fetchBinary(first.url);
+            }
+            else {
+                stderr.write(`Error: Image payload missing b64_json/url for prompt ${i + 1}.\n`);
+                continue;
+            }
+            node_fs_1.default.writeFileSync(imagePath, imageBytes);
+            const record = {
+                index: i + 1,
+                title: item.title,
+                prompt: item.prompt,
+                file: imagePath,
+            };
+            if (typeof first.revised_prompt === 'string') {
+                record.revised_prompt = first.revised_prompt;
+            }
+            records.push(record);
+            stdout.write(`[OK] Generated ${imagePath}\n`);
+        }
+        // Write summary
+        const summary = {
+            content_name: contentName,
+            project_dir: projectDir,
+            output_dir: outputDir,
+            image_model: imageModel,
+            images: records,
+        };
+        if (aspectRatio)
+            summary.aspect_ratio = aspectRatio;
+        if (imageSize)
+            summary.image_size = imageSize;
+        const summaryPath = node_path_1.default.join(outputDir, 'storyboard.json');
+        node_fs_1.default.writeFileSync(summaryPath, JSON.stringify(summary, null, 2), 'utf-8');
+        stdout.write(`[OK] Wrote plan to ${summaryPath}\n`);
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'Unknown error';
+        stderr.write(`Error: ${msg}\n`);
+        return 1;
+    }
+}

package/dist/lib/tools/log-cli-utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Normalize a raw timestamp string: strip whitespace, replace comma with dot,
+ * and convert trailing Z to +00:00.
+ */
+export declare function normalizeTimestamp(raw: string): string;
+/**
+ * Parse a CLI-provided timestamp string into a Date.
+ * Naive timestamps are assigned the assumeTimezone offset.
+ */
+export declare function parseCliTimestamp(raw: string, assumeTimezone: string): Date;
+/**
+ * Extract an ISO 8601 timestamp from a log line and parse it into a Date.
+ * Returns null if no timestamp is found or parsing fails.
+ */
+export declare function extractTimestamp(line: string, assumeTimezone: string): Date | null;
+/**
+ * Build a timezone offset in minutes from a timezone string.
+ * Supports "UTC" and "±HH:MM" formats.
+ */
+export declare function buildTimezone(raw: string): number;
+/**
+ * Validate that start is not later than end.
+ * Writes an error message to stderr and returns false if the order is inverted.
+ */
+export declare function validateTimeWindow(start: Date | null, end: Date | null, stderr: NodeJS.WriteStream): boolean;
+/**
+ * Check whether a timestamp falls within a given [start, end] window (inclusive).
+ * Returns false if timestamp is null.
+ */
+export declare function inWindow(timestamp: Date | null, start: Date | null, end: Date | null): boolean;
+/**
+ * Iterate over lines from file paths or stdin.
+ * When paths is empty or contains "-", reads from stdin.
+ */
+export declare function iterInputLines(paths: string[]): AsyncGenerator<string>;