squish-memory 1.0.2 → 1.2.0

package/dist/commands/managed-sync.js

@@ -1,64 +0,0 @@
-import { MCPClient } from '../core/mcp/client.js';
-import { config } from '../config.js';
-import { logger } from '../core/logger.js';
-import { searchMemories, rememberMemory } from '../core/memory/memories.js';
-export class ManagedSync {
-    client;
-    syncEnabled;
-    constructor() {
-        this.syncEnabled = config.managedMode && !!config.managedApiKey;
-        this.client = new MCPClient(config.managedApiUrl);
-    }
-    async sync() {
-        if (!this.syncEnabled) {
-            logger.debug('Managed sync disabled');
-            return;
-        }
-        try {
-            await this.client.initialize();
-            logger.info('Connected to managed storage');
-        }
-        catch (error) {
-            logger.error('Managed sync connection failed:', error);
-        }
-    }
-    async pushMemory(memoryId) {
-        if (!this.syncEnabled)
-            return;
-        try {
-            const memory = await searchMemories({ query: memoryId, limit: 1 });
-            if (memory.length > 0) {
-                await this.client.callTool('managed_memory_store', {
-                    memory: memory[0],
-                });
-                logger.debug(`Pushed memory ${memoryId} to managed storage`);
-            }
-        }
-        catch (error) {
-            logger.error(`Failed to push memory ${memoryId}:`, error);
-        }
-    }
-    async pullMemory(memoryId) {
-        if (!this.syncEnabled)
-            return;
-        try {
-            const result = await this.client.callTool('managed_memory_retrieve', {
-                memoryId,
-            });
-            if (result.content[0]?.text) {
-                const memory = JSON.parse(result.content[0].text);
-                await rememberMemory(memory);
-                logger.debug(`Pulled memory ${memoryId} from managed storage`);
-            }
-        }
-        catch (error) {
-            logger.error(`Failed to pull memory ${memoryId}:`, error);
-        }
-    }
-}
-export async function startManagedSync() {
-    const sync = new ManagedSync();
-    await sync.sync();
-    return sync;
-}
-//# sourceMappingURL=managed-sync.js.map

package/dist/commands/mcp-server.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=mcp-server.d.ts.map

package/dist/commands/mcp-server.js

@@ -1,393 +0,0 @@
-#!/usr/bin/env node
-// CRITICAL: Redirect console.log to stderr to prevent JSON-RPC stream corruption
-// MCP stdio requires stdout to contain ONLY valid JSON-RPC messages
-console.log = console.error;
-console.info = console.error;
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import express from "express";
-import { z } from "zod";
-import { config } from "../config.js";
-import { hybridSearch } from "../core/memory/hybrid-retrieval.js";
-import { rememberMemory, searchMemories, getMemoryById } from "../core/memory/memories.js";
-import { getEmbedding } from "../core/embeddings.js";
-import { getQMDClient } from "../core/embeddings/qmd-client.js";
-import { createAssociation, getRelatedMemories } from "../core/associations.js";
-import { createObservation, getObservationsForProject } from "../core/observations.js";
-import { getProjectByPath, getAllProjects } from "../core/projects.js";
-import { getMemoryStats } from "../core/memory/stats.js";
-import { getDb } from "../db/index.js";
-import { getSchema } from "../db/schema.js";
-import { eq } from "drizzle-orm";
-const SERVER_NAME = "squish-memory";
-const SERVER_VERSION = "1.0.2";
-function parseArgs() {
-    const args = process.argv.slice(2);
-    let mode = "stdio";
-    let port = config.mcpServerPort || 8767;
-    let health = false;
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === "--http" || args[i] === "-h") {
-            mode = "http";
-        }
-        else if (args[i] === "--stdio" || args[i] === "-s") {
-            mode = "stdio";
-        }
-        else if (args[i] === "--port" || args[i] === "-p") {
-            port = parseInt(args[i + 1], 10) || 8767;
-            i++;
-        }
-        else if (args[i] === "--health" || args[i] === "--check") {
-            health = true;
-        }
-    }
-    if (process.env.SQUISH_MCP_MODE === "http") {
-        mode = "http";
-    }
-    return { mode, port, health };
-}
-function safeRegisterTool(server, name, definition, handler) {
-    try {
-        server.registerTool(name, definition, handler);
-        console.error(`[MCP] Registered tool: ${name}`);
-        return true;
-    }
-    catch (error) {
-        console.error(`[MCP] Failed to register tool ${name}:`, error);
-        return false;
-    }
-}
-function createSquishServer() {
-    const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
-    let toolCount = 0;
-    console.error(`[MCP] Starting tool registration...`);
-    if (safeRegisterTool(server, "squish_search", {
-        description: "Hybrid search across QMD, SQLite DB, and embeddings with graph expansion",
-        inputSchema: {
-            query: z.string().describe("Search query"),
-            limit: z.number().min(1).max(100).default(5).describe("Maximum results"),
-            project: z.string().optional().describe("Project path filter"),
-            mode: z.enum(["hybrid", "qmd", "db", "semantic"]).default("hybrid").describe("Search mode")
-        }
-    }, async ({ query, limit = 5, project, mode = "hybrid" }) => {
-        const results = await hybridSearch({
-            query,
-            limit,
-            project,
-            candidateLimit: 50,
-            resultLimit: limit
-        });
-        const formatted = results.map((r, i) => `${i + 1}. [${r.type || "memory"}] ${r.content?.substring(0, 200)}... (score: ${r.hybridScore?.toFixed(2)})`).join("\n");
-        return { content: [{ type: "text", text: `Found ${results.length} memories:\n\n${formatted}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_remember", {
-        description: "Store a new memory in Squish with automatic embedding",
-        inputSchema: {
-            content: z.string().describe("Memory content to store"),
-            type: z.enum(["observation", "fact", "decision", "context", "preference"]).default("observation").describe("Memory type"),
-            tags: z.array(z.string()).optional().describe("Optional tags"),
-            project: z.string().optional().describe("Project path")
-        }
-    }, async ({ content, type = "observation", tags = [], project }) => {
-        const memory = await rememberMemory({ content, type: type, tags, project });
-        return { content: [{ type: "text", text: `Memory stored: ${memory.id}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_recall", {
-        description: "Retrieve a specific memory by ID",
-        inputSchema: {
-            memoryId: z.string().uuid().describe("Memory ID to retrieve")
-        }
-    }, async ({ memoryId }) => {
-        const memory = await getMemoryById(memoryId);
-        if (!memory) {
-            return { content: [{ type: "text", text: `Memory not found: ${memoryId}` }], isError: true };
-        }
-        return { content: [{ type: "text", text: JSON.stringify(memory, null, 2) }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_forget", {
-        description: "Delete a memory by ID",
-        inputSchema: {
-            memoryId: z.string().uuid().describe("Memory ID to delete")
-        }
-    }, async ({ memoryId }) => {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Cast to any to handle Drizzle ORM union type issue
-        const sqliteDb = db;
-        const result = await sqliteDb.delete(schema.memories).where(eq(schema.memories.id, memoryId));
-        return { content: [{ type: "text", text: `Memory deleted: ${memoryId}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_update", {
-        description: "Update an existing memory",
-        inputSchema: {
-            memoryId: z.string().uuid().describe("Memory ID to update"),
-            content: z.string().optional().describe("New content"),
-            tags: z.array(z.string()).optional().describe("New tags"),
-            type: z.enum(["observation", "fact", "decision", "context", "preference"]).optional().describe("New type")
-        }
-    }, async ({ memoryId, content, tags, type }) => {
-        const db = await getDb();
-        const schema = await getSchema();
-        const updates = {};
-        if (content)
-            updates.content = content;
-        if (tags)
-            updates.tags = config.isTeamMode ? tags : JSON.stringify(tags);
-        if (type)
-            updates.type = type;
-        if (Object.keys(updates).length === 0) {
-            return { content: [{ type: "text", text: "No updates provided" }], isError: true };
-        }
-        // Cast to any to handle Drizzle ORM union type issue
-        const sqliteDb2 = db;
-        await sqliteDb2.update(schema.memories).set(updates).where(eq(schema.memories.id, memoryId));
-        return { content: [{ type: "text", text: `Memory updated: ${memoryId}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_qmd_search", {
-        description: "Search markdown files using QMD (BM25 + vector)",
-        inputSchema: {
-            query: z.string().describe("Search query"),
-            collection: z.string().optional().describe("QMD collection name"),
-            limit: z.number().min(1).max(100).default(10).describe("Maximum results")
-        }
-    }, async ({ query, collection, limit = 10 }) => {
-        const client = await getQMDClient();
-        const available = await client.isAvailable();
-        if (!available) {
-            return { content: [{ type: "text", text: "QMD not available. Install with: bun install -g qmd" }], isError: true };
-        }
-        const results = await client.search({ query, collection, limit });
-        const formatted = results.map((r, i) => `${i + 1}. ${r.path || r.file} (score: ${r.score?.toFixed(2)})\n   ${r.content?.substring(0, 150)}...`).join("\n\n");
-        return { content: [{ type: "text", text: `QMD found ${results.length} results:\n\n${formatted}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_associate", {
-        description: "Create an association between two memories in the graph",
-        inputSchema: {
-            fromMemoryId: z.string().uuid().describe("Source memory ID"),
-            toMemoryId: z.string().uuid().describe("Target memory ID"),
-            type: z.enum(["relates_to", "supersedes", "contradicts", "supports", "duplicate", "merged"]).describe("Association type"),
-            weight: z.number().min(0).max(1).default(0.5).describe("Association strength (0-1)")
-        }
-    }, async ({ fromMemoryId, toMemoryId, type, weight = 0.5 }) => {
-        await createAssociation(fromMemoryId, toMemoryId, type, weight);
-        return { content: [{ type: "text", text: `Association created: ${fromMemoryId} -> ${toMemoryId} (${type})` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_related", {
-        description: "Get related memories via graph traversal",
-        inputSchema: {
-            memoryId: z.string().uuid().describe("Memory ID to find relations for"),
-            depth: z.number().min(1).max(5).default(2).describe("Graph traversal depth"),
-            minWeight: z.number().min(0).max(1).default(0.3).describe("Minimum association weight")
-        }
-    }, async ({ memoryId, depth = 2, minWeight = 0.3 }) => {
-        const related = await getRelatedMemories(memoryId, depth * 5);
-        const filtered = related.filter((r) => r.weight >= minWeight);
-        const formatted = filtered.map((r, i) => `${i + 1}. [${r.type || "memory"}] ${r.content?.substring(0, 100)}... (weight: ${r.weight?.toFixed(2)})`).join("\n");
-        return { content: [{ type: "text", text: `Found ${related.length} related memories:\n\n${formatted}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_context", {
-        description: "Get project context with relevant memories",
-        inputSchema: {
-            project: z.string().describe("Project path"),
-            limit: z.number().min(1).max(50).default(10).describe("Maximum memories to return")
-        }
-    }, async ({ project, limit = 10 }) => {
-        const projectRecord = await getProjectByPath(project);
-        if (!projectRecord) {
-            return { content: [{ type: "text", text: `Project not found: ${project}` }], isError: true };
-        }
-        const recentMemories = await searchMemories({ query: "", project, limit });
-        const observations = await getObservationsForProject(project, 5);
-        const context = {
-            project: projectRecord,
-            recentMemories: recentMemories.slice(0, limit),
-            recentObservations: observations
-        };
-        return { content: [{ type: "text", text: JSON.stringify(context, null, 2) }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_observe", {
-        description: "Store an observation about tool usage, patterns, or insights",
-        inputSchema: {
-            type: z.enum(["tool_use", "file_change", "error", "pattern", "insight"]).describe("Observation type"),
-            action: z.string().describe("Action performed"),
-            summary: z.string().describe("Summary of observation"),
-            target: z.string().optional().describe("Target file or resource"),
-            project: z.string().optional().describe("Project path")
-        }
-    }, async ({ type, action, summary, target, project }) => {
-        const observation = await createObservation({ type, action, summary, target, project });
-        return { content: [{ type: "text", text: `Observation stored: ${observation.id}` }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_embed", {
-        description: "Generate embeddings for text using configured provider",
-        inputSchema: {
-            text: z.string().describe("Text to embed")
-        }
-    }, async ({ text }) => {
-        const embedding = await getEmbedding(text);
-        if (!embedding) {
-            return { content: [{ type: "text", text: "Failed to generate embedding" }], isError: true };
-        }
-        return { content: [{ type: "text", text: JSON.stringify({ dimensions: embedding.length, preview: embedding.slice(0, 5) }, null, 2) }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_health", {
-        description: "Check Squish system health status",
-        inputSchema: {}
-    }, async () => {
-        const qmdClient = await getQMDClient();
-        const qmdAvailable = await qmdClient.isAvailable();
-        return { content: [{ type: "text", text: JSON.stringify({
-                        status: "ok",
-                        version: SERVER_VERSION,
-                        mode: config.isManagedMode ? "managed" : "local",
-                        embeddings: config.embeddingsProvider,
-                        qmd: qmdAvailable ? "available" : "unavailable",
-                        timestamp: new Date().toISOString()
-                    }, null, 2) }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_stats", {
-        description: "Get memory statistics for a project",
-        inputSchema: {
-            project: z.string().optional().describe("Project path (defaults to current)")
-        }
-    }, async ({ project }) => {
-        const stats = await getMemoryStats(project || process.cwd());
-        return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
-    }))
-        toolCount++;
-    if (safeRegisterTool(server, "squish_projects", {
-        description: "List all registered projects",
-        inputSchema: {}
-    }, async () => {
-        const projects = await getAllProjects();
-        const formatted = projects.map((p, i) => `${i + 1}. ${p.name}\n   Path: ${p.path}\n   ID: ${p.id}`).join("\n\n");
-        return { content: [{ type: "text", text: `Found ${projects.length} projects:\n\n${formatted}` }] };
-    }))
-        toolCount++;
-    console.error(`[MCP] Tool registration complete. Registered ${toolCount} tools.`);
-    return { server, toolCount };
-}
-async function runStdio(server, toolCount) {
-    console.error(`[MCP] Starting in STDIO mode...`);
-    const transport = new StdioServerTransport();
-    transport.onclose = () => {
-        console.error(`[MCP] STDIO transport closed`);
-    };
-    await server.connect(transport);
-    console.error(`[MCP] Connected via stdio. ${toolCount} tools available.`);
-    // Keep process alive - wait for stdin to close or process signals
-    await new Promise((resolve) => {
-        process.stdin.on('close', () => {
-            console.error(`[MCP] STDIO stdin closed, shutting down`);
-            resolve();
-        });
-        process.on('SIGINT', () => {
-            console.error(`[MCP] Received SIGINT, shutting down`);
-            resolve();
-        });
-        process.on('SIGTERM', () => {
-            console.error(`[MCP] Received SIGTERM, shutting down`);
-            resolve();
-        });
-    });
-}
-async function runHttp(server, port) {
-    console.error(`[MCP] Starting in HTTP mode on port ${port}...`);
-    const app = express();
-    app.use(express.json());
-    const transports = new Map();
-    app.get("/health", (req, res) => {
-        res.json({ status: "ok", server: SERVER_NAME, version: SERVER_VERSION });
-    });
-    app.get("/sse", async (req, res) => {
-        const transport = new SSEServerTransport("/message", res);
-        const sessionId = Math.random().toString(36).substring(7);
-        transports.set(sessionId, transport);
-        console.error(`[MCP] SSE connection established: ${sessionId}`);
-        await server.connect(transport);
-        req.on("close", () => {
-            console.error(`[MCP] SSE connection closed: ${sessionId}`);
-            transports.delete(sessionId);
-        });
-    });
-    app.post("/message", async (req, res) => {
-        const sessionId = req.headers["mcp-session-id"] || "default";
-        const transport = transports.get(sessionId);
-        if (!transport) {
-            res.status(400).json({ error: "No active session" });
-            return;
-        }
-        try {
-            await transport.handlePostMessage(req, res);
-        }
-        catch (error) {
-            console.error(`[MCP] Error handling message:`, error);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
-    await new Promise((resolve) => app.listen(port, () => {
-        console.error(`[MCP] HTTP server listening on port ${port}`);
-        console.error(`[MCP] SSE endpoint: http://localhost:${port}/sse`);
-        console.error(`[MCP] Health: http://localhost:${port}/health`);
-        resolve();
-    }));
-}
-async function runHealthCheck() {
-    console.error(`[MCP] Running health check...`);
-    try {
-        const { server, toolCount } = createSquishServer();
-        console.error(`[MCP] Health check passed. Server initialized with ${toolCount} tools.`);
-        process.exit(0);
-    }
-    catch (error) {
-        console.error(`[MCP] Health check failed:`, error);
-        process.exit(1);
-    }
-}
-async function main() {
-    try {
-        console.error(`[${SERVER_NAME}] v${SERVER_VERSION} initializing...`);
-        console.error(`[${SERVER_NAME}] Mode: ${config.isManagedMode ? "managed" : "local"}`);
-        console.error(`[${SERVER_NAME}] Embeddings: ${config.embeddingsProvider}`);
-        const { mode, port, health } = parseArgs();
-        if (health) {
-            await runHealthCheck();
-            return;
-        }
-        const { server, toolCount } = createSquishServer();
-        const shutdown = async () => {
-            console.error(`[${SERVER_NAME}] Shutting down...`);
-            process.exit(0);
-        };
-        process.on("SIGINT", shutdown);
-        process.on("SIGTERM", shutdown);
-        if (mode === "stdio") {
-            await runStdio(server, toolCount);
-        }
-        else {
-            await runHttp(server, port);
-        }
-    }
-    catch (error) {
-        console.error(`[${SERVER_NAME}] Fatal error:`, error);
-        process.exit(1);
-    }
-}
-main().catch((error) => {
-    console.error(`[${SERVER_NAME}] Fatal error:`, error);
-    process.exit(1);
-});
-//# sourceMappingURL=mcp-server.js.map

package/dist/core/context.js

@@ -1,24 +0,0 @@
-import { getProjectByPath } from './projects.js';
-import { getRecentMemories } from './memory/memories.js';
-import { getObservationsForProject } from './observations.js';
-import { getEntitiesForProject } from './search/entities.js';
-export async function getProjectContext(input) {
-    const project = await getProjectByPath(input.project);
-    const include = input.include ?? ['memories', 'observations'];
-    const limit = Math.min(Math.max(input.limit ?? 10, 1), 100);
-    if (!project) {
-        return { project: null, memories: [], observations: [] };
-    }
-    const result = { project };
-    if (include.includes('memories')) {
-        result.memories = await getRecentMemories(project.path, limit);
-    }
-    if (include.includes('observations')) {
-        result.observations = await getObservationsForProject(project.path, limit);
-    }
-    if (include.includes('entities')) {
-        result.entities = await getEntitiesForProject(project.path, limit);
-    }
-    return result;
-}
-//# sourceMappingURL=context.js.map

package/dist/core/governance.js

@@ -1,64 +0,0 @@
-/**
- * Memory Governance
- * Implements protection, pinning, and immutability rules
- */
-import { eq } from 'drizzle-orm';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { config } from '../config.js';
-import { performMemoryOperation } from './utils/memory-operations.js';
-import { logger } from './logger.js';
-/**
- * Mark a memory as protected (cannot be evicted)
- */
-export async function protectMemory(memoryId, reason) {
-    await performMemoryOperation(memoryId, {
-        name: 'protecting memory',
-        updates: {
-            isProtected: true,
-            metadata: { protectionReason: reason, protectedAt: new Date().toISOString() },
-        },
-    });
-}
-/**
- * Pin a memory for automatic injection into context
- */
-export async function pinMemory(memoryId) {
-    await performMemoryOperation(memoryId, {
-        name: 'pinning memory',
-        updates: {
-            isPinned: true,
-            metadata: { pinnedAt: new Date().toISOString() },
-        },
-    });
-}
-/**
- * Unpin a memory
- */
-export async function unpinMemory(memoryId) {
-    await performMemoryOperation(memoryId, {
-        name: 'unpinning memory',
-        updates: { isPinned: false },
-    });
-}
-/**
- * Get all pinned memories for auto-injection into context
- */
-export async function getPinnedMemories() {
-    if (!config.governanceEnabled)
-        return [];
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        return await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.isPinned, true))
-            .limit(50);
-    }
-    catch (error) {
-        logger.error('Error retrieving pinned memories', error);
-        return [];
-    }
-}
-//# sourceMappingURL=governance.js.map

package/dist/core/local-embeddings.d.ts

@@ -1,6 +0,0 @@
-/**
- * Utility functions for local embeddings
- * Note: Actual embedding generation is in core/embeddings.ts
- */
-export declare function cosineSimilarity(a: number[], b: number[]): number;
-//# sourceMappingURL=local-embeddings.d.ts.map

package/dist/core/local-embeddings.js

@@ -1,20 +0,0 @@
-/**
- * Utility functions for local embeddings
- * Note: Actual embedding generation is in core/embeddings.ts
- */
-export function cosineSimilarity(a, b) {
-    if (a.length !== b.length) {
-        throw new Error('Embeddings must have same dimensions');
-    }
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dotProduct += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-    return denominator === 0 ? 0 : dotProduct / denominator;
-}
-//# sourceMappingURL=local-embeddings.js.map

package/dist/core/namespaces/index.d.ts

@@ -1,71 +0,0 @@
-/** Namespace Management - Hierarchical folder-like namespaces for memories */
-export type NamespaceType = 'root' | 'user' | 'agent' | 'project' | 'custom';
-export interface Namespace {
-    id: string;
-    projectId: string;
-    name: string;
-    parentId: string | null;
-    type: NamespaceType;
-    description: string | null;
-    path: string;
-    children?: Namespace[];
-    createdAt: Date;
-    updatedAt: Date;
-}
-export interface NamespaceCreateInput {
-    projectId: string;
-    name: string;
-    type: NamespaceType;
-    parentId?: string | null;
-    description?: string;
-}
-export interface NamespaceTree {
-    id: string;
-    name: string;
-    type: NamespaceType;
-    description: string | null;
-    path: string;
-    children: NamespaceTree[];
-}
-/**
- * Create a new namespace
- */
-export declare function createNamespace(input: NamespaceCreateInput): Promise<Namespace>;
-/**
- * Get a namespace by ID
- */
-export declare function getNamespaceById(id: string): Promise<Namespace | null>;
-/**
- * Resolve a namespace path to a namespace ID
- * @example resolveNamespacePath('my-project', ['user', 'preferences']) -> namespaceId
- */
-export declare function resolveNamespacePath(projectId: string, path: string[]): Promise<string | null>;
-/**
- * Get namespace tree for a project
- */
-export declare function getNamespaceTree(projectId: string): Promise<NamespaceTree[]>;
-/**
- * Get or create default namespaces for a project
- */
-export declare function getDefaultNamespaces(projectId: string): Promise<Namespace[]>;
-/**
- * List namespaces with optional filtering
- */
-export declare function listNamespaces(options?: {
-    projectId?: string;
-    type?: NamespaceType;
-    parentId?: string;
-    recursive?: boolean;
-}): Promise<Namespace[]>;
-/**
- * Delete a namespace (cascades to child namespaces)
- */
-export declare function deleteNamespace(id: string): Promise<void>;
-/**
- * Update namespace
- */
-export declare function updateNamespace(id: string, updates: Partial<{
-    name: string;
-    description: string;
-}>): Promise<void>;
-//# sourceMappingURL=index.d.ts.map