@phuetz/code-buddy 1.6.0 → 2.0.0

package/dist/lora/dataset-v3-plan.js

@@ -0,0 +1,121 @@
+/** Deterministic generation plan for the v3 Lisa identity dataset. */
+export const DATASET_V3_TRIGGER = 'ohwx lisa';
+const OUTFITS = {
+    'black-knit': 'black long-sleeve knit top with the signature silver pendant',
+    'navy-blazer': 'navy blazer over an ivory crew-neck top with the signature silver pendant',
+    'burgundy-sweater': 'burgundy crew-neck sweater with the signature silver pendant',
+    'denim-casual': 'dark denim jacket over a white top with the signature silver pendant',
+    'ivory-blouse': 'modest ivory blouse with the signature silver pendant',
+    'navy-dress': 'knee-length navy dress with the signature silver pendant and flat shoes',
+    'knee-skirt-blouse': 'fitted knee-length black skirt with a tucked ivory blouse, the signature silver pendant and classic heels',
+    'tailored-shorts': 'high-waisted tailored beige shorts with a fitted white top, the signature silver pendant and sandals',
+    'slit-evening-dress': 'elegant dark evening dress with a tasteful leg slit, the signature silver pendant and heels',
+    'short-summer-dress': 'flowing knee-length floral summer dress with the signature silver pendant and sandals',
+    'backless-evening-dress': 'elegant floor-length evening dress with an open back, the signature silver pendant and heels',
+};
+const SETTINGS = {
+    'gray-studio': 'seamless neutral gray studio',
+    'cream-studio': 'minimal cream studio',
+    'modern-interior': 'quiet modern interior',
+    'urban-overcast': 'clean overcast city street',
+    'garden-path': 'leafy garden path',
+    'gallery-hall': 'bright contemporary gallery hall',
+};
+const LIGHTING_PROMPTS = {
+    'studio-soft': 'soft controlled studio lighting',
+    'window-daylight': 'diffused natural window daylight',
+    'cinematic-side': 'controlled cinematic side lighting with a subtle rim',
+    'golden-hour': 'clean warm golden-hour light',
+};
+const FRAMING_PROMPTS = {
+    face: 'tight face close-up',
+    bust: 'head-and-shoulders bust portrait',
+    half: 'waist-up half-body portrait with hands visible when in frame',
+    full: 'sharp full-body photograph with hands and feet fully visible',
+    back: 'rear-view portrait showing the back or rear three-quarter pose',
+};
+function promptFor(slot) {
+    return [
+        DATASET_V3_TRIGGER,
+        OUTFITS[slot.outfitTag],
+        `${slot.pose}, ${slot.expression}`,
+        LIGHTING_PROMPTS[slot.lighting],
+        SETTINGS[slot.settingTag],
+        `${FRAMING_PROMPTS[slot.framing]}, simulated ${slot.focalHint} lens`,
+        'identity-edit photograph, sharp natural detail, no sunglasses, no blur, no filters, no occlusion',
+    ].join(', ');
+}
+function slot(draft) {
+    return Object.freeze({
+        slotId: draft.slotId,
+        framing: draft.framing,
+        angle: draft.angle,
+        expression: draft.expression,
+        lighting: draft.lighting,
+        outfitTag: draft.outfitTag,
+        settingTag: draft.settingTag,
+        focalHint: draft.focalHint,
+        prompt: promptFor(draft),
+        overgenCount: draft.overgenCount,
+    });
+}
+const DRAFTS = [
+    { slotId: 'face-front-neutral', framing: 'face', angle: 'front', expression: 'neutral-closed', lighting: 'studio-soft', outfitTag: 'black-knit', settingTag: 'gray-studio', focalHint: '85mm', pose: 'straight-on eye-level portrait', overgenCount: 4 },
+    { slotId: 'face-front-smile-closed', framing: 'face', angle: 'front', expression: 'smile-closed', lighting: 'window-daylight', outfitTag: 'ivory-blouse', settingTag: 'cream-studio', focalHint: '85mm', pose: 'straight-on eye-level portrait', overgenCount: 3 },
+    { slotId: 'face-front-smile-open', framing: 'face', angle: 'front', expression: 'smile-open', lighting: 'cinematic-side', outfitTag: 'navy-blazer', settingTag: 'modern-interior', focalHint: '85mm', pose: 'straight-on eye-level portrait', overgenCount: 4 },
+    { slotId: 'face-threequarter-left-neutral', framing: 'face', angle: 'threequarter-left', expression: 'neutral-closed', lighting: 'window-daylight', outfitTag: 'burgundy-sweater', settingTag: 'cream-studio', focalHint: '85mm', pose: 'three-quarter pose turned left', overgenCount: 3 },
+    { slotId: 'face-threequarter-left-pensive', framing: 'face', angle: 'threequarter-left', expression: 'pensive', lighting: 'cinematic-side', outfitTag: 'black-knit', settingTag: 'gallery-hall', focalHint: '85mm', pose: 'three-quarter pose turned left', overgenCount: 4 },
+    { slotId: 'face-threequarter-right-neutral', framing: 'face', angle: 'threequarter-right', expression: 'neutral-closed', lighting: 'studio-soft', outfitTag: 'navy-blazer', settingTag: 'gray-studio', focalHint: '85mm', pose: 'three-quarter pose turned right', overgenCount: 3 },
+    { slotId: 'face-threequarter-right-laugh', framing: 'face', angle: 'threequarter-right', expression: 'laugh', lighting: 'golden-hour', outfitTag: 'denim-casual', settingTag: 'garden-path', focalHint: '85mm', pose: 'three-quarter pose turned right', overgenCount: 4 },
+    { slotId: 'face-profile-left-neutral', framing: 'face', angle: 'profile-left', expression: 'neutral-closed', lighting: 'cinematic-side', outfitTag: 'ivory-blouse', settingTag: 'gray-studio', focalHint: '85mm', pose: 'exact left profile', overgenCount: 3 },
+    { slotId: 'face-profile-right-neutral', framing: 'face', angle: 'profile-right', expression: 'neutral-closed', lighting: 'cinematic-side', outfitTag: 'burgundy-sweater', settingTag: 'gray-studio', focalHint: '85mm', pose: 'exact right profile', overgenCount: 4 },
+    { slotId: 'face-gaze-up-pensive', framing: 'face', angle: 'gaze-up', expression: 'pensive', lighting: 'golden-hour', outfitTag: 'denim-casual', settingTag: 'urban-overcast', focalHint: '85mm', pose: 'front orientation with gaze lifted upward', overgenCount: 3 },
+    { slotId: 'face-gaze-down-neutral', framing: 'face', angle: 'gaze-down', expression: 'neutral-closed', lighting: 'window-daylight', outfitTag: 'black-knit', settingTag: 'modern-interior', focalHint: '85mm', pose: 'front orientation with gaze lowered', overgenCount: 4 },
+    { slotId: 'bust-front-neutral', framing: 'bust', angle: 'front', expression: 'neutral-closed', lighting: 'studio-soft', outfitTag: 'navy-blazer', settingTag: 'gray-studio', focalHint: '85mm', pose: 'upright straight-on pose', overgenCount: 3 },
+    { slotId: 'bust-front-smile-closed', framing: 'bust', angle: 'front', expression: 'smile-closed', lighting: 'window-daylight', outfitTag: 'ivory-blouse', settingTag: 'modern-interior', focalHint: '85mm', pose: 'relaxed straight-on pose', overgenCount: 4 },
+    { slotId: 'bust-front-laugh', framing: 'bust', angle: 'front', expression: 'laugh', lighting: 'golden-hour', outfitTag: 'denim-casual', settingTag: 'garden-path', focalHint: '50mm', pose: 'relaxed straight-on pose', overgenCount: 3 },
+    { slotId: 'bust-left-neutral', framing: 'bust', angle: 'threequarter-left', expression: 'neutral-closed', lighting: 'cinematic-side', outfitTag: 'burgundy-sweater', settingTag: 'gallery-hall', focalHint: '85mm', pose: 'shoulders turned three-quarter left', overgenCount: 4 },
+    { slotId: 'bust-left-smile-open', framing: 'bust', angle: 'threequarter-left', expression: 'smile-open', lighting: 'studio-soft', outfitTag: 'black-knit', settingTag: 'cream-studio', focalHint: '50mm', pose: 'shoulders turned three-quarter left', overgenCount: 3 },
+    { slotId: 'bust-right-smile-closed', framing: 'bust', angle: 'threequarter-right', expression: 'smile-closed', lighting: 'window-daylight', outfitTag: 'navy-blazer', settingTag: 'modern-interior', focalHint: '85mm', pose: 'shoulders turned three-quarter right', overgenCount: 4 },
+    { slotId: 'bust-right-pensive', framing: 'bust', angle: 'threequarter-right', expression: 'pensive', lighting: 'cinematic-side', outfitTag: 'ivory-blouse', settingTag: 'gray-studio', focalHint: '50mm', pose: 'shoulders turned three-quarter right', overgenCount: 3 },
+    { slotId: 'bust-profile-left-neutral', framing: 'bust', angle: 'profile-left', expression: 'neutral-closed', lighting: 'golden-hour', outfitTag: 'denim-casual', settingTag: 'urban-overcast', focalHint: '85mm', pose: 'left profile with relaxed shoulders', overgenCount: 4 },
+    { slotId: 'bust-profile-right-smile-closed', framing: 'bust', angle: 'profile-right', expression: 'smile-closed', lighting: 'studio-soft', outfitTag: 'burgundy-sweater', settingTag: 'cream-studio', focalHint: '85mm', pose: 'right profile with relaxed shoulders', overgenCount: 3 },
+    { slotId: 'half-front-neutral', framing: 'half', angle: 'front', expression: 'neutral-closed', lighting: 'studio-soft', outfitTag: 'black-knit', settingTag: 'gray-studio', focalHint: '50mm', pose: 'standing frontally with both hands relaxed and visible', overgenCount: 4 },
+    { slotId: 'half-front-smile-open', framing: 'half', angle: 'front', expression: 'smile-open', lighting: 'window-daylight', outfitTag: 'ivory-blouse', settingTag: 'modern-interior', focalHint: '50mm', pose: 'standing frontally with one hand resting at the waist', overgenCount: 3 },
+    { slotId: 'half-left-pensive', framing: 'half', angle: 'threequarter-left', expression: 'pensive', lighting: 'cinematic-side', outfitTag: 'navy-blazer', settingTag: 'gallery-hall', focalHint: '50mm', pose: 'standing three-quarter left with loosely folded arms', overgenCount: 4 },
+    { slotId: 'half-left-laugh', framing: 'half', angle: 'threequarter-left', expression: 'laugh', lighting: 'golden-hour', outfitTag: 'denim-casual', settingTag: 'garden-path', focalHint: '50mm', pose: 'standing three-quarter left with open relaxed posture', overgenCount: 3 },
+    { slotId: 'half-right-neutral', framing: 'half', angle: 'threequarter-right', expression: 'neutral-closed', lighting: 'window-daylight', outfitTag: 'burgundy-sweater', settingTag: 'cream-studio', focalHint: '50mm', pose: 'standing three-quarter right with both hands visible', overgenCount: 4 },
+    { slotId: 'half-right-smile-closed', framing: 'half', angle: 'threequarter-right', expression: 'smile-closed', lighting: 'studio-soft', outfitTag: 'navy-dress', settingTag: 'modern-interior', focalHint: '50mm', pose: 'standing three-quarter right with one hand at the hip', overgenCount: 3 },
+    { slotId: 'full-walking-front', framing: 'full', angle: 'front', expression: 'smile-closed', lighting: 'golden-hour', outfitTag: 'denim-casual', settingTag: 'urban-overcast', focalHint: '35mm', pose: 'walking naturally toward camera mid-stride', overgenCount: 4 },
+    { slotId: 'full-seated-left', framing: 'full', angle: 'threequarter-left', expression: 'pensive', lighting: 'window-daylight', outfitTag: 'navy-dress', settingTag: 'modern-interior', focalHint: '50mm', pose: 'seated naturally on a simple chair, hands and feet visible', overgenCount: 3 },
+    { slotId: 'full-arms-raised-right', framing: 'full', angle: 'threequarter-right', expression: 'smile-open', lighting: 'studio-soft', outfitTag: 'black-knit', settingTag: 'gray-studio', focalHint: '35mm', pose: 'standing with both arms raised in a natural celebratory movement', overgenCount: 4 },
+    { slotId: 'full-standing-front', framing: 'full', angle: 'front', expression: 'smile-closed', lighting: 'cinematic-side', outfitTag: 'navy-blazer', settingTag: 'gallery-hall', focalHint: '50mm', pose: 'standing in a balanced catalog pose with hands and feet visible', overgenCount: 3 },
+    { slotId: 'full-turning-left', framing: 'full', angle: 'threequarter-left', expression: 'laugh', lighting: 'golden-hour', outfitTag: 'ivory-blouse', settingTag: 'garden-path', focalHint: '35mm', pose: 'turning dynamically while taking a step, hands and feet visible', overgenCount: 4 },
+    { slotId: 'back-straight', framing: 'back', angle: 'back', expression: 'pensive', lighting: 'studio-soft', outfitTag: 'navy-dress', settingTag: 'gray-studio', focalHint: '50mm', pose: 'standing fully turned away from camera', overgenCount: 3 },
+    { slotId: 'back-threequarter-right', framing: 'back', angle: 'threequarter-back-right', expression: 'smile-closed', lighting: 'golden-hour', outfitTag: 'denim-casual', settingTag: 'garden-path', focalHint: '50mm', pose: 'walking away in a rear three-quarter right pose', overgenCount: 3 },
+    // Extension 2026-07-20 (demande Patrice) : plus de jambes visibles et de dos —
+    // toujours tier couvert (jupes/robes/short, dos nu élégant = fashion, pas d'explicite).
+    { slotId: 'full-skirt-walk-legs', framing: 'full', angle: 'front', expression: 'smile-closed', lighting: 'golden-hour', outfitTag: 'knee-skirt-blouse', settingTag: 'urban-overcast', focalHint: '35mm', pose: 'walking toward camera in a knee-length skirt, full legs and heels clearly visible', overgenCount: 4 },
+    { slotId: 'full-shorts-standing-legs', framing: 'full', angle: 'threequarter-right', expression: 'smile-open', lighting: 'window-daylight', outfitTag: 'tailored-shorts', settingTag: 'modern-interior', focalHint: '50mm', pose: 'standing relaxed in tailored shorts, long bare legs fully visible, one knee slightly bent', overgenCount: 4 },
+    { slotId: 'full-slit-dress-profile-legs', framing: 'full', angle: 'profile-left', expression: 'pensive', lighting: 'cinematic-side', outfitTag: 'slit-evening-dress', settingTag: 'gallery-hall', focalHint: '85mm', pose: 'standing in profile, elegant dress with a leg-revealing slit, one leg forward', overgenCount: 4 },
+    { slotId: 'full-seated-crossed-legs', framing: 'full', angle: 'front', expression: 'smile-closed', lighting: 'studio-soft', outfitTag: 'short-summer-dress', settingTag: 'gray-studio', focalHint: '50mm', pose: 'seated on a stool with legs elegantly crossed, calves and heels visible', overgenCount: 4 },
+    { slotId: 'back-backless-dress', framing: 'back', angle: 'back', expression: 'smile-closed', lighting: 'cinematic-side', outfitTag: 'backless-evening-dress', settingTag: 'gallery-hall', focalHint: '85mm', pose: 'standing turned away in an elegant backless evening dress, bare back visible, glancing over her shoulder', overgenCount: 4 },
+    { slotId: 'back-walk-away-legs', framing: 'back', angle: 'back', expression: 'neutral-closed', lighting: 'golden-hour', outfitTag: 'knee-skirt-blouse', settingTag: 'urban-overcast', focalHint: '35mm', pose: 'walking away from camera in a knee-length skirt, legs and heels visible mid-stride', overgenCount: 4 },
+];
+/** The frozen canonical plan. Callers may safely reuse it without I/O or randomness. */
+export const DATASET_V3_SLOTS = Object.freeze(DRAFTS.map(slot));
+/** Return the canonical deterministic v3 slot sequence.
+ * An optional trigger substitutes the persona trigger word in every prompt
+ * (multi-persona roster support) — same slots, same determinism. */
+export function createDatasetV3Plan(trigger = DATASET_V3_TRIGGER) {
+    if (trigger === DATASET_V3_TRIGGER)
+        return DATASET_V3_SLOTS;
+    const normalized = trigger.trim();
+    if (!normalized)
+        throw new Error('createDatasetV3Plan trigger must be non-empty');
+    return Object.freeze(DATASET_V3_SLOTS.map((slot) => Object.freeze({
+        ...slot,
+        prompt: slot.prompt.replace(DATASET_V3_TRIGGER, normalized),
+    })));
+}
+//# sourceMappingURL=dataset-v3-plan.js.map

package/dist/lora/dataset.d.ts

@@ -0,0 +1,26 @@
+/**
+ * LoRA dataset project: init folder layout, validate images + captions.
+ */
+import type { LoraDatasetValidation, LoraProjectMeta } from './types.js';
+export declare const IMAGE_EXT: Set<string>;
+export declare function defaultLoraRoot(cwd?: string): string;
+export declare function projectDir(name: string, root?: string): string;
+export declare function initLoraProject(options: {
+    name: string;
+    triggerPhrase: string;
+    root?: string;
+    character?: string;
+}): Promise<{
+    dir: string;
+    imagesDir: string;
+    metaPath: string;
+}>;
+export declare function buildDatasetReadme(meta: LoraProjectMeta): string;
+export declare function loadProjectMeta(dir: string): Promise<LoraProjectMeta | null>;
+export declare function resolveProjectDir(nameOrPath: string, root?: string): Promise<string>;
+export declare function listImages(imagesDir: string): Promise<string[]>;
+export declare function validateDataset(projectDirectory: string, options?: {
+    triggerPhrase?: string;
+}): Promise<LoraDatasetValidation>;
+/** Write missing captions as the trigger phrase (DreamBooth-style). */
+export declare function fillMissingCaptions(projectDirectory: string, triggerPhrase: string): Promise<number>;

package/dist/lora/dataset.js

@@ -0,0 +1,165 @@
+/**
+ * LoRA dataset project: init folder layout, validate images + captions.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+export const IMAGE_EXT = new Set(['.png', '.jpg', '.jpeg', '.webp', '.PNG', '.JPG', '.JPEG', '.WEBP']);
+export function defaultLoraRoot(cwd = process.cwd()) {
+    return path.join(cwd, '.codebuddy', 'lora');
+}
+export function projectDir(name, root) {
+    const safe = name.trim().replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'project';
+    return path.join(root ?? defaultLoraRoot(), safe);
+}
+export async function initLoraProject(options) {
+    const dir = projectDir(options.name, options.root);
+    const imagesDir = path.join(dir, 'images');
+    await fs.mkdir(imagesDir, { recursive: true });
+    const meta = {
+        name: options.name.trim() || 'project',
+        triggerPhrase: options.triggerPhrase.trim(),
+        createdAt: new Date().toISOString(),
+        ...(options.character?.trim() ? { character: options.character.trim() } : {}),
+        notes: 'Drop 40–50 PNG/JPG training images into images/. Optional same-stem .txt captions. ' +
+            'If captions are missing, triggerPhrase is used (fal/Krea requirement when auto_captioning=Off).',
+    };
+    const metaPath = path.join(dir, 'project.json');
+    await fs.writeFile(metaPath, JSON.stringify(meta, null, 2) + '\n', 'utf8');
+    await fs.writeFile(path.join(dir, 'README.md'), buildDatasetReadme(meta), 'utf8');
+    return { dir, imagesDir, metaPath };
+}
+export function buildDatasetReadme(meta) {
+    return `# LoRA project: ${meta.name}
+
+Trigger phrase: \`${meta.triggerPhrase || '(none)'}\`
+${meta.character ? `Character: ${meta.character}\n` : ''}
+## Dataset (Krea 2 / video-aligned)
+
+1. Put **40–50** images in \`images/\` (PNG/JPG/WebP).
+2. Same face/style/lighting variety; avoid heavy text overlays.
+3. Optional captions: \`images/001.jpg\` + \`images/001.txt\`.
+4. Without captions, training uses the **trigger phrase** (required for fal when auto_captioning is Off).
+
+## Next
+
+\`\`\`bash
+# Validate
+buddy lora validate ${meta.name}
+
+# Cloud train (needs FAL_KEY + CODEBUDDY_LORA_TRAIN=true)
+buddy lora train cloud ${meta.name} --steps 1000
+
+# Local plan (AI-Toolkit / musubi-style config + script)
+buddy lora train local ${meta.name}
+
+# After training: install into ComfyUI
+buddy lora install path/to/lora.safetensors --name ${meta.name}
+\`\`\`
+`;
+}
+export async function loadProjectMeta(dir) {
+    try {
+        const raw = await fs.readFile(path.join(dir, 'project.json'), 'utf8');
+        const j = JSON.parse(raw);
+        if (!j || typeof j.name !== 'string')
+            return null;
+        return j;
+    }
+    catch {
+        return null;
+    }
+}
+export async function resolveProjectDir(nameOrPath, root) {
+    const abs = path.isAbsolute(nameOrPath)
+        ? nameOrPath
+        : path.resolve(process.cwd(), nameOrPath);
+    try {
+        const st = await fs.stat(abs);
+        if (st.isDirectory())
+            return abs;
+    }
+    catch {
+        /* not a path */
+    }
+    return projectDir(nameOrPath, root);
+}
+export async function listImages(imagesDir) {
+    let names;
+    try {
+        names = await fs.readdir(imagesDir);
+    }
+    catch {
+        return [];
+    }
+    return names
+        .filter((n) => IMAGE_EXT.has(path.extname(n)))
+        .sort((a, b) => a.localeCompare(b));
+}
+export async function validateDataset(projectDirectory, options) {
+    const imagesDir = path.join(projectDirectory, 'images');
+    const errors = [];
+    const warnings = [];
+    const images = await listImages(imagesDir);
+    const missingCaptions = [];
+    let captionCount = 0;
+    if (images.length === 0) {
+        errors.push(`No images in ${imagesDir} (png/jpg/webp).`);
+    }
+    else if (images.length < 15) {
+        warnings.push(`Only ${images.length} images — Krea character LoRAs work best with ~40–50.`);
+    }
+    else if (images.length > 80) {
+        warnings.push(`${images.length} images — training will be slower; 40–50 is typical.`);
+    }
+    const meta = await loadProjectMeta(projectDirectory);
+    const trigger = (options?.triggerPhrase ?? meta?.triggerPhrase ?? '').trim();
+    for (const img of images) {
+        const stem = img.replace(/\.[^.]+$/, '');
+        const capPath = path.join(imagesDir, `${stem}.txt`);
+        try {
+            await fs.access(capPath);
+            captionCount += 1;
+        }
+        catch {
+            missingCaptions.push(img);
+        }
+    }
+    if (missingCaptions.length > 0 && !trigger) {
+        errors.push(`${missingCaptions.length} image(s) lack .txt captions and no trigger phrase is set ` +
+            '(required when auto_captioning=Off on fal/Krea).');
+    }
+    else if (missingCaptions.length > 0) {
+        warnings.push(`${missingCaptions.length} image(s) without captions will use trigger « ${trigger} ».`);
+    }
+    return {
+        ok: errors.length === 0 && images.length > 0,
+        imageCount: images.length,
+        captionCount,
+        missingCaptions,
+        images: images.map((n) => path.join(imagesDir, n)),
+        errors,
+        warnings,
+    };
+}
+/** Write missing captions as the trigger phrase (DreamBooth-style). */
+export async function fillMissingCaptions(projectDirectory, triggerPhrase) {
+    const phrase = triggerPhrase.trim();
+    if (!phrase)
+        throw new Error('triggerPhrase is required to fill captions');
+    const imagesDir = path.join(projectDirectory, 'images');
+    const images = await listImages(imagesDir);
+    let written = 0;
+    for (const img of images) {
+        const stem = img.replace(/\.[^.]+$/, '');
+        const capPath = path.join(imagesDir, `${stem}.txt`);
+        try {
+            await fs.access(capPath);
+        }
+        catch {
+            await fs.writeFile(capPath, phrase + '\n', 'utf8');
+            written += 1;
+        }
+    }
+    return written;
+}
+//# sourceMappingURL=dataset.js.map

package/dist/lora/fal-krea-trainer.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Cloud Krea 2 LoRA training via fal.ai queue API.
+ * Endpoint: fal-ai/krea-2-trainer · ~$0.003/step (min 100 steps charged).
+ */
+import type { LoraTrainCloudOptions, LoraTrainCloudResult } from './types.js';
+export declare function resolveFalKey(env?: NodeJS.ProcessEnv): string | undefined;
+export declare function uploadFileToFal(filePath: string, options?: {
+    apiKey?: string;
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<string>;
+export declare function submitKrea2Train(input: {
+    images_data_url: string;
+    trigger_phrase?: string;
+    auto_captioning?: string;
+    steps?: number;
+    learning_rate?: number;
+    resolution?: number;
+    debug_dataset?: boolean;
+}, options?: {
+    apiKey?: string;
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<{
+    requestId: string;
+    statusUrl: string;
+    responseUrl: string;
+}>;
+export declare function pollKrea2Train(requestId: string, options?: {
+    apiKey?: string;
+    fetch?: typeof fetch;
+    pollMs?: number;
+    timeoutMs?: number;
+    onStatus?: (status: string) => void;
+    signal?: AbortSignal;
+}): Promise<{
+    lora_file?: {
+        url: string;
+        file_name?: string;
+    };
+    config_file?: {
+        url: string;
+    };
+}>;
+export declare function downloadToFile(url: string, destPath: string, options?: {
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<void>;
+/** Full cloud train: optional local zip already packed; uploads if path given. */
+export declare function trainKrea2Cloud(options: LoraTrainCloudOptions & {
+    /** Local zip to upload when imagesDataUrl is empty / 'upload'. */
+    localZipPath?: string;
+    outDir?: string;
+}): Promise<LoraTrainCloudResult>;

package/dist/lora/fal-krea-trainer.js

@@ -0,0 +1,197 @@
+/**
+ * Cloud Krea 2 LoRA training via fal.ai queue API.
+ * Endpoint: fal-ai/krea-2-trainer · ~$0.003/step (min 100 steps charged).
+ */
+import fs from 'fs/promises';
+import path from 'path';
+const FAL_QUEUE = 'https://queue.fal.run';
+const FAL_ENDPOINT = 'fal-ai/krea-2-trainer';
+const FAL_UPLOAD = 'https://fal.media/files/upload';
+export function resolveFalKey(env = process.env) {
+    return env.FAL_KEY?.trim() || env.FAL_API_KEY?.trim() || undefined;
+}
+export async function uploadFileToFal(filePath, options) {
+    const apiKey = options?.apiKey ?? resolveFalKey();
+    if (!apiKey)
+        throw new Error('FAL_KEY is required to upload the dataset zip');
+    const fetchFn = options?.fetch ?? fetch;
+    const buf = await fs.readFile(filePath);
+    const fileName = path.basename(filePath);
+    const res = await fetchFn(FAL_UPLOAD, {
+        method: 'POST',
+        headers: {
+            Authorization: `Key ${apiKey}`,
+            'Content-Type': 'application/octet-stream',
+            'X-Fal-File-Name': fileName,
+        },
+        body: buf,
+        signal: options?.signal,
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`fal upload failed HTTP ${res.status}: ${text.slice(0, 400)}`);
+    }
+    const json = (await res.json());
+    const url = json.url ?? json.file_url ?? json.access_url;
+    if (!url)
+        throw new Error(`fal upload response missing url: ${JSON.stringify(json).slice(0, 200)}`);
+    return url;
+}
+export async function submitKrea2Train(input, options) {
+    const apiKey = options?.apiKey ?? resolveFalKey();
+    if (!apiKey)
+        throw new Error('FAL_KEY is required for cloud LoRA training');
+    const fetchFn = options?.fetch ?? fetch;
+    const res = await fetchFn(`${FAL_QUEUE}/${FAL_ENDPOINT}`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Key ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(input),
+        signal: options?.signal,
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`fal train submit failed HTTP ${res.status}: ${text.slice(0, 500)}`);
+    }
+    const json = (await res.json());
+    if (!json.request_id)
+        throw new Error('fal train submit missing request_id');
+    return {
+        requestId: json.request_id,
+        statusUrl: json.status_url ?? `${FAL_QUEUE}/${FAL_ENDPOINT}/requests/${json.request_id}/status`,
+        responseUrl: json.response_url ?? `${FAL_QUEUE}/${FAL_ENDPOINT}/requests/${json.request_id}`,
+    };
+}
+export async function pollKrea2Train(requestId, options) {
+    const apiKey = options?.apiKey ?? resolveFalKey();
+    if (!apiKey)
+        throw new Error('FAL_KEY is required');
+    const fetchFn = options?.fetch ?? fetch;
+    const pollMs = options?.pollMs ?? 5000;
+    const timeoutMs = options?.timeoutMs ?? 2 * 60 * 60 * 1000;
+    const started = Date.now();
+    const statusUrl = `${FAL_QUEUE}/${FAL_ENDPOINT}/requests/${requestId}/status`;
+    const resultUrl = `${FAL_QUEUE}/${FAL_ENDPOINT}/requests/${requestId}`;
+    while (Date.now() - started < timeoutMs) {
+        if (options?.signal?.aborted)
+            throw new Error('aborted');
+        const st = await fetchFn(`${statusUrl}?logs=0`, {
+            headers: { Authorization: `Key ${apiKey}` },
+            signal: options?.signal,
+        });
+        if (!st.ok) {
+            const text = await st.text().catch(() => '');
+            throw new Error(`fal status HTTP ${st.status}: ${text.slice(0, 300)}`);
+        }
+        const body = (await st.json());
+        const status = body.status ?? 'UNKNOWN';
+        options?.onStatus?.(status);
+        if (status === 'COMPLETED') {
+            const res = await fetchFn(resultUrl, {
+                headers: { Authorization: `Key ${apiKey}` },
+                signal: options?.signal,
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => '');
+                throw new Error(`fal result HTTP ${res.status}: ${text.slice(0, 400)}`);
+            }
+            return (await res.json());
+        }
+        if (status === 'FAILED' || status === 'CANCELLED') {
+            throw new Error(`fal train ended with status ${status}`);
+        }
+        await new Promise((r) => setTimeout(r, pollMs));
+    }
+    throw new Error(`fal train timed out after ${timeoutMs}ms`);
+}
+export async function downloadToFile(url, destPath, options) {
+    const fetchFn = options?.fetch ?? fetch;
+    const res = await fetchFn(url, { signal: options?.signal });
+    if (!res.ok)
+        throw new Error(`download failed HTTP ${res.status} for ${url}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    await fs.mkdir(path.dirname(destPath), { recursive: true });
+    await fs.writeFile(destPath, buf);
+}
+/** Full cloud train: optional local zip already packed; uploads if path given. */
+export async function trainKrea2Cloud(options) {
+    try {
+        const apiKey = options.apiKey ?? resolveFalKey();
+        if (!apiKey) {
+            return { success: false, error: 'FAL_KEY is not set' };
+        }
+        let imagesDataUrl = options.imagesDataUrl;
+        if (!imagesDataUrl || imagesDataUrl === 'upload') {
+            if (!options.localZipPath) {
+                return { success: false, error: 'imagesDataUrl or localZipPath required' };
+            }
+            options.onStatus?.('UPLOADING', options.localZipPath);
+            imagesDataUrl = await uploadFileToFal(options.localZipPath, {
+                apiKey,
+                fetch: options.fetch,
+                signal: options.signal,
+            });
+        }
+        const steps = Math.max(50, Math.min(10000, options.steps ?? 1000));
+        options.onStatus?.('SUBMITTING', `${steps} steps`);
+        const submitted = await submitKrea2Train({
+            images_data_url: imagesDataUrl,
+            ...(options.triggerPhrase ? { trigger_phrase: options.triggerPhrase } : {}),
+            auto_captioning: options.autoCaptioning ?? 'Off',
+            steps,
+            learning_rate: options.learningRate ?? 0.0005,
+            resolution: options.resolution ?? 768,
+            debug_dataset: options.debugDataset ?? false,
+        }, { apiKey, fetch: options.fetch, signal: options.signal });
+        options.onStatus?.('QUEUED', submitted.requestId);
+        const result = await pollKrea2Train(submitted.requestId, {
+            apiKey,
+            fetch: options.fetch,
+            pollMs: options.pollMs,
+            timeoutMs: options.timeoutMs,
+            onStatus: (s) => options.onStatus?.(s),
+            signal: options.signal,
+        });
+        const loraUrl = result.lora_file?.url;
+        if (!loraUrl) {
+            return {
+                success: false,
+                requestId: submitted.requestId,
+                error: 'Training completed but lora_file.url missing',
+                raw: result,
+            };
+        }
+        const outDir = options.outDir ?? path.join(process.cwd(), '.codebuddy', 'lora', 'output');
+        await fs.mkdir(outDir, { recursive: true });
+        const loraName = result.lora_file?.file_name || `krea2-${submitted.requestId.slice(0, 8)}.safetensors`;
+        const loraPath = path.join(outDir, loraName);
+        options.onStatus?.('DOWNLOADING', loraUrl);
+        await downloadToFile(loraUrl, loraPath, { fetch: options.fetch, signal: options.signal });
+        let configPath;
+        if (result.config_file?.url) {
+            configPath = path.join(outDir, `config-${submitted.requestId.slice(0, 8)}.json`);
+            await downloadToFile(result.config_file.url, configPath, {
+                fetch: options.fetch,
+                signal: options.signal,
+            });
+        }
+        return {
+            success: true,
+            requestId: submitted.requestId,
+            loraUrl,
+            configUrl: result.config_file?.url,
+            loraPath,
+            configPath,
+            raw: result,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+//# sourceMappingURL=fal-krea-trainer.js.map

package/dist/lora/generate-training-set.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Generate a synthetic LoRA training set for a character (e.g. Lisa) via image_generate.
+ * Uses a fixed identity block + varied poses/lighting so captions can share one trigger phrase.
+ */
+import { type AvatarId } from './lisa-avatar-bible.js';
+/**
+ * Stable visual identity for Lisa — default = dark brunette muse from
+ * https://www.youtube.com/watch?v=GQusMZgc1RE (multi-style training curriculum).
+ */
+export declare const LISA_IDENTITY_BLOCK: string;
+export type TrainingView = 'front' | 'three-quarter' | 'profile' | 'looking-away' | 'smile' | 'soft-smile' | 'close-up' | 'upper-body';
+export interface TrainingPromptSpec {
+    id: string;
+    view: TrainingView;
+    prompt: string;
+}
+/**
+ * Deterministic curriculum of training prompts (no randomness) for reproducible sets.
+ * Rotates view + style-pack inspiration + scene/outfit/light so the LoRA learns the
+ * face, not one outfit (Krea 2 multi-panel avatar pattern).
+ */
+export declare function buildLisaTrainingPrompts(count: number, identity?: string, avatarId?: AvatarId | string): TrainingPromptSpec[];
+export interface GenerateTrainingSetOptions {
+    name: string;
+    count?: number;
+    triggerPhrase?: string;
+    /** Avatar profile id (lisa = brunette muse, lisa-classic = soft chestnut). */
+    avatarId?: string;
+    rootDir?: string;
+    loraRoot?: string;
+    aspectRatio?: 'portrait' | 'square';
+    /** Skip images that already exist on disk. */
+    resume?: boolean;
+    env?: NodeJS.ProcessEnv;
+    generate?: (prompt: string, aspect: string) => Promise<{
+        success: boolean;
+        outputPath?: string | null;
+        error?: string;
+    }>;
+    onProgress?: (info: {
+        index: number;
+        total: number;
+        id: string;
+        ok: boolean;
+        error?: string;
+    }) => void;
+}
+export interface GenerateTrainingSetResult {
+    projectDir: string;
+    imagesDir: string;
+    generated: number;
+    skipped: number;
+    failed: number;
+    imagePaths: string[];
+    errors: string[];
+}
+export declare function generateLisaTrainingSet(options: GenerateTrainingSetOptions): Promise<GenerateTrainingSetResult>;
+export declare function ensureProjectAndCount(nameOrPath: string): Promise<{
+    dir: string;
+    imageCount: number;
+}>;