praxis-agent 0.30.0 → 0.32.0

package/dist/application/claude-project-purge.js

@@ -283,6 +283,13 @@ export async function planClaudeProjectPurge(options) {
                     },
                 ]
                 : []),
+            {
+                kind: 'memory',
+                name: dataPlane === 'native'
+                    ? join('state', 'project-memory')
+                    : join('praxis', 'project-memory'),
+                description: 'all private Project-memory operational state',
+            },
             {
                 kind: 'tasks',
                 name: 'tasks',
@@ -336,7 +343,6 @@ export async function planClaudeProjectPurge(options) {
     const targetPaths = [...new Set([requestedPath, targetPath])];
     const projectIdentity = await resolveClaudeProjectIdentity({
         cwd: targetPath,
-        homeDirectory: options.homeDirectory ?? homedir(),
     });
     const projectRootPaths = await discoverProjectRoots(configRoot, targetPaths, dataPlane);
     const sessionIdSet = new Set();
@@ -352,16 +358,23 @@ export async function planClaudeProjectPurge(options) {
         await addExistingPath(items, configRoot, removePathItem('debug', join(configRoot, 'debug', `${sessionId}.txt`), `debug log for session ${sessionId}`));
         await addExistingPath(items, configRoot, removePathItem('file-history', join(configRoot, 'file-history', sessionId), `file edit history for session ${sessionId}`));
     }
+    const projectKeys = new Set([
+        ...targetPaths.map(sanitizeClaudeProjectPath),
+        ...projectRootPaths.map((path) => basename(path)),
+        sanitizeClaudeProjectPath(projectIdentity),
+    ]);
     if (dataPlane === 'native') {
-        const projectKeys = new Set([
-            ...targetPaths.map(sanitizeClaudeProjectPath),
-            ...projectRootPaths.map((path) => basename(path)),
-        ]);
         for (const projectKey of projectKeys) {
             await addExistingPath(items, configRoot, removePathItem('memory', join(configRoot, 'memory', projectKey), `memory for project ${projectKey}`));
+            await addExistingPath(items, configRoot, removePathItem('memory', join(configRoot, 'state', 'project-memory', projectKey), `private Project-memory state for project ${projectKey}`));
             await addExistingPath(items, configRoot, removePathItem('scheduled', join(configRoot, 'scheduled', `${projectKey}.json`), `scheduled prompts for project ${projectKey}`));
         }
     }
+    else {
+        for (const projectKey of projectKeys) {
+            await addExistingPath(items, configRoot, removePathItem('memory', join(configRoot, 'praxis', 'project-memory', projectKey), `private Project-memory state for project ${projectKey}`));
+        }
+    }
     for (const projectRoot of projectRootPaths) {
         await addExistingPath(items, configRoot, removePathItem('project', projectRoot, dataPlane === 'native'
             ? 'project transcripts'

package/dist/application/project-memory.d.ts

@@ -0,0 +1,141 @@
+import { type ModelProvider } from '../core/runtime.js';
+export type ProjectMemoryTopicType = 'user' | 'feedback' | 'project' | 'reference';
+export interface ProjectMemoryTopic {
+    path: string;
+    name: string;
+    description: string | null;
+    type: ProjectMemoryTopicType | null;
+    rawType?: string;
+    typeStatus: 'known' | 'missing' | 'unknown';
+    content: string;
+}
+export interface ProjectMemoryCandidate extends Omit<ProjectMemoryTopic, 'content'> {
+    modifiedAtMs: number;
+}
+export interface ProjectMemoryRecallPayload {
+    content: string;
+    attachmentCount: number;
+}
+export interface ProjectMemoryIndex {
+    path: string;
+    scope: 'project';
+    content: string;
+}
+export interface ProjectMemorySelector {
+    select(input: {
+        prompt: string;
+        candidates: readonly ProjectMemoryCandidate[];
+        signal?: AbortSignal;
+    }): Promise<readonly string[]>;
+}
+export interface ProjectMemoryMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+}
+export interface ProjectMemoryExtractorInput {
+    directory: string;
+    sessionId: string;
+    messages: readonly ProjectMemoryMessage[];
+    constraints: {
+        persistTranscript: false;
+        allowSubagents: false;
+        allowRemote: false;
+        maxModelTurns: 4;
+        tools: readonly ['Read', 'Write', 'Edit'];
+    };
+    signal: AbortSignal;
+}
+export interface ProjectMemoryExtractor {
+    extract(input: ProjectMemoryExtractorInput): Promise<void>;
+}
+export declare function loadProjectMemoryIndex(directory: string): Promise<ProjectMemoryIndex | null>;
+export declare function parseProjectMemoryTopic(path: string, source: string): ProjectMemoryTopic;
+export declare function listProjectMemoryCandidates(directory: string): Promise<ProjectMemoryCandidate[]>;
+export interface ProjectMemoryRecallHandle {
+    consumeIfSettled(): ProjectMemoryRecallPayload | null;
+}
+export interface ProjectMemoryRecallRuntime {
+    prefetch(input: {
+        sessionId: string;
+        turnId: string;
+        prompt: string;
+        signal?: AbortSignal;
+    }): ProjectMemoryRecallHandle;
+    recordRead(sessionId: string, path: string): void;
+    recordCompact(sessionId: string): void;
+    clearSession?(sessionId: string): void;
+}
+export interface ProjectMemoryExtractionRuntime {
+    observe(observation: ProjectMemoryObservation): void;
+    close(timeoutMs?: number): Promise<void>;
+}
+export declare class ProjectMemoryRecallController {
+    private readonly options;
+    private readonly sessions;
+    private readonly turns;
+    constructor(options: {
+        directory: string;
+        selector: ProjectMemorySelector;
+    });
+    prefetch(input: {
+        sessionId: string;
+        turnId: string;
+        prompt: string;
+        signal?: AbortSignal;
+    }): ProjectMemoryRecallHandle;
+    recordRead(sessionId: string, path: string): void;
+    recordCompact(sessionId: string): void;
+    clearSession(sessionId: string): void;
+    private session;
+    private select;
+    private consume;
+}
+export interface ProjectMemoryObservation {
+    sessionId: string;
+    messages: readonly ProjectMemoryMessage[];
+    directMaintenance?: boolean;
+}
+export declare class ProjectMemoryExtractionController {
+    private readonly options;
+    private trailing;
+    private pump;
+    private cursorLoaded;
+    private cursor;
+    private controller;
+    constructor(options: {
+        directory: string;
+        cursorPath: string;
+        extractor: ProjectMemoryExtractor;
+        onWarning?: (message: string) => void;
+    });
+    observe(observation: ProjectMemoryObservation): void;
+    drain(timeoutMs?: number): Promise<void>;
+    close(timeoutMs?: number): Promise<void>;
+    private run;
+    private ensurePump;
+    private process;
+    private loadCursor;
+    private saveCursor;
+    private warn;
+}
+export declare class ProjectMemoryModelSelector implements ProjectMemorySelector {
+    private readonly options;
+    constructor(options: {
+        directory: string;
+        providerFactory: () => ModelProvider;
+    });
+    select(input: {
+        prompt: string;
+        candidates: readonly ProjectMemoryCandidate[];
+        signal?: AbortSignal;
+    }): Promise<readonly string[]>;
+}
+export declare class ProjectMemoryAgentExtractor implements ProjectMemoryExtractor {
+    private readonly options;
+    constructor(options: {
+        providerFactory: () => ModelProvider;
+    });
+    extract(input: ProjectMemoryExtractorInput): Promise<void>;
+}
+//# sourceMappingURL=project-memory.d.ts.map