fluffy-context 0.1.0 → 0.3.0

package/dist/src/runtime/notes.js

@@ -0,0 +1,173 @@
+import crypto from 'node:crypto';
+import { access, readdir } from 'node:fs/promises';
+import { resolveProjectRoot } from '../project/project-resolver.js';
+import { filterPaths } from '../capture/context-filter.js';
+import { atomicWriteJson } from '../storage/atomic-write.js';
+import { isRecord, readJson } from '../storage/json-store.js';
+import { contextMetadataPath, contextsRoot, locksDirectory, notesPath, snapshotPath, snapshotsDirectory } from '../storage/layout.js';
+import { withLock } from '../storage/lock.js';
+function id() {
+    return `note-${Date.now().toString(36)}-${crypto.randomBytes(4).toString('hex')}`;
+}
+function isNotFound(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}
+function isNote(value) {
+    return isRecord(value)
+        && value.schemaVersion === 1
+        && typeof value.noteId === 'string'
+        && ['problem', 'action', 'observation', 'decision'].includes(value.kind)
+        && typeof value.message === 'string'
+        && value.message.trim().length > 0
+        && ['agent', 'human'].includes(value.actor)
+        && (typeof value.contextId === 'string' || value.contextId === null)
+        && (typeof value.snapshotId === 'string' || value.snapshotId === null)
+        && Array.isArray(value.relatedFiles) && value.relatedFiles.every((item) => typeof item === 'string')
+        && ['open', 'resolved'].includes(value.status)
+        && (typeof value.absorbedBySnapshotId === 'string' || value.absorbedBySnapshotId === null)
+        && typeof value.createdAt === 'string'
+        && typeof value.updatedAt === 'string';
+}
+function isNoteFile(value) {
+    return isRecord(value) && value.schemaVersion === 1 && Array.isArray(value.items) && value.items.every(isNote);
+}
+async function loadNotes(projectRoot) {
+    try {
+        return await readJson(notesPath(projectRoot), isNoteFile);
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return { schemaVersion: 1, items: [] };
+        throw error;
+    }
+}
+async function validateSource(projectRoot, contextId, snapshotId) {
+    if (!contextId && snapshotId)
+        throw new Error('source snapshot requires source context');
+    if (!contextId)
+        return;
+    await access(contextMetadataPath(projectRoot, contextId));
+    if (snapshotId)
+        await access(snapshotPath(projectRoot, contextId, snapshotId));
+}
+function limited(value, budget) {
+    return value.length <= budget ? value : value.slice(0, Math.max(0, budget - 1)) + '…';
+}
+export async function addNote(startPath, message, input = {}) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    const normalizedMessage = message.trim();
+    if (!normalizedMessage)
+        throw new Error('note message must not be empty');
+    await validateSource(projectRoot, input.contextId, input.snapshotId);
+    const relatedFiles = await filterPaths(projectRoot, (input.relatedFiles ?? []).map((item) => item.trim()).filter(Boolean));
+    return withLock(`${locksDirectory(projectRoot)}/notes.lock`, async () => {
+        const file = await loadNotes(projectRoot);
+        const now = new Date().toISOString();
+        const note = {
+            noteId: id(),
+            schemaVersion: 1,
+            kind: input.kind ?? 'observation',
+            message: normalizedMessage,
+            actor: input.actor ?? 'agent',
+            contextId: input.contextId ?? null,
+            snapshotId: input.snapshotId ?? null,
+            relatedFiles,
+            status: input.status ?? 'open',
+            absorbedBySnapshotId: null,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await atomicWriteJson(notesPath(projectRoot), { schemaVersion: 1, items: [...file.items, note] });
+        return note;
+    });
+}
+export async function listNotes(startPath, query = {}) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    const file = await loadNotes(projectRoot);
+    const limit = query.limit ?? 50;
+    const maxChars = query.maxChars ?? 500;
+    return file.items
+        .filter((note) => !query.contextId || note.contextId === query.contextId)
+        .filter((note) => !query.openOnly || (note.status === 'open' && note.absorbedBySnapshotId === null))
+        .sort((left, right) => right.createdAt.localeCompare(left.createdAt))
+        .slice(0, limit)
+        .map((note) => ({ ...note, message: limited(note.message, maxChars) }));
+}
+function noteActivity(note) {
+    if (!note.contextId)
+        return null;
+    return {
+        type: 'note',
+        occurredAt: note.createdAt,
+        contextId: note.contextId,
+        snapshotId: note.snapshotId ?? undefined,
+        noteId: note.noteId,
+        kind: note.kind,
+        message: note.message,
+        actor: note.actor,
+        status: note.status,
+        absorbedBySnapshotId: note.absorbedBySnapshotId,
+    };
+}
+async function checkpointActivities(projectRoot, contextId) {
+    const items = [];
+    let contextIds;
+    try {
+        contextIds = await readdir(contextsRoot(projectRoot));
+    }
+    catch {
+        contextIds = [];
+    }
+    for (const id of contextIds) {
+        if (contextId && id !== contextId)
+            continue;
+        try {
+            const context = await readJson(contextMetadataPath(projectRoot, id), (value) => isRecord(value) && typeof value.id === 'string' && typeof value.title === 'string' && (typeof value.currentSnapshotId === 'string' || value.currentSnapshotId === null));
+            if (!context.currentSnapshotId)
+                continue;
+            const snapshots = await readdir(snapshotsDirectory(projectRoot, id));
+            for (const fileName of snapshots.filter((name) => name.endsWith('.json'))) {
+                const snapshot = await readJson(snapshotPath(projectRoot, id, fileName.slice(0, -5)), (value) => isRecord(value) && value.schemaVersion === 1 && typeof value.snapshotId === 'string' && typeof value.createdAt === 'string' && (value.mode === 'baseline' || value.mode === 'patch'));
+                items.push({ type: 'checkpoint', occurredAt: snapshot.createdAt, contextId: id, snapshotId: snapshot.snapshotId, title: context.title });
+            }
+        }
+        catch {
+            // Doctor reports malformed activity sources.
+        }
+    }
+    return items;
+}
+export async function listActivity(startPath, query = {}) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    const notes = await loadNotes(projectRoot);
+    const noteItems = notes.items.map(noteActivity).filter((item) => item !== null);
+    const checkpointItems = await checkpointActivities(projectRoot, query.contextId);
+    const maxChars = query.maxChars ?? 500;
+    const items = [...noteItems, ...checkpointItems]
+        .filter((item) => !query.contextId || item.contextId === query.contextId)
+        .filter((item) => !query.since || item.occurredAt >= query.since)
+        .filter((item) => !query.openOnly || (item.type === 'note' && item.status === 'open' && item.absorbedBySnapshotId === null))
+        .sort((left, right) => right.occurredAt.localeCompare(left.occurredAt))
+        .slice(0, query.limit ?? 50)
+        .map((item) => item.message ? { ...item, message: limited(item.message, maxChars) } : item);
+    return { projectRoot, items };
+}
+export async function absorbNotes(startPath, contextId, snapshotId) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    return withLock(`${locksDirectory(projectRoot)}/notes.lock`, async () => {
+        const file = await loadNotes(projectRoot);
+        let absorbed = 0;
+        const items = file.items.map((note) => {
+            if (note.contextId !== contextId || note.absorbedBySnapshotId !== null)
+                return note;
+            absorbed += 1;
+            return { ...note, absorbedBySnapshotId: snapshotId, updatedAt: new Date().toISOString() };
+        });
+        if (absorbed > 0)
+            await atomicWriteJson(notesPath(projectRoot), { schemaVersion: 1, items });
+        return absorbed;
+    });
+}
+export function isValidNote(value) {
+    return isNote(value);
+}

package/dist/src/runtime/runtime.d.ts

@@ -0,0 +1,11 @@
+import type { CheckpointInput, CheckpointResult, IndexFile, ResumeResult, StructuredContext } from './types.js';
+export interface CheckpointOptions {
+    minSaveIntervalMs?: number;
+}
+export declare function rebuildSnapshot(projectRoot: string, contextId: string, snapshotId: string, seen?: Set<string>): Promise<StructuredContext>;
+export declare function rebuildIndex(projectRoot: string, persist?: boolean): Promise<IndexFile>;
+export declare function checkpoint(startPath: string | undefined, input: CheckpointInput, options?: CheckpointOptions): Promise<CheckpointResult>;
+export interface ResumeOptions {
+    touchLastUsedAt?: boolean;
+}
+export declare function resume(startPath?: string, contextId?: string, maxChars?: number, options?: ResumeOptions): Promise<ResumeResult>;

package/dist/src/runtime/runtime.js

@@ -8,6 +8,7 @@ import { withLock } from '../storage/lock.js';
 import { contextDirectory, contextMetadataPath, contextsRoot, indexPath, locksDirectory, snapshotPath, snapshotsDirectory, } from '../storage/layout.js';
 import { loadManifest } from './init.js';
 import { filterPaths } from '../capture/context-filter.js';
+import { absorbNotes } from './notes.js';
 const emptyContext = () => ({
     progressSummary: '',
     lastError: null,
@@ -46,6 +47,29 @@ function limitedList(values, budget) {
 function applyPatch(base, patch) {
     return { ...base, ...patch };
 }
+function isContextPatch(value) {
+    if (!isRecord(value))
+        return false;
+    const fields = ['progressSummary', 'lastError', 'completed', 'pendingTasks', 'decisions', 'risks', 'relatedFiles'];
+    if (Object.keys(value).some((key) => !fields.includes(key)))
+        return false;
+    return fields.every((field) => {
+        if (!(field in value))
+            return true;
+        const fieldValue = value[field];
+        if (field === 'lastError')
+            return typeof fieldValue === 'string' || fieldValue === null;
+        if (field === 'progressSummary')
+            return typeof fieldValue === 'string';
+        return isStringArray(fieldValue);
+    });
+}
+function normalizeText(value) {
+    return value.trim();
+}
+function normalizeList(values) {
+    return values.map(normalizeText).filter(Boolean);
+}
 function diffContext(previous, current) {
     const patch = {};
     if (previous.progressSummary !== current.progressSummary)
@@ -65,16 +89,17 @@ function diffContext(previous, current) {
     return patch;
 }
 async function contextFromInput(projectRoot, input, previous) {
-    const relatedFiles = await filterPaths(projectRoot, input.relatedFiles ?? previous?.relatedFiles ?? []);
-    return {
-        progressSummary: input.progressSummary ?? previous?.progressSummary ?? '',
-        lastError: input.lastError === undefined ? previous?.lastError ?? null : input.lastError,
-        completed: input.completed ?? previous?.completed ?? [],
-        pendingTasks: input.pendingTasks ?? previous?.pendingTasks ?? [],
-        decisions: input.decisions ?? previous?.decisions ?? [],
-        risks: input.risks ?? previous?.risks ?? [],
-        relatedFiles,
-    };
+    const progressSummary = input.progressSummary === undefined ? previous?.progressSummary ?? '' : normalizeText(input.progressSummary);
+    const lastError = input.lastError === undefined
+        ? previous?.lastError ?? null
+        : normalizeText(input.lastError ?? '') || null;
+    const completed = input.completed === undefined ? previous?.completed ?? [] : normalizeList(input.completed);
+    const pendingTasks = input.pendingTasks === undefined ? previous?.pendingTasks ?? [] : normalizeList(input.pendingTasks);
+    const decisions = input.decisions === undefined ? previous?.decisions ?? [] : normalizeList(input.decisions);
+    const risks = input.risks === undefined ? previous?.risks ?? [] : normalizeList(input.risks);
+    const relatedFilesInput = input.relatedFiles === undefined ? previous?.relatedFiles ?? [] : normalizeList(input.relatedFiles);
+    const relatedFiles = await filterPaths(projectRoot, relatedFilesInput);
+    return { progressSummary, lastError, completed, pendingTasks, decisions, risks, relatedFiles };
 }
 function isStructuredContext(value) {
     return isRecord(value)
@@ -126,7 +151,7 @@ async function loadSnapshot(projectRoot, contextId, snapshotId) {
     }
     return snapshot;
 }
-async function rebuildSnapshot(projectRoot, contextId, snapshotId, seen = new Set()) {
+export async function rebuildSnapshot(projectRoot, contextId, snapshotId, seen = new Set()) {
     if (seen.has(snapshotId))
         throw new Error(`snapshot cycle detected at ${snapshotId}`);
     seen.add(snapshotId);
@@ -139,7 +164,7 @@ async function rebuildSnapshot(projectRoot, contextId, snapshotId, seen = new Se
         content = snapshot.content;
     }
     else {
-        if (!snapshot.parentSnapshotId || !snapshot.patch || !isRecord(snapshot.patch))
+        if (!snapshot.parentSnapshotId || !snapshot.patch || !isContextPatch(snapshot.patch))
             throw new Error(`incomplete patch snapshot ${snapshotId}`);
         const parentSnapshot = await loadSnapshot(projectRoot, contextId, snapshot.parentSnapshotId);
         if (parentSnapshot.baseSnapshotId !== snapshot.baseSnapshotId)
@@ -151,7 +176,7 @@ async function rebuildSnapshot(projectRoot, contextId, snapshotId, seen = new Se
     }
     return content;
 }
-export async function rebuildIndex(projectRoot) {
+export async function rebuildIndex(projectRoot, persist = true) {
     const contexts = [];
     let entries = [];
     try {
@@ -178,7 +203,8 @@ export async function rebuildIndex(projectRoot) {
         }
     }
     const index = { schemaVersion: 1, rebuiltAt: new Date().toISOString(), contexts };
-    await atomicWriteJson(indexPath(projectRoot), index);
+    if (persist)
+        await atomicWriteJson(indexPath(projectRoot), index);
     return index;
 }
 async function updateIndex(projectRoot, entry) {
@@ -279,14 +305,16 @@ export async function checkpoint(startPath, input, options = {}) {
             currentSnapshotId: snapshotId,
             updatedAt: now,
         });
+        if (input.absorbNotes)
+            await absorbNotes(projectRoot, contextId, snapshotId);
         return { status: 'saved', context: updatedContext, snapshot };
     });
 }
-export async function resume(startPath, contextId, maxChars = 4000) {
+export async function resume(startPath, contextId, maxChars = 4000, options = {}) {
     const projectRoot = await resolveProjectRoot(startPath);
     await loadManifest(projectRoot);
     const git = await readGitState(projectRoot);
-    const index = await rebuildIndex(projectRoot);
+    const index = await rebuildIndex(projectRoot, options.touchLastUsedAt !== false);
     const candidates = index.contexts
         .filter((entry) => !contextId || entry.contextId === contextId)
         .filter((entry) => ['active', 'stable'].includes(entry.status))
@@ -300,8 +328,10 @@ export async function resume(startPath, contextId, maxChars = 4000) {
     const snapshot = await loadSnapshot(projectRoot, candidate.contextId, context.currentSnapshotId);
     const content = await rebuildSnapshot(projectRoot, candidate.contextId, snapshot.snapshotId);
     const drift = context.branch !== git.branch || context.commit !== git.commit;
-    context.lastUsedAt = new Date().toISOString();
-    await atomicWriteJson(contextMetadataPath(projectRoot, context.id), context);
+    if (options.touchLastUsedAt !== false) {
+        context.lastUsedAt = new Date().toISOString();
+        await atomicWriteJson(contextMetadataPath(projectRoot, context.id), context);
+    }
     const budget = { remaining: Math.max(0, maxChars) };
     const resumeSummary = {
         progressSummary: limited(content.progressSummary, budget.remaining),

package/dist/src/runtime/types.d.ts

@@ -0,0 +1,294 @@
+export type ContextStatus = 'draft' | 'active' | 'stable' | 'archived' | 'deleted';
+export type SnapshotMode = 'baseline' | 'patch';
+export interface GitState {
+    root: string | null;
+    branch: string | null;
+    commit: string | null;
+}
+export interface ContextMetadata {
+    id: string;
+    schemaVersion: 1;
+    title: string;
+    projectRoot: string;
+    branch: string | null;
+    commit: string | null;
+    createdAt: string;
+    updatedAt: string;
+    lastUsedAt: string | null;
+    usageCount: number;
+    status: ContextStatus;
+    currentSnapshotId: string | null;
+    tags: string[];
+    dependencies: string[];
+}
+export interface StructuredContext {
+    progressSummary: string;
+    lastError: string | null;
+    completed: string[];
+    pendingTasks: string[];
+    decisions: string[];
+    risks: string[];
+    relatedFiles: string[];
+}
+export type ContextPatch = Partial<StructuredContext>;
+export interface Snapshot {
+    snapshotId: string;
+    schemaVersion: 1;
+    contextId: string;
+    parentSnapshotId: string | null;
+    baseSnapshotId: string;
+    mode: SnapshotMode;
+    createdAt: string;
+    branch: string | null;
+    commit: string | null;
+    contentHash: string;
+    rebuildHash: string;
+    content?: StructuredContext;
+    patch?: ContextPatch;
+}
+export interface Manifest {
+    schemaVersion: 1;
+    layoutVersion: 'compact-json-v1';
+    projectId: string;
+    projectRoot: string;
+    initializedAt: string;
+}
+export interface IndexEntry {
+    contextId: string;
+    title: string;
+    status: ContextStatus;
+    branch: string | null;
+    commit: string | null;
+    currentSnapshotId: string | null;
+    updatedAt: string;
+}
+export interface IndexFile {
+    schemaVersion: 1;
+    rebuiltAt: string;
+    contexts: IndexEntry[];
+}
+export interface CheckpointInput {
+    contextId?: string;
+    absorbNotes?: boolean;
+    title?: string;
+    progressSummary?: string;
+    lastError?: string | null;
+    completed?: string[];
+    pendingTasks?: string[];
+    decisions?: string[];
+    risks?: string[];
+    relatedFiles?: string[];
+}
+export type NoteKind = 'problem' | 'action' | 'observation' | 'decision';
+export type NoteStatus = 'open' | 'resolved';
+export type NoteActor = 'agent' | 'human';
+export interface Note {
+    noteId: string;
+    schemaVersion: 1;
+    kind: NoteKind;
+    message: string;
+    actor: NoteActor;
+    contextId: string | null;
+    snapshotId: string | null;
+    relatedFiles: string[];
+    status: NoteStatus;
+    absorbedBySnapshotId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface NoteInput {
+    kind?: NoteKind;
+    actor?: NoteActor;
+    contextId?: string;
+    snapshotId?: string;
+    relatedFiles?: string[];
+    status?: NoteStatus;
+}
+export interface NoteFile {
+    schemaVersion: 1;
+    items: Note[];
+}
+export interface NoteQuery {
+    contextId?: string;
+    openOnly?: boolean;
+    limit?: number;
+    maxChars?: number;
+}
+export interface ActivityItem {
+    type: 'note' | 'checkpoint';
+    occurredAt: string;
+    contextId: string;
+    snapshotId?: string;
+    noteId?: string;
+    kind?: NoteKind;
+    message?: string;
+    actor?: NoteActor;
+    status?: NoteStatus;
+    absorbedBySnapshotId?: string | null;
+    title?: string;
+}
+export interface ActivityQuery extends NoteQuery {
+    since?: string;
+}
+export interface ActivityResult {
+    projectRoot: string;
+    items: ActivityItem[];
+}
+export type KnowledgeStatus = 'candidate' | 'verified' | 'deprecated' | 'rejected';
+export type DeadendStatus = 'candidate' | 'verified' | 'obsolete' | 'rejected';
+export interface Knowledge {
+    knowledgeId: string;
+    kind: string;
+    statement: string;
+    scope: string;
+    confidence: number;
+    status: KnowledgeStatus;
+    sourceContextIds: string[];
+    sourceSnapshotIds: string[];
+    supportingEvidence: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface KnowledgeInput {
+    kind?: string;
+    scope?: string;
+    sourceContextId?: string;
+    sourceSnapshotId?: string;
+    evidence?: string[];
+}
+export interface KnowledgeDiscoverOptions {
+    scope?: string;
+    statuses?: KnowledgeStatus[];
+    limit?: number;
+    maxChars?: number;
+}
+export interface KnowledgeDiscoveryHit {
+    knowledge: Knowledge;
+    score: number;
+    matchedTerms: string[];
+    matchedFields: string[];
+    why: string[];
+}
+export interface KnowledgeConflictGroup {
+    scope: string;
+    knowledgeIds: string[];
+    statements: string[];
+}
+export interface KnowledgeDiscoveryResult {
+    query: string;
+    total: number;
+    truncated: boolean;
+    hits: KnowledgeDiscoveryHit[];
+    duplicateIds: string[][];
+    possibleConflicts: KnowledgeConflictGroup[];
+}
+export interface DeadendDiscoverOptions {
+    scope?: string;
+    statuses?: DeadendStatus[];
+    limit?: number;
+    maxChars?: number;
+}
+export interface DeadendDiscoveryHit {
+    deadend: Deadend;
+    score: number;
+    matchedTerms: string[];
+    matchedFields: string[];
+}
+export interface DeadendDiscoveryResult {
+    query: string;
+    total: number;
+    truncated: boolean;
+    hits: DeadendDiscoveryHit[];
+}
+export interface DeadendInput {
+    scope?: string;
+    sourceContextId?: string;
+    sourceSnapshotId?: string;
+    evidence?: string[];
+}
+export interface Deadend {
+    deadendId: string;
+    attempt: string;
+    reason: string;
+    observedEvidence: string[];
+    scope: string;
+    status: DeadendStatus;
+    sourceContextId: string | null;
+    sourceSnapshotId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface KnowledgeFile {
+    schemaVersion: 1;
+    items: Knowledge[];
+}
+export interface DeadendFile {
+    schemaVersion: 1;
+    items: Deadend[];
+}
+export interface ResumeSummary extends StructuredContext {
+    branchOrCommitDrift: boolean;
+}
+export interface ResumeResult {
+    context: ContextMetadata;
+    snapshot: Snapshot;
+    resumeSummary: ResumeSummary;
+    details: StructuredContext;
+}
+export interface AgentLoadOptions {
+    contextId?: string;
+    maxChars?: number;
+    includeDetails?: boolean;
+    query?: string;
+    scope?: string;
+}
+export interface AgentLoadResult {
+    projectRoot: string;
+    context: ContextMetadata;
+    snapshot: Snapshot;
+    resumeSummary: ResumeSummary;
+    details?: StructuredContext;
+    knowledge: KnowledgeDiscoveryResult | null;
+    verifiedDeadendIds: string[];
+}
+export interface AgentSaveResult {
+    projectRoot: string;
+    result: CheckpointResult;
+}
+export interface ContextSearchOptions {
+    contextId?: string;
+    scope?: string;
+    limit?: number;
+    maxChars?: number;
+}
+export interface ContextSearchHit {
+    context: ContextMetadata;
+    snapshotId: string;
+    score: number;
+    matchedTerms: string[];
+    matchedFields: string[];
+    summary: ResumeSummary;
+}
+export interface ContextSearchResult {
+    projectRoot: string;
+    query: string;
+    total: number;
+    truncated: boolean;
+    hits: ContextSearchHit[];
+    knowledge: KnowledgeDiscoveryResult;
+    verifiedDeadendIds: string[];
+}
+export type CheckpointResult = {
+    status: 'saved';
+    context: ContextMetadata;
+    snapshot: Snapshot;
+} | {
+    status: 'no_change';
+    context: ContextMetadata;
+    snapshot: Snapshot;
+} | {
+    status: 'rate_limited';
+    context: ContextMetadata;
+    snapshot: Snapshot;
+    retryAt: string;
+};

package/dist/src/storage/atomic-write.d.ts

@@ -0,0 +1 @@
+export declare function atomicWriteJson(filePath: string, value: unknown): Promise<void>;

package/dist/src/storage/json-store.d.ts

@@ -0,0 +1,6 @@
+export declare class JsonStoreError extends Error {
+    readonly filePath: string;
+    constructor(filePath: string, message: string);
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function readJson<T>(filePath: string, validate?: (value: unknown) => value is T): Promise<T>;

package/dist/src/storage/layout.d.ts

@@ -0,0 +1,13 @@
+export declare function contextRoot(projectRoot: string): string;
+export declare function manifestPath(projectRoot: string): string;
+export declare function indexPath(projectRoot: string): string;
+export declare function ignoredPath(projectRoot: string): string;
+export declare function contextsRoot(projectRoot: string): string;
+export declare function contextDirectory(projectRoot: string, contextId: string): string;
+export declare function contextMetadataPath(projectRoot: string, contextId: string): string;
+export declare function snapshotsDirectory(projectRoot: string, contextId: string): string;
+export declare function snapshotPath(projectRoot: string, contextId: string, snapshotId: string): string;
+export declare function locksDirectory(projectRoot: string): string;
+export declare function knowledgePath(projectRoot: string): string;
+export declare function deadendsPath(projectRoot: string): string;
+export declare function notesPath(projectRoot: string): string;

package/dist/src/storage/layout.js

@@ -35,3 +35,6 @@ export function knowledgePath(projectRoot) {
 export function deadendsPath(projectRoot) {
     return path.join(contextRoot(projectRoot), 'deadends.json');
 }
+export function notesPath(projectRoot) {
+    return path.join(contextRoot(projectRoot), 'notes.json');
+}

package/dist/src/storage/lock.d.ts

@@ -0,0 +1 @@
+export declare function withLock<T>(lockPath: string, operation: () => Promise<T>): Promise<T>;

package/dist/src/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "0.3.0";

package/dist/src/version.js

@@ -0,0 +1 @@
+export const VERSION = '0.3.0';