@phuetz/code-buddy 1.6.1 → 2.0.0

package/dist/meeting/output.js

@@ -0,0 +1,155 @@
+import { randomUUID } from 'crypto';
+import { lstat, mkdir, open, rename, stat, unlink } from 'fs/promises';
+import { dirname, extname, join, resolve } from 'path';
+function slug(value) {
+    const normalized = value
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLocaleLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80);
+    return normalized || 'meeting-notes';
+}
+async function isDirectory(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Resolve a CLI-style output target: prefix, explicit .md/.json path, or existing directory. */
+export async function resolveMeetingOutputTargets(output, result) {
+    const absolute = resolve(output);
+    let prefix;
+    if (await isDirectory(absolute)) {
+        prefix = join(absolute, slug(result.notes.title));
+    }
+    else {
+        const extension = extname(absolute).toLocaleLowerCase();
+        prefix = extension === '.md' || extension === '.json'
+            ? absolute.slice(0, -extension.length)
+            : absolute;
+    }
+    return { markdown: `${prefix}.md`, json: `${prefix}.json` };
+}
+async function writeExclusivePair(targets, result) {
+    const opened = [];
+    try {
+        // Reserve both final paths before writing either payload. `wx` refuses
+        // regular files and symlinks alike, preventing an agent from replacing an
+        // unrelated workspace file through a crafted output prefix.
+        opened.push({
+            path: targets.markdown,
+            handle: await open(targets.markdown, 'wx', 0o600),
+        });
+        opened.push({
+            path: targets.json,
+            handle: await open(targets.json, 'wx', 0o600),
+        });
+        await Promise.all([
+            opened[0].handle.writeFile(result.markdown, 'utf8'),
+            opened[1].handle.writeFile(`${result.json}\n`, 'utf8'),
+        ]);
+        await Promise.all(opened.map(({ handle }) => handle.sync()));
+    }
+    catch (error) {
+        await Promise.all(opened.map(({ handle }) => handle.close().catch(() => undefined)));
+        await Promise.all(opened.map(({ path }) => unlink(path).catch(() => undefined)));
+        const code = error && typeof error === 'object' && 'code' in error
+            ? String(error.code)
+            : '';
+        if (code === 'EEXIST') {
+            throw new Error('Meeting report target already exists; choose another prefix or use --force from the CLI');
+        }
+        throw error;
+    }
+    finally {
+        await Promise.all(opened.map(({ handle }) => handle.close().catch(() => undefined)));
+    }
+}
+async function prepareReplacement(path, payload) {
+    const id = randomUUID();
+    const temporary = join(dirname(path), `.${String(process.pid)}.${id}.meeting.tmp`);
+    const backup = join(dirname(path), `.${String(process.pid)}.${id}.meeting.bak`);
+    let handle;
+    try {
+        handle = await open(temporary, 'wx', 0o600);
+        await handle.writeFile(payload, 'utf8');
+        await handle.chmod(0o600);
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
+        let hadOriginal = false;
+        try {
+            const existing = await lstat(path);
+            if (existing.isDirectory())
+                throw new Error(`Meeting report target is a directory: ${path}`);
+            hadOriginal = true;
+        }
+        catch (error) {
+            const code = error && typeof error === 'object' && 'code' in error
+                ? String(error.code)
+                : '';
+            if (code !== 'ENOENT')
+                throw error;
+        }
+        return { target: path, temporary, backup, hadOriginal, published: false };
+    }
+    catch (error) {
+        await handle?.close().catch(() => undefined);
+        await unlink(temporary).catch(() => undefined);
+        throw error;
+    }
+}
+async function replacePairWithRollback(targets, result) {
+    const prepared = [];
+    let committed = false;
+    try {
+        prepared.push(await prepareReplacement(targets.markdown, result.markdown));
+        prepared.push(await prepareReplacement(targets.json, `${result.json}\n`));
+        for (const item of prepared) {
+            if (item.hadOriginal)
+                await rename(item.target, item.backup);
+        }
+        for (const item of prepared) {
+            await rename(item.temporary, item.target);
+            item.published = true;
+        }
+        committed = true;
+    }
+    catch (error) {
+        // Restore the complete old pair on any failure after publication starts.
+        for (const item of [...prepared].reverse()) {
+            if (item.published)
+                await unlink(item.target).catch(() => undefined);
+            if (item.hadOriginal) {
+                await rename(item.backup, item.target).catch(() => undefined);
+            }
+            await unlink(item.temporary).catch(() => undefined);
+        }
+        throw error;
+    }
+    if (committed) {
+        await Promise.all(prepared
+            .filter((item) => item.hadOriginal)
+            .map((item) => unlink(item.backup).catch(() => undefined)));
+    }
+}
+/** Write the Markdown and JSON representations together without overwriting by default. */
+export async function writeMeetingOutputReports(output, result, options = {}) {
+    const targets = await resolveMeetingOutputTargets(output, result);
+    await Promise.all([
+        mkdir(dirname(targets.markdown), { recursive: true }),
+        mkdir(dirname(targets.json), { recursive: true }),
+    ]);
+    if (options.overwrite) {
+        await replacePairWithRollback(targets, result);
+    }
+    else {
+        await writeExclusivePair(targets, result);
+    }
+    return targets;
+}
+//# sourceMappingURL=output.js.map

package/dist/meeting/transcript.d.ts

@@ -0,0 +1,25 @@
+import type { MeetingNotesDependencies, MeetingNotesInput, MeetingTranscriptSegment } from './types.js';
+export declare const MEETING_MEDIA_EXTENSIONS: Set<string>;
+export declare const MEETING_TEXT_EXTENSIONS: Set<string>;
+export declare const MAX_MEETING_TRANSCRIPT_CHARACTERS: number;
+export declare const MAX_MEETING_TEXT_FILE_BYTES: number;
+export declare const MAX_MEETING_MEDIA_FILE_BYTES: number;
+export declare function assertSupportedMeetingFilePath(filePath: string): void;
+interface IngestedTranscript {
+    segments: MeetingTranscriptSegment[];
+    source: {
+        kind: 'text' | 'json' | 'media';
+        name: string | null;
+    };
+}
+/** Parse `HH:MM:SS(.mmm)` or `MM:SS(.mmm)` into seconds. */
+export declare function parseTranscriptTimestamp(value: string): number | null;
+/**
+ * Parse plain text, SRT/VTT, and common `[timestamp] Speaker: text` exports.
+ * Missing timestamps remain null rather than being invented.
+ */
+export declare function parseTextTranscript(text: string): MeetingTranscriptSegment[];
+/** Normalize common Whisper, diarization, and Code Buddy transcript JSON shapes. */
+export declare function parseJsonTranscript(value: unknown): MeetingTranscriptSegment[];
+export declare function ingestMeetingTranscript(input: MeetingNotesInput, deps?: MeetingNotesDependencies): Promise<IngestedTranscript>;
+export {};

package/dist/meeting/transcript.js

@@ -0,0 +1,292 @@
+import { basename, extname } from 'path';
+import { readFile, stat } from 'fs/promises';
+export const MEETING_MEDIA_EXTENSIONS = new Set([
+    '.aac', '.aiff', '.avi', '.flac', '.m4a', '.m4v', '.mkv', '.mov', '.mp3',
+    '.mp4', '.mpeg', '.mpg', '.oga', '.ogg', '.opus', '.wav', '.webm', '.wma',
+]);
+export const MEETING_TEXT_EXTENSIONS = new Set(['.json', '.md', '.srt', '.txt', '.vtt']);
+export const MAX_MEETING_TRANSCRIPT_CHARACTERS = 8 * 1024 * 1024;
+export const MAX_MEETING_TEXT_FILE_BYTES = 16 * 1024 * 1024;
+export const MAX_MEETING_MEDIA_FILE_BYTES = 1024 * 1024 * 1024;
+const SENSITIVE_MEETING_BASENAMES = new Set([
+    '.env', 'credentials', 'credentials.json', 'id_ed25519', 'id_rsa',
+    'secrets', 'secrets.json', 'settings.json',
+]);
+export function assertSupportedMeetingFilePath(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    const name = basename(filePath).toLowerCase();
+    const segments = filePath.split(/[\\/]+/u).map((segment) => segment.toLowerCase());
+    if (SENSITIVE_MEETING_BASENAMES.has(name) ||
+        name.startsWith('.env.') ||
+        ['.key', '.p12', '.pem', '.pfx'].includes(extension) ||
+        segments.some((segment) => segment === '.git' || segment === '.codebuddy')) {
+        throw new Error(`Sensitive files cannot be used as meeting input: ${name}`);
+    }
+    if (!MEETING_TEXT_EXTENSIONS.has(extension) && !MEETING_MEDIA_EXTENSIONS.has(extension)) {
+        throw new Error(`Unsupported meeting input extension "${extension || '(none)'}"; use TXT, MD, SRT, VTT, JSON, audio, or video`);
+    }
+}
+function assertTranscriptBounds(segments) {
+    if (segments.length > 100_000)
+        throw new Error('Meeting transcript has too many segments');
+    let characters = 0;
+    for (const segment of segments) {
+        characters += segment.text.length + (segment.speaker?.length ?? 0);
+        if (characters > MAX_MEETING_TRANSCRIPT_CHARACTERS) {
+            throw new Error('Meeting transcript exceeds the 8 MiB text safety limit');
+        }
+    }
+}
+function finiteNonNegative(value) {
+    const parsed = typeof value === 'number' ? value : typeof value === 'string' ? Number(value) : NaN;
+    return Number.isFinite(parsed) && parsed >= 0 ? Math.round(parsed * 1000) / 1000 : null;
+}
+/** Parse `HH:MM:SS(.mmm)` or `MM:SS(.mmm)` into seconds. */
+export function parseTranscriptTimestamp(value) {
+    const normalized = value.trim().replace(',', '.');
+    const pieces = normalized.split(':');
+    if (pieces.length < 2 || pieces.length > 3)
+        return null;
+    const values = pieces.map((piece) => Number(piece));
+    if (values.some((part) => !Number.isFinite(part) || part < 0))
+        return null;
+    if (pieces.length === 2) {
+        const [minutes, seconds] = values;
+        if (minutes === undefined || seconds === undefined || seconds >= 60)
+            return null;
+        return Math.round((minutes * 60 + seconds) * 1000) / 1000;
+    }
+    const [hours, minutes, seconds] = values;
+    if (hours === undefined || minutes === undefined || seconds === undefined || minutes >= 60 || seconds >= 60) {
+        return null;
+    }
+    return Math.round((hours * 3600 + minutes * 60 + seconds) * 1000) / 1000;
+}
+function cleanSpeakerAndText(raw) {
+    const text = raw.trim().replace(/^[-–—]\s*/, '');
+    const bracketed = /^\[([^\]]{1,60})\]\s+(.+)$/u.exec(text);
+    if (bracketed?.[1] && bracketed[2]) {
+        return { speaker: bracketed[1].trim(), text: bracketed[2].trim() };
+    }
+    const match = /^([^:\n]{1,60}):\s+(.+)$/u.exec(text);
+    if (!match?.[1] || !match[2])
+        return { speaker: null, text };
+    const candidate = match[1].trim();
+    // Avoid treating URLs and ordinary prose containing a colon as speaker labels.
+    if (/^(https?|file)$/i.test(candidate) || /[.!?]$/.test(candidate)) {
+        return { speaker: null, text };
+    }
+    return { speaker: candidate, text: match[2].trim() };
+}
+function pushSegment(target, value) {
+    const text = value.text.trim();
+    if (!text)
+        return;
+    target.push({
+        sequence: target.length + 1,
+        startSeconds: value.startSeconds ?? null,
+        endSeconds: value.endSeconds ?? null,
+        speaker: value.speaker?.trim() || null,
+        text,
+    });
+}
+/**
+ * Parse plain text, SRT/VTT, and common `[timestamp] Speaker: text` exports.
+ * Missing timestamps remain null rather than being invented.
+ */
+export function parseTextTranscript(text) {
+    const lines = text.replace(/^\uFEFF/, '').replace(/\r\n?/g, '\n').split('\n');
+    const segments = [];
+    for (let index = 0; index < lines.length;) {
+        const raw = lines[index]?.trim() ?? '';
+        if (!raw || raw === 'WEBVTT') {
+            index += 1;
+            continue;
+        }
+        // SRT cue number or WebVTT cue identifier before a timestamp range.
+        if (/-->/u.test(lines[index + 1] ?? '')) {
+            index += 1;
+            continue;
+        }
+        const range = /^\[?((?:\d{1,2}:)?\d{1,2}:\d{2}(?:[.,]\d+)?)\]?\s*-->\s*\[?((?:\d{1,2}:)?\d{1,2}:\d{2}(?:[.,]\d+)?)\]?(?:\s+.*)?$/u.exec(raw);
+        if (range?.[1] && range[2]) {
+            const cue = [];
+            index += 1;
+            while (index < lines.length) {
+                const next = lines[index]?.trim() ?? '';
+                if (!next)
+                    break;
+                if (/^\d+$/.test(next) && /-->/u.test(lines[index + 1] ?? ''))
+                    break;
+                if (/-->/u.test(next))
+                    break;
+                // Keep tags until the cue is assembled so WebVTT `<v Speaker>` can be
+                // interpreted as diarization metadata; formatting tags are stripped below.
+                cue.push(next);
+                index += 1;
+            }
+            const cueText = cue.join(' ');
+            const voice = /^<v\s+([^>]+)>([\s\S]*?)(?:<\/v>)?$/iu.exec(cueText);
+            const parsed = cleanSpeakerAndText((voice?.[2] ?? cueText).replace(/<[^>]+>/g, ''));
+            pushSegment(segments, {
+                startSeconds: parseTranscriptTimestamp(range[1]),
+                endSeconds: parseTranscriptTimestamp(range[2]),
+                speaker: parsed.speaker ?? voice?.[1]?.trim() ?? null,
+                text: parsed.text,
+            });
+            continue;
+        }
+        const stamped = /^\[?((?:\d{1,2}:)?\d{1,2}:\d{2}(?:[.,]\d+)?)\]?\s*(?:[-–—]\s*)?(.+)$/u.exec(raw);
+        if (stamped?.[1] && stamped[2]) {
+            const parsed = cleanSpeakerAndText(stamped[2]);
+            pushSegment(segments, {
+                startSeconds: parseTranscriptTimestamp(stamped[1]),
+                ...parsed,
+            });
+            index += 1;
+            continue;
+        }
+        const parsed = cleanSpeakerAndText(raw.replace(/<[^>]+>/g, ''));
+        pushSegment(segments, parsed);
+        index += 1;
+    }
+    return segments;
+}
+function pickArray(value) {
+    const candidates = [value.segments, value.transcript, value.utterances, value.results];
+    for (const candidate of candidates) {
+        if (Array.isArray(candidate))
+            return candidate;
+        if (candidate && typeof candidate === 'object') {
+            const nested = candidate;
+            if (Array.isArray(nested.segments))
+                return nested.segments;
+        }
+    }
+    return null;
+}
+function firstString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return null;
+}
+/** Normalize common Whisper, diarization, and Code Buddy transcript JSON shapes. */
+export function parseJsonTranscript(value) {
+    if (typeof value === 'string')
+        return parseTextTranscript(value);
+    let items = Array.isArray(value) ? value : null;
+    if (!items && value && typeof value === 'object') {
+        const record = value;
+        if (typeof record.transcript === 'string')
+            return parseTextTranscript(record.transcript);
+        if (typeof record.text === 'string' && !pickArray(record))
+            return parseTextTranscript(record.text);
+        items = pickArray(record);
+    }
+    if (!items)
+        throw new Error('Unsupported transcript JSON: expected text or a segments/transcript/utterances/results array');
+    const segments = [];
+    for (const item of items) {
+        if (typeof item === 'string') {
+            pushSegment(segments, cleanSpeakerAndText(item));
+            continue;
+        }
+        if (!item || typeof item !== 'object')
+            continue;
+        const record = item;
+        const text = firstString(record, ['text', 'said', 'utterance', 'content']);
+        if (!text)
+            continue;
+        const speaker = firstString(record, ['speaker', 'speaker_label', 'speakerLabel', 'name']);
+        const startSeconds = finiteNonNegative(record.startSeconds ?? record.start ?? record.t_start ?? record.offset);
+        const endSeconds = finiteNonNegative(record.endSeconds ?? record.end ?? record.t_end);
+        pushSegment(segments, { startSeconds, endSeconds, speaker, text });
+    }
+    return segments;
+}
+async function transcribeMedia(path, deps) {
+    let transcribe = deps.transcribe;
+    if (!transcribe) {
+        const { transcribeLong } = await import('../tools/video/long-transcribe.js');
+        transcribe = transcribeLong;
+    }
+    const timed = await transcribe(path);
+    const segments = [];
+    for (const item of timed) {
+        pushSegment(segments, {
+            startSeconds: finiteNonNegative(item.t_start),
+            endSeconds: finiteNonNegative(item.t_end),
+            text: item.said,
+        });
+    }
+    if (segments.length === 0) {
+        throw new Error(`No speech could be transcribed from ${basename(path)}`);
+    }
+    return segments;
+}
+export async function ingestMeetingTranscript(input, deps = {}) {
+    if (input.kind === 'text') {
+        if (input.text.length > MAX_MEETING_TRANSCRIPT_CHARACTERS) {
+            throw new Error('Meeting transcript exceeds the 8 MiB text safety limit');
+        }
+        const segments = parseTextTranscript(input.text);
+        assertTranscriptBounds(segments);
+        if (segments.length === 0)
+            throw new Error('The text transcript is empty');
+        return { segments, source: { kind: 'text', name: input.sourceName?.trim() || null } };
+    }
+    if (input.kind === 'json') {
+        const segments = parseJsonTranscript(input.value);
+        assertTranscriptBounds(segments);
+        if (segments.length === 0)
+            throw new Error('The JSON transcript contains no usable speech segments');
+        return { segments, source: { kind: 'json', name: input.sourceName?.trim() || null } };
+    }
+    const name = basename(input.path);
+    const extension = extname(input.path).toLowerCase();
+    assertSupportedMeetingFilePath(input.path);
+    const sourceStat = await stat(input.path);
+    if (!sourceStat.isFile())
+        throw new Error(`Meeting input is not a regular file: ${name}`);
+    if (MEETING_MEDIA_EXTENSIONS.has(extension)) {
+        if (sourceStat.size > MAX_MEETING_MEDIA_FILE_BYTES) {
+            throw new Error(`Meeting media exceeds the ${MAX_MEETING_MEDIA_FILE_BYTES}-byte safety limit`);
+        }
+        const segments = await transcribeMedia(input.path, deps);
+        assertTranscriptBounds(segments);
+        return {
+            segments,
+            source: { kind: 'media', name },
+        };
+    }
+    if (sourceStat.size > MAX_MEETING_TEXT_FILE_BYTES) {
+        throw new Error(`Meeting transcript file exceeds the ${MAX_MEETING_TEXT_FILE_BYTES}-byte safety limit`);
+    }
+    const raw = await readFile(input.path, 'utf8');
+    if (extension === '.json') {
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            throw new Error(`Invalid transcript JSON in ${name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const segments = parseJsonTranscript(parsed);
+        assertTranscriptBounds(segments);
+        if (segments.length === 0)
+            throw new Error(`The JSON transcript ${name} contains no usable speech segments`);
+        return { segments, source: { kind: 'json', name } };
+    }
+    if (raw.includes('\0')) {
+        throw new Error(`Unsupported binary meeting input: ${name}`);
+    }
+    const segments = parseTextTranscript(raw);
+    assertTranscriptBounds(segments);
+    if (segments.length === 0)
+        throw new Error(`The transcript ${name} is empty`);
+    return { segments, source: { kind: 'text', name } };
+}
+//# sourceMappingURL=transcript.js.map

package/dist/meeting/types.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Stable, local-first meeting-notes schema.
+ *
+ * The transcript is always preserved from the source. LLM analysis may enrich
+ * the summary and extracted lists, but it is never allowed to replace or edit
+ * the transcript itself.
+ */
+export declare const MEETING_NOTES_SCHEMA_VERSION: 1;
+export interface MeetingTranscriptSegment {
+    /** Stable, one-based order in the source transcript. */
+    sequence: number;
+    /** Seconds from the beginning of the recording, or null when the source has no timestamp. */
+    startSeconds: number | null;
+    /** End time in seconds, or null when the source does not provide one. */
+    endSeconds: number | null;
+    /** Speaker label exactly as found in the source, or null. */
+    speaker: string | null;
+    text: string;
+}
+export interface MeetingParticipant {
+    name: string;
+    speakingTurns: number;
+}
+export interface MeetingEvidence {
+    /** One-based transcript segment containing the evidence. */
+    sequence: number;
+    /** Human-readable timestamp, null when the source was not timestamped. */
+    timestamp: string | null;
+    /** Exact source segment, never an LLM-generated quote. */
+    quote: string;
+}
+export interface MeetingDecision {
+    id: string;
+    text: string;
+    owner: string | null;
+    evidence: MeetingEvidence | null;
+}
+export interface MeetingActionItem {
+    id: string;
+    task: string;
+    owner: string | null;
+    /** ISO date when explicit, otherwise the verbatim relative deadline (for example "demain"). */
+    dueDate: string | null;
+    status: 'open';
+    evidence: MeetingEvidence | null;
+}
+export interface MeetingOpenQuestion {
+    id: string;
+    text: string;
+    owner: string | null;
+    evidence: MeetingEvidence | null;
+}
+export interface MeetingNotes {
+    schemaVersion: typeof MEETING_NOTES_SCHEMA_VERSION;
+    generatedAt: string;
+    language: string;
+    analysisMode: 'ai' | 'deterministic';
+    source: {
+        kind: 'text' | 'json' | 'media';
+        /** Basename or caller-provided label only; absolute local paths are not exported. */
+        name: string | null;
+    };
+    title: string;
+    summary: string;
+    keyPoints: string[];
+    participants: MeetingParticipant[];
+    decisions: MeetingDecision[];
+    actionItems: MeetingActionItem[];
+    openQuestions: MeetingOpenQuestion[];
+    transcript: MeetingTranscriptSegment[];
+}
+export type MeetingNotesInput = {
+    kind: 'text';
+    text: string;
+    sourceName?: string;
+} | {
+    kind: 'json';
+    value: unknown;
+    sourceName?: string;
+} | {
+    kind: 'file';
+    path: string;
+};
+export interface MeetingAnalyzerRequest {
+    systemPrompt: string;
+    userPrompt: string;
+    language: string;
+}
+/** Injectable one-shot analyzer; it returns raw JSON text. */
+export type MeetingAnalyzer = (request: MeetingAnalyzerRequest) => Promise<string>;
+export interface GenerateMeetingNotesOptions {
+    /** Requested output language. Default: `fr`. */
+    language?: string;
+    /** Set true to authorize optional LLM enrichment. Default: false (strictly local). */
+    useAI?: boolean;
+    /** Maximum transcript characters sent to an optional LLM. The full transcript remains in the output. */
+    maxAnalysisCharacters?: number;
+}
+export interface MeetingNotesDependencies {
+    analyzer?: MeetingAnalyzer;
+    transcribe?: (path: string) => Promise<Array<{
+        t_start: number;
+        t_end: number;
+        said: string;
+    }>>;
+    now?: () => Date;
+}
+export interface MeetingNotesResult {
+    notes: MeetingNotes;
+    markdown: string;
+    json: string;
+}

package/dist/meeting/types.js

@@ -0,0 +1,9 @@
+/**
+ * Stable, local-first meeting-notes schema.
+ *
+ * The transcript is always preserved from the source. LLM analysis may enrich
+ * the summary and extracted lists, but it is never allowed to replace or edit
+ * the transcript itself.
+ */
+export const MEETING_NOTES_SCHEMA_VERSION = 1;
+//# sourceMappingURL=types.js.map

package/dist/memory/adapters/network-memory-adapters.d.ts

@@ -1,5 +1,19 @@
 import type { MemoryProvider, MemoryRememberOptions } from '../memory-provider.js';
-import type { Memory } from '../persistent-memory.js';
+import type { Memory, MemoryConfig } from '../persistent-memory.js';
+/**
+ * Test-only escape hatch (TESTWRITE1, 2026-09-04). Every adapter below builds
+ * its `LocalMemoryProvider` fallback with zero arguments, which resolves the
+ * DEFAULT `PersistentMemoryManager` singleton — `.codebuddy/CODEBUDDY_MEMORY.md`
+ * under `process.cwd()`. A test exercising the "no API key" fallback path
+ * (the whole point of `Mem0MemoryProvider`/`HonchoMemoryProvider`/
+ * `SupermemoryMemoryProvider`) therefore writes into the real repo's tracked
+ * memory file unless it can point the fallback at a temp `projectMemoryPath`.
+ * `fallbackMemoryConfig` is that seam; omitting it keeps production behavior
+ * byte-identical (still `new LocalMemoryProvider()`).
+ */
+interface NetworkProviderTestOptions {
+    fallbackMemoryConfig?: Partial<MemoryConfig>;
+}
 export declare class Mem0MemoryProvider implements MemoryProvider {
     readonly id = "mem0";
     private fallback;
@@ -11,7 +25,7 @@ export declare class Mem0MemoryProvider implements MemoryProvider {
         apiKey?: string;
         baseUrl?: string;
         userId?: string;
-    });
+    } & NetworkProviderTestOptions);
     /** Remote is usable when self-hosted (base set) or a cloud key is present. */
     private isRemote;
     private headers;
@@ -43,7 +57,7 @@ export declare class HonchoMemoryProvider implements MemoryProvider {
         baseUrl?: string;
         workspace?: string;
         peer?: string;
-    });
+    } & NetworkProviderTestOptions);
     /**
      * Self-hosted Honcho runs without a key (any explicit base URL activates it);
      * cloud requires a key. This MUST mirror the readiness matrix's `configured`
@@ -71,7 +85,7 @@ export declare class SupermemoryMemoryProvider implements MemoryProvider {
         apiKey?: string;
         baseUrl?: string;
         containerTag?: string;
-    });
+    } & NetworkProviderTestOptions);
     private headers;
     initialize(): Promise<void>;
     remember(key: string, value: string, options?: MemoryRememberOptions): Promise<void>;
@@ -125,3 +139,4 @@ export declare class RetainDBMemoryProvider implements MemoryProvider {
     getRelevantMemories(query: string, limit?: number): Promise<Memory[]>;
     getContextForPrompt(): Promise<string>;
 }
+export {};

package/dist/memory/adapters/network-memory-adapters.js

@@ -74,7 +74,7 @@ function trimBase(url) {
 }
 // ============================================================================
 // Mem0 — OSS self-hosted REST server OR Mem0 Platform cloud.
-//   Self-hosted (MEM0_BASE_URL set, e.g. http://ministar-linux:8888):
+//   Self-hosted (MEM0_BASE_URL set, e.g. http://hub-linux:8888):
 //     POST {base}/memories  {messages,[user_id]}   ·  POST {base}/search {query,user_id}
 //     auth: X-API-Key (optional)                   ·  NO /v1 prefix
 //   Cloud (api.mem0.ai):
@@ -94,7 +94,7 @@ export class Mem0MemoryProvider {
         this.selfHosted = configuredBase !== '' && !/api\.mem0\.ai/i.test(configuredBase);
         this.baseUrl = trimBase(configuredBase || 'https://api.mem0.ai/v1');
         this.userId = options.userId ?? process.env.MEM0_USER_ID ?? 'codebuddy';
-        this.fallback = new LocalMemoryProvider();
+        this.fallback = new LocalMemoryProvider(options.fallbackMemoryConfig);
     }
     /** Remote is usable when self-hosted (base set) or a cloud key is present. */
     isRemote() {
@@ -203,7 +203,7 @@ export class HonchoMemoryProvider {
         this.workspace = options.workspace ?? process.env.HONCHO_WORKSPACE ?? 'codebuddy';
         this.peer = options.peer ?? process.env.HONCHO_PEER ?? 'codebuddy';
         this.session = process.env.HONCHO_SESSION ?? 'default';
-        this.fallback = new LocalMemoryProvider();
+        this.fallback = new LocalMemoryProvider(options.fallbackMemoryConfig);
     }
     /**
      * Self-hosted Honcho runs without a key (any explicit base URL activates it);
@@ -302,7 +302,7 @@ export class SupermemoryMemoryProvider {
         this.apiKey = options.apiKey ?? process.env.SUPERMEMORY_API_KEY ?? '';
         this.baseUrl = trimBase(options.baseUrl ?? process.env.SUPERMEMORY_BASE_URL ?? 'https://api.supermemory.ai');
         this.containerTag = options.containerTag ?? process.env.SUPERMEMORY_CONTAINER_TAG ?? 'codebuddy';
-        this.fallback = new LocalMemoryProvider();
+        this.fallback = new LocalMemoryProvider(options.fallbackMemoryConfig);
     }
     headers() {
         return { Authorization: `Bearer ${this.apiKey}` };