squish-memory 1.0.2 → 1.2.0

package/dist/core/places/walking.js

@@ -0,0 +1,121 @@
+/**
+ * Walking Interface - Sequential memory retrieval through places
+ *
+ * Implements place walking through memory places:
+ * - Walk single place to get memories in order
+ * - Walk all places for full tour
+ * - Token budget handling with TOON compression
+ */
+import { getProjectPlaces } from './places.js';
+import { getPlaceMemories } from './memory-places.js';
+import { getMemory } from '../memory/memories.js';
+import { compressForContext } from '../compression.js';
+import { logger } from '../logger.js';
+/**
+ * Walk through a single place
+ */
+export async function walkPlace(projectId, placeType, options = {}) {
+    const { tokenBudget = 170, maxMemoriesPerPlace = 10, includePurpose = true, compressWithCompression = false } = options;
+    // Get the place
+    const places = await getProjectPlaces(projectId);
+    const place = places.find(p => p.placeType === placeType);
+    if (!place) {
+        logger.warn(`[Walking] Place not found: ${placeType}`);
+        return null;
+    }
+    // Get memory IDs for this place
+    const memoryIds = await getPlaceMemories(place.id, maxMemoriesPerPlace);
+    // Get full memories
+    const memories = [];
+    let totalTokens = 0;
+    for (const memoryId of memoryIds) {
+        const memory = await getMemory(memoryId);
+        if (!memory)
+            continue;
+        let content = memory.content || '';
+        // Compress with TOON if requested
+        if (compressWithCompression && content) {
+            content = compressForContext(content);
+        }
+        const tokenEstimate = Math.ceil(content.length / 4); // rough token estimate
+        if (totalTokens + tokenEstimate > tokenBudget) {
+            // Would exceed budget - stop adding
+            break;
+        }
+        memories.push({
+            id: memory.id,
+            content,
+            type: memory.type,
+            tags: memory.tags || [],
+            createdAt: memory.createdAt || '',
+        });
+        totalTokens += tokenEstimate;
+    }
+    return {
+        place,
+        memories,
+        totalTokens,
+        truncated: memories.length < memoryIds.length,
+    };
+}
+/**
+  * Walk through all places in sort order
+ */
+export async function walkAllPlaces(projectId, options = {}) {
+    const places = await getProjectPlaces(projectId);
+    const results = [];
+    for (const place of places) {
+        const walkResult = await walkPlace(projectId, place.placeType, options);
+        if (walkResult && walkResult.memories.length > 0) {
+            results.push(walkResult);
+        }
+    }
+    logger.info(`[Walking] Walked ${results.length} places for project ${projectId}`);
+    return results;
+}
+/**
+ * Quick tour - just place names and purposes (minimal tokens)
+ */
+export async function quickTour(projectId) {
+    const places = await getProjectPlaces(projectId);
+    return {
+        places: places.map(p => ({
+            name: p.name,
+            purpose: p.purpose || '',
+            memoryCount: p.memoryCount,
+        })),
+        totalMemories: places.reduce((sum, p) => sum + p.memoryCount, 0),
+    };
+}
+/**
+ * Get context summary for a place (for injection)
+ */
+export async function getPlaceContext(projectId, placeType, maxTokens = 50) {
+    const walkResult = await walkPlace(projectId, placeType, {
+        tokenBudget: maxTokens,
+        compressWithCompression: true,
+    });
+    if (!walkResult || walkResult.memories.length === 0) {
+        return '';
+    }
+    const lines = walkResult.memories.map((m, i) => `${i + 1}. [${m.type}] ${m.content.substring(0, 100)}`);
+    return `## ${walkResult.place.name}\n${lines.join('\n')}`;
+}
+/**
+ * Full context for session start (all places)
+ */
+export async function getFullWalkingContext(projectId, maxTokens = 170) {
+    const results = await walkAllPlaces(projectId, {
+        tokenBudget: Math.floor(maxTokens / 7), // Distribute across 7 places
+        compressWithCompression: true,
+    });
+    if (results.length === 0) {
+        return 'No memories yet. Start building your spatial memory!';
+    }
+    const sections = results.map(r => {
+        const lines = r.memories.slice(0, 3).map((m, i) => `  ${i + 1}. ${m.content.substring(0, 60)}...`).join('\n');
+        return `## ${r.place.name}\n${lines}`;
+    });
+    return sections.join('\n\n');
+}
+//# sourceMappingURL=walking.js.map

package/dist/core/projects.d.ts

@@ -7,6 +7,11 @@ export interface ProjectRecord {
 }
 export declare function getProjectByPath(path: string): Promise<ProjectRecord | null>;
 export declare function ensureProject(path?: string): Promise<ProjectRecord | null>;
+export declare class ProjectNotFoundError extends Error {
+    constructor(path: string);
+}
+export declare function requireProject(path: string): Promise<ProjectRecord>;
+export declare function getOrCreateProject(path?: string): Promise<ProjectRecord | null>;
 export declare function getAllProjects(): Promise<ProjectRecord[]>;
 export declare function getProjectById(id: string): Promise<ProjectRecord | null>;
 //# sourceMappingURL=projects.d.ts.map

package/dist/core/projects.js

@@ -3,9 +3,8 @@ import { randomUUID } from 'crypto';
 import { eq } from 'drizzle-orm';
 import { getDb } from '../db/index.js';
 import { getSchema } from '../db/schema.js';
-import { fromSqliteJson, toSqliteJson } from './memory/serialization.js';
-import { config } from '../config.js';
-import { createDatabaseClient } from './database.js';
+import { serializeMetadata, deserializeMetadata } from './memory/serialization.js';
+import { createDatabaseClient } from './storage/database.js';
 export async function getProjectByPath(path) {
     try {
         const db = createDatabaseClient(await getDb());
@@ -31,26 +30,48 @@ export async function ensureProject(path) {
     const id = randomUUID();
     const name = basename(path) || path;
     const metadata = { source: 'mcp' };
-    if (config.isTeamMode) {
-        await db.insert(schema.projects).values({
-            id,
-            name,
-            path,
-            metadata,
-        });
+    await db.insert(schema.projects).values({
+        id,
+        name,
+        path,
+        metadata: serializeMetadata(metadata),
+    });
+    return { id, name, path, metadata };
+}
+export class ProjectNotFoundError extends Error {
+    constructor(path) {
+        super(`Project not found: ${path}`);
+        this.name = 'ProjectNotFoundError';
     }
-    else {
-        await db.insert(schema.projects).values({
-            id,
-            name,
-            path,
-            metadata: toSqliteJson(metadata),
-        });
+}
+export async function requireProject(path) {
+    const project = await getProjectByPath(path);
+    if (!project) {
+        throw new ProjectNotFoundError(path);
     }
+    return project;
+}
+export async function getOrCreateProject(path) {
+    if (!path)
+        return null;
+    const existing = await getProjectByPath(path);
+    if (existing)
+        return existing;
+    const db = createDatabaseClient(await getDb());
+    const schema = await getSchema();
+    const id = randomUUID();
+    const name = basename(path) || path;
+    const metadata = { source: 'mcp' };
+    await db.insert(schema.projects).values({
+        id,
+        name,
+        path,
+        metadata: serializeMetadata(metadata),
+    });
     return { id, name, path, metadata };
 }
 function normalizeProject(row) {
-    const metadata = config.isTeamMode ? row.metadata : fromSqliteJson(row.metadata);
+    const metadata = deserializeMetadata(row.metadata ?? null);
     return {
         id: row.id,
         name: row.name,
@@ -64,6 +85,14 @@ export async function getAllProjects() {
         const db = createDatabaseClient(await getDb());
         const schema = await getSchema();
         const rows = await db.select().from(schema.projects);
+        // Auto-create default project if none exist
+        if (rows.length === 0) {
+            const cwd = process.cwd();
+            const defaultProject = await getOrCreateProject(cwd);
+            if (defaultProject) {
+                return [defaultProject];
+            }
+        }
         return rows.map(normalizeProject);
     }
     catch (error) {

package/dist/core/responses.d.ts

@@ -0,0 +1,96 @@
+/**
+ * ResponseFormatter - Unified response formatting for all Squish output contexts
+ * @module core/responses
+ */
+export type ResponseStatus = 'ok' | 'error';
+export interface BaseResponse<T = unknown> {
+    status: ResponseStatus;
+    message?: string;
+    data?: T;
+    error?: string;
+    timestamp?: string;
+}
+export interface PaginatedResponse<T> extends BaseResponse<T[]> {
+    count: number;
+    total?: number;
+    page?: number;
+    limit?: number;
+}
+/**
+ * Format options for web responses
+ */
+export interface WebFormatOptions {
+    statusCode?: number;
+    pagination?: {
+        total: number;
+        page: number;
+        limit: number;
+    };
+}
+/**
+ * Unified response formatter for all Squish output contexts
+ */
+export declare class ResponseFormatter {
+    /**
+     * Generate ISO timestamp
+     */
+    private static getTimestamp;
+    /**
+     * Build base response with timestamp
+     */
+    private static buildBase;
+    /**
+     * Format response for CLI output (pretty-printed JSON)
+     */
+    static cli<T>(data: T, message?: string): string;
+    /**
+     * Format error for CLI and exit process
+     */
+    static cliError(error: Error): never;
+    /**
+     * Format successful response for Web API
+     */
+    static web<T>(data: T, message?: string, options?: WebFormatOptions): {
+        status: number;
+        body: BaseResponse<T>;
+    };
+    /**
+     * Format error response for Web API
+     */
+    static webError(error: Error, options?: {
+        statusCode?: number;
+        log?: boolean;
+    }): {
+        status: number;
+        body: BaseResponse;
+    };
+    /**
+     * Format response for MCP tools
+     */
+    static mcp<T>(data: T, message?: string): {
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    };
+    /**
+     * Format error for MCP tools (throws McpError)
+     */
+    static mcpError(error: Error, context?: string): never;
+    /**
+     * Format response for algorithm handlers
+     */
+    static algorithm<T>(data: T, message: string, options?: {
+        ok?: boolean;
+        error?: string;
+    }): BaseResponse<T>;
+    /**
+     * Convenience method for success responses
+     */
+    static success<T>(data: T, message?: string): BaseResponse<T>;
+    /**
+     * Convenience method for failure responses
+     */
+    static failure(message: string, error?: Error | string): BaseResponse;
+}
+//# sourceMappingURL=responses.d.ts.map

package/dist/core/responses.js

@@ -0,0 +1,122 @@
+/**
+ * ResponseFormatter - Unified response formatting for all Squish output contexts
+ * @module core/responses
+ */
+/**
+ * Unified response formatter for all Squish output contexts
+ */
+export class ResponseFormatter {
+    /**
+     * Generate ISO timestamp
+     */
+    static getTimestamp() {
+        return new Date().toISOString();
+    }
+    /**
+     * Build base response with timestamp
+     */
+    static buildBase(status, message, data, error) {
+        return {
+            status,
+            message,
+            data,
+            error,
+            timestamp: this.getTimestamp(),
+        };
+    }
+    // CLI Formatters
+    /**
+     * Format response for CLI output (pretty-printed JSON)
+     */
+    static cli(data, message) {
+        const response = this.buildBase(data instanceof Error ? 'error' : 'ok', message, data);
+        return JSON.stringify(response, null, 2);
+    }
+    /**
+     * Format error for CLI and exit process
+     */
+    static cliError(error) {
+        const response = this.buildBase('error', error.message, undefined, error.message);
+        console.error(JSON.stringify(response, null, 2));
+        process.exit(1);
+    }
+    // Web API Formatters
+    /**
+     * Format successful response for Web API
+     */
+    static web(data, message, options) {
+        const body = this.buildBase('ok', message, data);
+        // Add pagination metadata if provided
+        if (options?.pagination) {
+            body.count = options.pagination.total;
+            body.total = options.pagination.total;
+            body.page = options.pagination.page;
+            body.limit = options.pagination.limit;
+        }
+        return {
+            status: options?.statusCode ?? 200,
+            body,
+        };
+    }
+    /**
+     * Format error response for Web API
+     */
+    static webError(error, options) {
+        const statusCode = options?.statusCode ?? 500;
+        const body = this.buildBase('error', error.message, undefined, error.message);
+        if (options?.log !== false) {
+            console.error(`[Web API Error ${statusCode}]:`, error.message);
+        }
+        return { status: statusCode, body };
+    }
+    // MCP Formatters
+    /**
+     * Format response for MCP tools
+     */
+    static mcp(data, message) {
+        const response = this.buildBase('ok', message, data);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+        };
+    }
+    /**
+     * Format error for MCP tools (throws McpError)
+     */
+    static mcpError(error, context) {
+        const message = context ? `${context}: ${error.message}` : error.message;
+        const response = this.buildBase('error', message, undefined, message);
+        // Import McpError dynamically to avoid requiring @modelcontextprotocol/sdk in non-MCP contexts
+        try {
+            const { McpError, ErrorCode } = require('@modelcontextprotocol/sdk/types.js');
+            throw new McpError(ErrorCode.InternalError, JSON.stringify(response));
+        }
+        catch (e) {
+            // If McpError is not available, throw a standard error with MCP-formatted message
+            const mcpError = new Error(JSON.stringify(response));
+            mcpError.name = 'McpError';
+            throw mcpError;
+        }
+    }
+    // Algorithm Handler Formatters
+    /**
+     * Format response for algorithm handlers
+     */
+    static algorithm(data, message, options) {
+        const isOk = options?.ok !== false;
+        return this.buildBase(isOk ? 'ok' : 'error', message, isOk ? data : undefined, options?.error);
+    }
+    /**
+     * Convenience method for success responses
+     */
+    static success(data, message) {
+        return this.buildBase('ok', message, data);
+    }
+    /**
+     * Convenience method for failure responses
+     */
+    static failure(message, error) {
+        const errorMessage = error instanceof Error ? error.message : error;
+        return this.buildBase('error', message, undefined, errorMessage);
+    }
+}
+//# sourceMappingURL=responses.js.map

package/dist/core/runtime/trust-report.d.ts

@@ -0,0 +1,102 @@
+export interface CurrentProjectSummary {
+    id: string;
+    name: string;
+    path: string;
+    resolution: 'explicit' | 'inferred' | 'auto-created' | 'legacy-placeholder';
+}
+export interface ContextReportInput {
+    currentProject: CurrentProjectSummary;
+    otherProjects: CurrentProjectSummary[];
+    runtime: {
+        sessionSummary: string;
+        activePlaces: string[];
+        signalSummary: {
+            captured: number;
+            suppressed: number;
+            sessionOnly: number;
+            durable: number;
+            durableWithRaw: number;
+        };
+        graphSummary: string;
+    };
+    durableMemories: Array<{
+        id: string;
+        type: string;
+        content: string;
+        place?: string | null;
+    }>;
+    beliefs?: Array<{
+        type: string;
+        statement: string;
+        status: string;
+    }>;
+    nextStep: string | null;
+}
+export interface HealthReportInput {
+    severity: 'ok' | 'degraded' | 'broken';
+    currentProject: string;
+    checks: Array<{
+        name: string;
+        status: 'ok' | 'degraded' | 'broken';
+        detail: string;
+    }>;
+    diagnostics?: Array<{
+        name: string;
+        status: 'ok' | 'degraded' | 'broken';
+        detail: string;
+        fix?: string;
+    }>;
+    nextStep: string | null;
+}
+export interface StatsReportInput {
+    currentProject: string;
+    totals: {
+        memories: number;
+        durable: number;
+        sessionLocal: number;
+    };
+    signal: {
+        captured: number;
+        suppressed: number;
+        sessionOnly: number;
+        durable: number;
+        durableWithRaw: number;
+        tokensSaved: number;
+        placeRouted: number;
+        graphEnriched: number;
+    };
+    places: {
+        active: number;
+        named: string[];
+    };
+    graph: {
+        status: string;
+        enrichments: number;
+    };
+    wakeUp: string;
+    signalNote?: string | null;
+}
+export interface InspectReportInput {
+    id: string;
+    classification: string;
+    storageReason: string;
+    durability: 'session-only' | 'durable';
+    place?: string | null;
+    placeType?: string | null;
+    graphStatus?: string | null;
+    rawFallback?: string | null;
+    wakeUpPriority?: string | null;
+    metadataAvailability?: string | null;
+    beliefs?: Array<{
+        id: string;
+        type: string;
+        statement: string;
+        status: string;
+        confidence: number;
+    }>;
+}
+export declare function formatContextReport(input: ContextReportInput): string;
+export declare function formatHealthReport(input: HealthReportInput): string;
+export declare function formatStatsReport(input: StatsReportInput): string;
+export declare function formatInspectReport(input: InspectReportInput): string;
+//# sourceMappingURL=trust-report.d.ts.map

package/dist/core/runtime/trust-report.js

@@ -0,0 +1,107 @@
+export function formatContextReport(input) {
+    const lines = [
+        'Current project',
+        `- ${input.currentProject.name} (${input.currentProject.path})`,
+        `- resolution: ${input.currentProject.resolution}`,
+        '',
+        'Runtime state',
+        `- session working set: ${input.runtime.sessionSummary || 'none'}`,
+        `- active places: ${input.runtime.activePlaces.join(', ') || 'none'}`,
+        `- signals: captured ${input.runtime.signalSummary.captured}, suppressed ${input.runtime.signalSummary.suppressed}, session-only ${input.runtime.signalSummary.sessionOnly}, durable ${input.runtime.signalSummary.durable}, durable+raw ${input.runtime.signalSummary.durableWithRaw}`,
+        `- graph: ${input.runtime.graphSummary}`,
+        '',
+        'Recent durable memories',
+    ];
+    if (input.durableMemories.length === 0) {
+        lines.push('- none yet');
+    }
+    else {
+        for (const memory of input.durableMemories) {
+            lines.push(`- [${memory.type}] ${memory.content}${memory.place ? ` @ ${memory.place}` : ''}`);
+        }
+    }
+    if (input.otherProjects.length > 0) {
+        lines.push('', 'Other projects');
+        for (const project of input.otherProjects) {
+            lines.push(`- ${project.name} (${project.path}) [${project.resolution}]`);
+        }
+    }
+    if (input.beliefs && input.beliefs.length > 0) {
+        lines.push('', 'Derived beliefs');
+        for (const belief of input.beliefs) {
+            lines.push(`- [${belief.type}] ${belief.statement} (${belief.status})`);
+        }
+    }
+    if (input.nextStep) {
+        lines.push('', `Next step: ${input.nextStep}`);
+    }
+    return lines.join('\n');
+}
+export function formatHealthReport(input) {
+    const lines = [
+        `Status: ${input.severity}`,
+        `Current project: ${input.currentProject}`,
+        '',
+        'Subsystems',
+        ...input.checks.map((check) => `- ${check.name}: ${check.status} (${check.detail})`),
+    ];
+    if (input.diagnostics && input.diagnostics.length > 0) {
+        lines.push('', 'Diagnostics');
+        for (const diagnostic of input.diagnostics) {
+            lines.push(`- ${diagnostic.name}: ${diagnostic.status} (${diagnostic.detail})`);
+            if (diagnostic.fix) {
+                lines.push(`  fix: ${diagnostic.fix}`);
+            }
+        }
+    }
+    if (input.nextStep)
+        lines.push('', `Next step: ${input.nextStep}`);
+    return lines.join('\n');
+}
+export function formatStatsReport(input) {
+    const lines = [
+        `Current project: ${input.currentProject}`,
+        `Memory totals: ${input.totals.memories} total, ${input.totals.durable} durable, ${input.totals.sessionLocal} session-local`,
+        '',
+        'Capture-era signals',
+        `- captured: ${input.signal.captured}`,
+        `- suppressed: ${input.signal.suppressed}`,
+        `- session-only: ${input.signal.sessionOnly}`,
+        `- signal-tracked durable: ${input.signal.durable}`,
+        `- signal-tracked durable+raw: ${input.signal.durableWithRaw}`,
+        `- token savings: ${input.signal.tokensSaved}`,
+        `- place routed: ${input.signal.placeRouted}`,
+        `- graph enriched: ${input.signal.graphEnriched}`,
+        '',
+        `Places: ${input.places.active} active (${input.places.named.join(', ') || 'none'})`,
+        `Graph: ${input.graph.status}; ${input.graph.enrichments} enrichments`,
+        `Wake-up: ${input.wakeUp}`,
+    ];
+    if (input.signalNote) {
+        lines.push(`Signal note: ${input.signalNote}`);
+    }
+    return lines.join('\n');
+}
+export function formatInspectReport(input) {
+    const lines = [
+        `Memory ${input.id}`,
+        `Classification: ${input.classification}`,
+        `Storage reason: ${input.storageReason}`,
+        `Durability: ${input.durability}`,
+        `Place: ${input.place ?? 'none'}${input.placeType ? ` (${input.placeType})` : ''}`,
+        `Graph: ${input.graphStatus ?? 'none'}`,
+        `Raw fallback: ${input.rawFallback ?? 'none'}`,
+        `Wake-up priority: ${input.wakeUpPriority ?? 'n/a'}`,
+    ];
+    if (input.metadataAvailability) {
+        lines.push(`Metadata: ${input.metadataAvailability}`);
+    }
+    if (input.beliefs && input.beliefs.length > 0) {
+        lines.push('Beliefs:');
+        for (const belief of input.beliefs) {
+            lines.push(`- [${belief.type}] ${belief.statement} (${belief.status}, c=${belief.confidence.toFixed(2)})`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=trust-report.js.map

package/dist/core/runtime/trust-state.d.ts

@@ -0,0 +1,12 @@
+import type { ContextReportInput, CurrentProjectSummary, HealthReportInput, InspectReportInput, StatsReportInput } from './trust-report.js';
+export interface TrustProjectScope {
+    currentProject: CurrentProjectSummary;
+    otherProjects: CurrentProjectSummary[];
+    nextStep: string | null;
+}
+export declare function resolveProjectScope(projectPath?: string): Promise<TrustProjectScope>;
+export declare function buildContextState(projectPath?: string, limit?: number): Promise<ContextReportInput>;
+export declare function buildStatsState(projectPath?: string): Promise<StatsReportInput>;
+export declare function buildHealthState(projectPath?: string): Promise<HealthReportInput>;
+export declare function buildInspectState(id: string): Promise<InspectReportInput | null>;
+//# sourceMappingURL=trust-state.d.ts.map