@phuetz/code-buddy 1.6.0 → 2.0.0

package/dist/companion/maison-voice-actions.js

@@ -0,0 +1,192 @@
+import { CookingTimerStore, HomeModeStore, findNextZonedMinute, } from '../life-rhythm/index.js';
+import { MealPlanStore } from '../meals/index.js';
+import { logger } from '../utils/logger.js';
+import { normalizeVoiceInteractionText } from '../sensory/voice-interactions.js';
+function parseSpokenDuration(text) {
+    const match = text.match(/\b(\d{1,3})\s*(seconde|secondes|minute|minutes|heure|heures)\b/);
+    if (!match)
+        return undefined;
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const multiplier = unit.startsWith('seconde')
+        ? 1_000
+        : unit.startsWith('minute')
+            ? 60_000
+            : 3_600_000;
+    const durationMs = amount * multiplier;
+    return durationMs >= 1_000 && durationMs <= 24 * 3_600_000 ? durationMs : undefined;
+}
+function cleanTimerLabel(value) {
+    const normalized = value?.replace(/^(?:le|la|les|des|du|de l)\s+/, '').trim();
+    return normalized?.slice(0, 120) || 'cuisson';
+}
+/** Conservative deterministic parser: only explicit Maison/minuteur wording is intercepted. */
+export function parseMaisonVoiceCommand(heard) {
+    const text = normalizeVoiceInteractionText(heard).replace(/^lisa\s+/, '').replace(/\s+lisa$/, '');
+    if (!text)
+        return null;
+    const timerDuration = parseSpokenDuration(text);
+    if (/\b(?:minuteur|chrono|chronometre)\b/.test(text) && /\b(?:mets|met|lance|demarre|regle|programme)\b/.test(text)) {
+        if (!timerDuration)
+            return null;
+        const label = text.match(/\b(?:pour|nomme|appele)\s+(.+)$/)?.[1];
+        return { kind: 'timer-start', durationMs: timerDuration, label: cleanTimerLabel(label) };
+    }
+    if (/\b(?:liste|quels|montre|reste)\b.*\b(?:minuteur|minuteurs|chronos?)\b/.test(text)) {
+        return { kind: 'timer-list' };
+    }
+    const cancelTimer = text.match(/\b(?:annule|arrete|supprime)\s+(?:le\s+)?(?:minuteur|chrono)(?:\s+(?:de|des|du|pour))?\s*(.*)$/);
+    if (cancelTimer)
+        return { kind: 'timer-cancel', label: cleanTimerLabel(cancelTimer[1]) };
+    const ackTimer = text.match(/\b(?:acquitte|confirme|ok|c est bon|j ai vu)\b.*\b(?:minuteur|chrono)\b(?:\s+(?:de|des|du|pour))?\s*(.*)$/);
+    if (ackTimer)
+        return { kind: 'timer-ack', ...(ackTimer[1]?.trim() ? { label: cleanTimerLabel(ackTimer[1]) } : {}) };
+    if (/^(?:qu est ce qu on mange|on mange quoi|quel est le prochain repas|qu est ce qui est prevu (?:pour|au) (?:repas|dejeuner|diner))$/.test(text)) {
+        return { kind: 'meal-next' };
+    }
+    const explicitDuration = parseSpokenDuration(text);
+    if (/\b(?:silence|mode silencieux|ne me derange pas|ne parle pas)\b/.test(text)) {
+        return {
+            kind: 'mode',
+            mode: 'silent',
+            ...(explicitDuration ? { durationMs: explicitDuration } : {}),
+            ...(/\b(?:aujourd hui|jusqu a demain)\b/.test(text) ? { boundaryHour: 0 } : {}),
+        };
+    }
+    if (/\b(?:je vais dormir|je vais me coucher|bonne nuit)\b/.test(text)) {
+        return { kind: 'mode', mode: 'rest', boundaryHour: 8 };
+    }
+    if (/\b(?:mode concentration|mode focus|je veux me concentrer|protege mon attention)\b/.test(text)) {
+        return { kind: 'mode', mode: 'focus', ...(explicitDuration ? { durationMs: explicitDuration } : {}) };
+    }
+    if (/\b(?:mode repos|je veux me reposer|laisse moi me reposer)\b/.test(text)) {
+        return { kind: 'mode', mode: 'rest', ...(explicitDuration ? { durationMs: explicitDuration } : {}) };
+    }
+    if (/\b(?:mode cuisine|je vais cuisiner|on cuisine|commencons a cuisiner)\b/.test(text)) {
+        return { kind: 'mode', mode: 'cooking' };
+    }
+    if (/\b(?:mode invites|j ai des invites|on a des invites)\b/.test(text)) {
+        return { kind: 'mode', mode: 'guests' };
+    }
+    if (/\b(?:les invites sont partis|fin du mode invites)\b/.test(text)) {
+        return { kind: 'mode', mode: 'normal' };
+    }
+    if (/\b(?:mode absent|mode absence|je passe en mode absent)\b/.test(text)) {
+        return { kind: 'mode', mode: 'away' };
+    }
+    if (/\b(?:journee libre|mode journee libre|je suis en conge)\b/.test(text)) {
+        return { kind: 'mode', mode: 'free-day' };
+    }
+    if (/\b(?:mode normal|reprends le mode normal|tu peux reparler|je suis de retour|je suis rentre)\b/.test(text)) {
+        return { kind: 'mode', mode: 'normal' };
+    }
+    return null;
+}
+export function isMaisonVoiceCommand(text) {
+    return parseMaisonVoiceCommand(text) !== null;
+}
+function selectTimer(timers, label) {
+    if (!label)
+        return timers.length === 1 ? timers[0] : undefined;
+    const needle = normalizeVoiceInteractionText(label);
+    return timers.find((timer) => {
+        const candidate = normalizeVoiceInteractionText(timer.label);
+        return candidate.includes(needle) || needle.includes(candidate);
+    });
+}
+function modeConfirmation(mode) {
+    const confirmations = {
+        normal: 'D’accord, je repasse en mode normal.',
+        'free-day': 'D’accord, je garde la journée légère et vraiment libre.',
+        focus: 'D’accord, je protège ta concentration et je retiens les interruptions.',
+        rest: 'D’accord. Repose-toi, je reste disponible sans te solliciter.',
+        cooking: 'Mode cuisine activé. Je peux suivre les étapes et garder des minuteurs nommés.',
+        guests: 'Mode invités activé. Je masque les souvenirs, messages et projets personnels.',
+        away: 'Mode absent activé. Je ne parlerai pas dans une pièce vide.',
+        silent: 'D’accord, je reste silencieuse jusqu’à ce que tu me réactives.',
+    };
+    return confirmations[mode];
+}
+export async function handleMaisonVoiceCommand(text, deps) {
+    const command = parseMaisonVoiceCommand(text);
+    if (!command)
+        return false;
+    try {
+        const now = deps.now?.() ?? new Date();
+        if (Number.isNaN(now.getTime()))
+            throw new Error('Maison voice clock is invalid');
+        const timeZone = deps.timeZone
+            || process.env.CODEBUDDY_TIMEZONE
+            || Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const modes = deps.homeModeStore ?? new HomeModeStore();
+        const timers = deps.cookingTimerStore ?? new CookingTimerStore();
+        if (command.kind === 'meal-next') {
+            const upcoming = await (deps.mealPlanStore ?? new MealPlanStore()).nextUpcoming(now);
+            if (!upcoming) {
+                await deps.speak('Aucun repas n’est encore planifié. Je peux t’aider à en choisir un.');
+                return true;
+            }
+            const slotLabels = {
+                breakfast: 'le petit-déjeuner',
+                lunch: 'le déjeuner',
+                dinner: 'le dîner',
+                snack: 'l’en-cas',
+            };
+            const status = upcoming.entry.status === 'planned' ? 'est prévu' : 'est proposé';
+            await deps.speak(`${upcoming.entry.recipeTitle} ${status} pour ${slotLabels[upcoming.entry.slot]}, `
+                + `le ${upcoming.entry.localDate} à ${upcoming.entry.localTime}.`);
+            return true;
+        }
+        if (command.kind === 'mode') {
+            let durationMs = command.durationMs;
+            if (durationMs === undefined && command.boundaryHour !== undefined) {
+                durationMs = findNextZonedMinute(now, timeZone, command.boundaryHour, 0)
+                    .instant.getTime() - now.getTime();
+            }
+            await modes.setMode(command.mode, durationMs !== undefined ? { durationMs } : {});
+            await deps.speak(modeConfirmation(command.mode));
+            return true;
+        }
+        if (command.kind === 'timer-start') {
+            const timer = await timers.start(command.durationMs, command.label);
+            const minutes = Math.max(1, Math.round(timer.durationMs / 60_000));
+            await deps.speak(`Minuteur « ${timer.label} » lancé pour ${minutes} minute${minutes > 1 ? 's' : ''}.`);
+            return true;
+        }
+        const active = await timers.listActive(now);
+        if (command.kind === 'timer-list') {
+            if (active.length === 0)
+                await deps.speak('Aucun minuteur de cuisine n’est actif.');
+            else
+                await deps.speak(active.slice(0, 5).map((timer) => (timer.state === 'due'
+                    ? `${timer.label} est terminé`
+                    : `${timer.label}, encore ${Math.max(1, Math.ceil(timer.remainingMs / 60_000))} minute${timer.remainingMs > 60_000 ? 's' : ''}`)).join('. ') + '.');
+            return true;
+        }
+        const selected = selectTimer(active, command.label);
+        if (!selected) {
+            await deps.speak(active.length > 1
+                ? 'Dis-moi le nom du minuteur concerné.'
+                : 'Je ne trouve pas ce minuteur.');
+            return true;
+        }
+        if (command.kind === 'timer-cancel') {
+            await timers.cancel(selected.id);
+            await deps.speak(`Minuteur « ${selected.label} » annulé.`);
+            return true;
+        }
+        const acknowledged = await timers.acknowledge(selected.id, now);
+        await deps.speak(acknowledged
+            ? `Minuteur « ${selected.label} » acquitté.`
+            : `Le minuteur « ${selected.label} » n’est pas encore terminé.`);
+        return true;
+    }
+    catch (error) {
+        logger.warn('[maison-voice] command failed', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        await deps.speak('Je n’ai pas pu appliquer cette commande Maison. Rien n’a été supposé.');
+        return true;
+    }
+}
+//# sourceMappingURL=maison-voice-actions.js.map

package/dist/companion/migration.d.ts

@@ -0,0 +1,63 @@
+import { type CompanionContinuityOptions } from './continuity.js';
+export declare const COMPANION_MIGRATION_SCHEMA_VERSION: 1;
+export interface CompanionMigrationEnvelope {
+    format: 'codebuddy-companion-migration';
+    schemaVersion: typeof COMPANION_MIGRATION_SCHEMA_VERSION;
+    lineageId: string;
+    companionName: string;
+    createdAt: string;
+    encryption: {
+        algorithm: 'aes-256-gcm';
+        keyDerivation: 'scrypt';
+        salt: string;
+        iv: string;
+        authTag: string;
+    };
+    ciphertext: string;
+}
+export interface CompanionMigrationOptions extends CompanionContinuityOptions {
+    passphrase: string;
+    bundlePath?: string;
+    now?: Date;
+}
+export interface CompanionMigrationExportResult {
+    bundlePath: string;
+    lineageId: string;
+    companionName: string;
+    artifactCount: number;
+    plaintextBytes: number;
+    encryptedBytes: number;
+}
+export interface CompanionMigrationRestoreOptions extends CompanionMigrationOptions {
+    apply?: boolean;
+    overwrite?: boolean;
+}
+export interface CompanionMigrationRestoreResult {
+    bundlePath: string;
+    lineageId: string;
+    companionName: string;
+    valid: boolean;
+    applied: boolean;
+    writable: boolean;
+    planned: string[];
+    restored: string[];
+    unchanged: string[];
+    conflicts: string[];
+    errors: string[];
+}
+export declare function getCompanionMigrationKeyPath(homeDir?: string): string;
+export declare function getOrCreateCompanionMigrationPassphrase(homeDir?: string): {
+    passphrase: string;
+    keyPath: string;
+    created: boolean;
+};
+export declare function readCompanionMigrationPassphrase(options?: {
+    homeDir?: string;
+    keyFile?: string;
+}): {
+    passphrase: string;
+    keyPath: string | null;
+};
+export declare function exportCompanionMigration(options: CompanionMigrationOptions): CompanionMigrationExportResult;
+export declare function restoreCompanionMigration(options: CompanionMigrationRestoreOptions): CompanionMigrationRestoreResult;
+export declare function formatCompanionMigrationResult(result: CompanionMigrationExportResult | CompanionMigrationRestoreResult, keyPath?: string | null): string;

package/dist/companion/migration.js

@@ -0,0 +1,270 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes, scryptSync, } from 'node:crypto';
+import { existsSync, lstatSync, readFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { getCompanionContinuityStatus, } from './continuity.js';
+import { writeFileAtomicSync } from '../utils/atomic-write.js';
+export const COMPANION_MIGRATION_SCHEMA_VERSION = 1;
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function resolvedRoots(options) {
+    return {
+        cwd: path.resolve(options.cwd ?? process.cwd()),
+        homeDir: path.resolve(options.homeDir ?? homedir()),
+    };
+}
+function artifactPath(artifact, roots) {
+    const root = artifact.scope === 'project' ? roots.cwd : roots.homeDir;
+    const target = path.resolve(root, artifact.relativePath);
+    if (target !== root && !target.startsWith(`${root}${path.sep}`)) {
+        throw new Error(`Migration artifact escapes its ${artifact.scope} root: ${artifact.relativePath}`);
+    }
+    return target;
+}
+function envelopeAad(envelope) {
+    return Buffer.from(JSON.stringify({
+        format: envelope.format,
+        schemaVersion: envelope.schemaVersion,
+        lineageId: envelope.lineageId,
+        companionName: envelope.companionName,
+        createdAt: envelope.createdAt,
+    }), 'utf8');
+}
+function assertPassphrase(passphrase) {
+    if (passphrase.length < 16) {
+        throw new Error('The companion migration passphrase must contain at least 16 characters.');
+    }
+}
+function readEnvelope(bundlePath) {
+    const parsed = JSON.parse(readFileSync(bundlePath, 'utf8'));
+    if (parsed.format !== 'codebuddy-companion-migration') {
+        throw new Error('Not a Code Buddy companion migration bundle.');
+    }
+    if (parsed.schemaVersion !== COMPANION_MIGRATION_SCHEMA_VERSION) {
+        throw new Error(`Unsupported companion migration schema: ${String(parsed.schemaVersion)}.`);
+    }
+    if (parsed.encryption?.algorithm !== 'aes-256-gcm' || parsed.encryption.keyDerivation !== 'scrypt') {
+        throw new Error('Unsupported companion migration encryption parameters.');
+    }
+    return parsed;
+}
+function decryptPayload(envelope, passphrase) {
+    assertPassphrase(passphrase);
+    const key = scryptSync(passphrase, Buffer.from(envelope.encryption.salt, 'base64'), 32);
+    const decipher = createDecipheriv('aes-256-gcm', key, Buffer.from(envelope.encryption.iv, 'base64'));
+    decipher.setAAD(envelopeAad(envelope));
+    decipher.setAuthTag(Buffer.from(envelope.encryption.authTag, 'base64'));
+    const plaintext = Buffer.concat([
+        decipher.update(Buffer.from(envelope.ciphertext, 'base64')),
+        decipher.final(),
+    ]);
+    const payload = JSON.parse(plaintext.toString('utf8'));
+    if (payload.schemaVersion !== COMPANION_MIGRATION_SCHEMA_VERSION || payload.lineageId !== envelope.lineageId) {
+        throw new Error('Companion migration payload metadata does not match its authenticated envelope.');
+    }
+    return payload;
+}
+function defaultBundlePath(cwd, companionName, now) {
+    const stamp = now.toISOString().replace(/[-:.TZ]/g, '');
+    const safeName = companionName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'companion';
+    return path.join(cwd, '.codebuddy', 'companion', 'migrations', `${safeName}-${stamp}.cbm`);
+}
+function atomicWrite(target, content) {
+    writeFileAtomicSync(target, content, { mode: 0o600 });
+}
+export function getCompanionMigrationKeyPath(homeDir = homedir()) {
+    return path.join(path.resolve(homeDir), '.codebuddy', 'companion', 'migration.key');
+}
+export function getOrCreateCompanionMigrationPassphrase(homeDir = homedir()) {
+    const keyPath = getCompanionMigrationKeyPath(homeDir);
+    if (existsSync(keyPath)) {
+        return { passphrase: readFileSync(keyPath, 'utf8').trim(), keyPath, created: false };
+    }
+    const passphrase = randomBytes(32).toString('base64url');
+    atomicWrite(keyPath, `${passphrase}\n`);
+    return { passphrase, keyPath, created: true };
+}
+export function readCompanionMigrationPassphrase(options = {}) {
+    const fromEnvironment = process.env.CODEBUDDY_COMPANION_MIGRATION_KEY?.trim();
+    if (fromEnvironment)
+        return { passphrase: fromEnvironment, keyPath: null };
+    const keyPath = path.resolve(options.keyFile ?? getCompanionMigrationKeyPath(options.homeDir));
+    if (!existsSync(keyPath)) {
+        throw new Error(`Companion migration key not found: ${keyPath}`);
+    }
+    return { passphrase: readFileSync(keyPath, 'utf8').trim(), keyPath };
+}
+export function exportCompanionMigration(options) {
+    assertPassphrase(options.passphrase);
+    const status = getCompanionContinuityStatus(options);
+    if (!status.valid || !status.manifest) {
+        throw new Error('Companion continuity must verify successfully before a migration can be exported.');
+    }
+    const roots = resolvedRoots(options);
+    const artifacts = status.manifest.components
+        .filter(component => component.exists)
+        .map((component) => {
+        const content = readFileSync(artifactPath(component, roots));
+        return {
+            id: component.id,
+            scope: component.scope,
+            relativePath: component.relativePath,
+            sensitive: component.sensitive,
+            bytes: content.length,
+            sha256: sha256(content),
+            contentBase64: content.toString('base64'),
+        };
+    });
+    const manifestContent = readFileSync(status.path);
+    artifacts.push({
+        id: 'continuity-manifest',
+        scope: 'global',
+        relativePath: path.relative(roots.homeDir, status.path),
+        sensitive: true,
+        bytes: manifestContent.length,
+        sha256: sha256(manifestContent),
+        contentBase64: manifestContent.toString('base64'),
+    });
+    const now = options.now ?? new Date();
+    const payload = {
+        schemaVersion: COMPANION_MIGRATION_SCHEMA_VERSION,
+        lineageId: status.manifest.lineageId,
+        companionName: status.manifest.companionName,
+        humanName: status.manifest.humanName,
+        createdAt: now.toISOString(),
+        sourceManifest: status.manifest,
+        artifacts,
+    };
+    const plaintext = Buffer.from(JSON.stringify(payload), 'utf8');
+    const salt = randomBytes(32);
+    const iv = randomBytes(12);
+    const envelope = {
+        format: 'codebuddy-companion-migration',
+        schemaVersion: COMPANION_MIGRATION_SCHEMA_VERSION,
+        lineageId: payload.lineageId,
+        companionName: payload.companionName,
+        createdAt: payload.createdAt,
+        encryption: {
+            algorithm: 'aes-256-gcm',
+            keyDerivation: 'scrypt',
+            salt: salt.toString('base64'),
+            iv: iv.toString('base64'),
+            authTag: '',
+        },
+        ciphertext: '',
+    };
+    const key = scryptSync(options.passphrase, salt, 32);
+    const cipher = createCipheriv('aes-256-gcm', key, iv);
+    cipher.setAAD(envelopeAad(envelope));
+    const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    envelope.encryption.authTag = cipher.getAuthTag().toString('base64');
+    envelope.ciphertext = ciphertext.toString('base64');
+    const bundlePath = path.resolve(options.bundlePath ?? defaultBundlePath(roots.cwd, payload.companionName, now));
+    atomicWrite(bundlePath, `${JSON.stringify(envelope, null, 2)}\n`);
+    return {
+        bundlePath,
+        lineageId: payload.lineageId,
+        companionName: payload.companionName,
+        artifactCount: artifacts.length,
+        plaintextBytes: plaintext.length,
+        encryptedBytes: ciphertext.length,
+    };
+}
+export function restoreCompanionMigration(options) {
+    if (!options.bundlePath)
+        throw new Error('A companion migration bundle path is required.');
+    const bundlePath = path.resolve(options.bundlePath);
+    const result = {
+        bundlePath,
+        lineageId: '',
+        companionName: '',
+        valid: false,
+        applied: false,
+        writable: false,
+        planned: [],
+        restored: [],
+        unchanged: [],
+        conflicts: [],
+        errors: [],
+    };
+    try {
+        const payload = decryptPayload(readEnvelope(bundlePath), options.passphrase);
+        result.lineageId = payload.lineageId;
+        result.companionName = payload.companionName;
+        const roots = resolvedRoots(options);
+        const prepared = payload.artifacts.map((artifact) => {
+            const content = Buffer.from(artifact.contentBase64, 'base64');
+            if (content.length !== artifact.bytes || sha256(content) !== artifact.sha256) {
+                throw new Error(`Artifact integrity failed: ${artifact.id}`);
+            }
+            const target = artifactPath(artifact, roots);
+            if (existsSync(target) && lstatSync(target).isSymbolicLink()) {
+                throw new Error(`Refusing to restore through a symbolic link: ${target}`);
+            }
+            const existing = existsSync(target) ? readFileSync(target) : null;
+            if (existing && sha256(existing) === artifact.sha256)
+                result.unchanged.push(artifact.id);
+            else if (existing)
+                result.conflicts.push(artifact.id);
+            const differs = !existing || sha256(existing) !== artifact.sha256;
+            if (differs)
+                result.planned.push(artifact.id);
+            return { artifact, content, target, differs };
+        });
+        result.valid = true;
+        result.writable = result.conflicts.length === 0 || options.overwrite === true;
+        if (options.apply) {
+            if (!result.writable) {
+                result.errors.push('Existing artifacts differ. Review the dry run and use --overwrite to replace them.');
+                return result;
+            }
+            const ordered = prepared.sort((a, b) => Number(a.artifact.id === 'continuity-manifest') - Number(b.artifact.id === 'continuity-manifest'));
+            for (const item of ordered) {
+                if (!item.differs)
+                    continue;
+                atomicWrite(item.target, item.content);
+                result.restored.push(item.artifact.id);
+            }
+            result.applied = true;
+        }
+    }
+    catch (error) {
+        result.errors.push(error instanceof Error ? error.message : String(error));
+    }
+    return result;
+}
+export function formatCompanionMigrationResult(result, keyPath) {
+    if ('artifactCount' in result) {
+        return [
+            'Companion migration bundle created',
+            `Companion: ${result.companionName}`,
+            `Lineage: ${result.lineageId}`,
+            `Artifacts: ${result.artifactCount}`,
+            `Bundle: ${result.bundlePath}`,
+            keyPath ? `Recovery key: ${keyPath} (store separately from the bundle)` : 'Recovery key: provided by environment',
+        ].join('\n');
+    }
+    const lines = [
+        'Companion migration verification',
+        `Status: ${result.valid ? 'cryptographically valid' : 'invalid'}`,
+        `Mode: ${result.applied ? 'restored' : 'dry run'}`,
+        `Bundle: ${result.bundlePath}`,
+    ];
+    if (result.lineageId)
+        lines.push(`Lineage: ${result.lineageId}`);
+    if (result.companionName)
+        lines.push(`Companion: ${result.companionName}`);
+    lines.push(`Conflicts: ${result.conflicts.length}`, result.applied ? `Restored: ${result.restored.length}` : `Would restore: ${result.planned.length}`);
+    if (result.conflicts.length > 0)
+        lines.push(`Different existing artifacts: ${result.conflicts.join(', ')}`);
+    if (result.errors.length > 0)
+        lines.push(`Errors: ${result.errors.join('; ')}`);
+    if (result.valid && !result.applied) {
+        lines.push('', result.writable
+            ? 'Dry run passed. Use --apply to restore.'
+            : 'Dry run found conflicts. Review them before using --apply --overwrite.');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=migration.js.map

package/dist/companion/mission-board.js

@@ -1,5 +1,5 @@
-import { mkdir, readFile, writeFile } from 'fs/promises';
 import * as path from 'path';
+import { readJsonAtomic, writeJsonAtomic } from '../utils/atomic-write.js';
 import { buildCompanionCompetitiveRadar, } from './competitive-radar.js';
 import { recordCompanionPercept } from './percepts.js';
 import { recordCompanionSafetyEvent } from './safety-ledger.js';
@@ -62,8 +62,7 @@ function parseMission(value) {
     };
 }
 async function writeMissionBoard(board) {
-    await mkdir(path.dirname(board.storePath), { recursive: true });
-    await writeFile(board.storePath, `${JSON.stringify(board, null, 2)}\n`, 'utf8');
+    await writeJsonAtomic(board.storePath, board, { mode: 0o600 });
 }
 function missionId(gap) {
     return `mission-${gap.id}`;
@@ -135,15 +134,13 @@ function sortMissions(missions) {
 }
 export async function readCompanionMissionBoard(options = {}) {
     const fallback = emptyBoard(options);
-    let raw;
-    try {
-        raw = await readFile(fallback.storePath, 'utf8');
-    }
-    catch {
+    const parsed = await readJsonAtomic(fallback.storePath, null, {
+        mode: 0o600,
+        isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value)),
+    });
+    if (!parsed)
         return fallback;
-    }
     try {
-        const parsed = JSON.parse(raw);
         const missions = Array.isArray(parsed.missions)
             ? parsed.missions.map(parseMission).filter((mission) => Boolean(mission))
             : [];

package/dist/companion/mission-runner.js

@@ -1,4 +1,4 @@
-import { mkdir, writeFile } from 'fs/promises';
+import { writeFileAtomic } from '../utils/atomic-write.js';
 import * as path from 'path';
 import { readCompanionMissionBoard, syncCompanionMissionBoard, updateCompanionMissionStatus, } from './mission-board.js';
 import { recordCompanionPercept } from './percepts.js';
@@ -162,8 +162,7 @@ export async function runNextCompanionMission(options = {}) {
             syncedBoard: synced,
         };
     }
-    await mkdir(path.dirname(targetPath), { recursive: true });
-    await writeFile(targetPath, brief, 'utf8');
+    await writeFileAtomic(targetPath, brief, { mode: 0o600 });
     let perceptId;
     let safetyEventId;
     try {

package/dist/companion/mobile-conversation-log.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Append-only PWA conversation journal (not the 20-turn LLM window).
+ * Path: ~/.codebuddy/companion/mobile-conversations/<sha256>.jsonl (0600).
+ */
+export declare const CONVERSATION_LOG_MAX_BYTES: number;
+export declare const CONVERSATION_LOG_MAX_AGE_MS: number;
+export interface ConversationLogEntry {
+    id: string;
+    role: 'user' | 'assistant';
+    text: string;
+    ts: number;
+}
+export declare function resolveConversationLogDir(env?: NodeJS.ProcessEnv): string;
+export declare function resolveConversationLogFile(userId: string | undefined, env?: NodeJS.ProcessEnv): string | null;
+export declare function appendConversationLog(userId: string | undefined, entries: readonly ConversationLogEntry[], env?: NodeJS.ProcessEnv): void;
+export declare function readConversationLog(userId: string | undefined, opts?: {
+    before?: string;
+    limit?: number;
+}, env?: NodeJS.ProcessEnv): ConversationLogEntry[];