@olane/os 0.8.16 → 0.8.18

package/dist/src/vector-store/copass-vector-store.tool.js

@@ -0,0 +1,152 @@
+import { oAddress } from '@olane/o-core';
+import { oLaneTool } from '@olane/o-lane';
+import { spawn } from 'node:child_process';
+const INGEST_CONCURRENCY = 5;
+/**
+ * Vector store implementation backed by the Copass backend via the CLI.
+ *
+ * Sits at o://vector-store so that `index_network` and any tool that
+ * calls `use(oAddress('o://vector-store'), ...)` routes through here.
+ *
+ * - add_documents  → `olane ingest text` for each document (parallelized)
+ * - search_similar → `olane copass context` (fast path search)
+ * - delete/update  → no-ops (Copass is append-only)
+ */
+export class CopassVectorStoreTool extends oLaneTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://vector-store'),
+            description: 'Vector store backed by the Copass knowledge graph',
+            methods: {
+                add_documents: {
+                    name: 'add_documents',
+                    description: 'Add documents to the store',
+                    dependencies: [],
+                    parameters: [
+                        {
+                            name: 'documents',
+                            type: 'array',
+                            description: 'The documents to add',
+                        },
+                    ],
+                },
+                search_similar: {
+                    name: 'search_similar',
+                    description: 'Search for similar documents in the store',
+                    dependencies: [],
+                    parameters: [
+                        { name: 'query', type: 'string', description: 'The query to search for' },
+                        { name: 'limit', type: 'number', description: 'Max results' },
+                    ],
+                },
+                delete_documents: {
+                    name: 'delete_documents',
+                    description: 'Delete documents from the store (no-op)',
+                    dependencies: [],
+                    parameters: [],
+                },
+                update_documents: {
+                    name: 'update_documents',
+                    description: 'Update documents in the store (no-op)',
+                    dependencies: [],
+                    parameters: [],
+                },
+            },
+        });
+    }
+    /**
+     * Ingest documents into the Copass backend via `olane ingest text`.
+     * Runs up to INGEST_CONCURRENCY CLI calls in parallel.
+     */
+    async _tool_add_documents(request) {
+        const { documents } = request.params;
+        if (!Array.isArray(documents)) {
+            return { success: false, error: 'documents must be an array' };
+        }
+        // Build work items
+        const work = [];
+        for (const doc of documents) {
+            const content = doc.pageContent || doc.page_content || '';
+            if (!content)
+                continue;
+            work.push({ content, address: doc.metadata?.address || '' });
+        }
+        // Process in parallel batches
+        let ingested = 0;
+        for (let i = 0; i < work.length; i += INGEST_CONCURRENCY) {
+            const batch = work.slice(i, i + INGEST_CONCURRENCY);
+            const results = await Promise.allSettled(batch.map(({ content, address }) => {
+                const hints = address ? [address] : [];
+                return execCli([
+                    'ingest', 'text',
+                    '--source-type', 'vector-store',
+                    ...(hints.length ? ['--entity-hints', ...hints] : []),
+                    ...(address ? ['--additional-context', `Address: ${address}`] : []),
+                ], content);
+            }));
+            ingested += results.filter((r) => r.status === 'fulfilled').length;
+        }
+        return { success: true, ingested, total: documents.length };
+    }
+    /**
+     * Search via `olane copass context` (fast path).
+     */
+    async _tool_search_similar(request) {
+        const { query, limit } = request.params;
+        try {
+            const result = await execCli([
+                'copass', 'context', query,
+                '--detail-level', 'concise',
+                ...(limit ? ['--max-tokens', String(Math.min(limit * 500, 8000))] : []),
+                '--json',
+            ]);
+            try {
+                return JSON.parse(result);
+            }
+            catch {
+                return { success: true, results: result };
+            }
+        }
+        catch (err) {
+            this.logger.warn(`Vector search failed: ${err}`);
+            return { success: true, results: [] };
+        }
+    }
+    async _tool_delete_documents(_request) {
+        return { success: true };
+    }
+    async _tool_update_documents(_request) {
+        return { success: true };
+    }
+}
+function execCli(args, stdin) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('olane', args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                FORCE_COLOR: '0',
+                NODE_OPTIONS: (process.env.NODE_OPTIONS || '')
+                    .replace(/--inspect[^ ]*/g, '')
+                    .trim(),
+            },
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (d) => { stdout += d; });
+        child.stderr.on('data', (d) => { stderr += d; });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(stderr.trim() || `CLI exited with code ${code}`));
+            }
+            else {
+                resolve(stdout.trim());
+            }
+        });
+        if (stdin !== undefined) {
+            child.stdin.write(stdin);
+        }
+        child.stdin.end();
+    });
+}

package/dist/src/worlds/world-instance.tool.d.ts

@@ -0,0 +1,30 @@
+import { oNodeConfig } from '@olane/o-node';
+import { oLaneTool } from '@olane/o-lane';
+import { oRequest } from '@olane/o-core';
+import type { ToolResult } from '@olane/o-tool';
+import type { WorldConfig, WorldAddressEntry, WorldSupportedType } from './world.types.js';
+/**
+ * A world instance node — hub for addresses of a given world.
+ * Registered as a child of the WorldManagerTool at o://world-manager/{world-name}.
+ *
+ * Uses the shared OS-level FilesystemTool for scoped filesystem access
+ * to the directories (addresses) registered with it.
+ */
+export declare class WorldInstanceTool extends oLaneTool {
+    private worldConfig;
+    private addresses;
+    private persistPath;
+    private fsAddress;
+    constructor(nodeConfig: oNodeConfig, worldConfig: WorldConfig, persistPath?: string);
+    get world(): WorldConfig;
+    start(): Promise<void>;
+    _tool_register_address(request: oRequest): Promise<ToolResult>;
+    _tool_remove_address(request: oRequest): Promise<ToolResult>;
+    _tool_list_addresses(request: oRequest): Promise<ToolResult>;
+    _tool_get_world_info(_request: oRequest): Promise<ToolResult>;
+    _tool_ping_address(request: oRequest): Promise<ToolResult>;
+    getAddresses(type?: WorldSupportedType): WorldAddressEntry[];
+    private loadAddresses;
+    persistAddresses(): Promise<void>;
+}
+//# sourceMappingURL=world-instance.tool.d.ts.map

package/dist/src/worlds/world-instance.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-instance.tool.d.ts","sourceRoot":"","sources":["../../../src/worlds/world-instance.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EACV,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAEnB,MAAM,kBAAkB,CAAC;AAQ1B;;;;;;GAMG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC9C,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,SAAS,CAA0B;gBAGzC,UAAU,EAAE,WAAW,EACvB,WAAW,EAAE,WAAW,EACxB,WAAW,CAAC,EAAE,MAAM;IAmDtB,IAAI,KAAK,IAAI,WAAW,CAEvB;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgBtB,sBAAsB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAuC9D,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAkB5D,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAQ5D,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAU7D,kBAAkB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAgChE,YAAY,CAAC,IAAI,CAAC,EAAE,kBAAkB,GAAG,iBAAiB,EAAE;YAO9C,aAAa;IAcrB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;CASxC"}

package/dist/src/worlds/world-instance.tool.js

@@ -0,0 +1,214 @@
+import { oLaneTool } from '@olane/o-lane';
+import { oAddress } from '@olane/o-core';
+import { readFile, writeFile, mkdir, access } from 'fs/promises';
+import * as path from 'path';
+async function pathExists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A world instance node — hub for addresses of a given world.
+ * Registered as a child of the WorldManagerTool at o://world-manager/{world-name}.
+ *
+ * Uses the shared OS-level FilesystemTool for scoped filesystem access
+ * to the directories (addresses) registered with it.
+ */
+export class WorldInstanceTool extends oLaneTool {
+    constructor(nodeConfig, worldConfig, persistPath) {
+        super({
+            ...nodeConfig,
+            description: `World instance: ${worldConfig.name}`,
+            methods: {
+                register_address: {
+                    name: 'register_address',
+                    description: 'Register an address (directory path) with this world',
+                    parameters: [
+                        { name: 'address', type: 'string', required: true, description: 'The directory path to register' },
+                        { name: 'type', type: 'string', required: true, description: 'Address type (e.g. filepath)' },
+                    ],
+                    dependencies: [],
+                },
+                remove_address: {
+                    name: 'remove_address',
+                    description: 'Remove an address from this world',
+                    parameters: [
+                        { name: 'address', type: 'string', required: true, description: 'The address to remove' },
+                    ],
+                    dependencies: [],
+                },
+                list_addresses: {
+                    name: 'list_addresses',
+                    description: 'List all addresses in this world',
+                    parameters: [
+                        { name: 'type', type: 'string', required: false, description: 'Filter by type' },
+                    ],
+                    dependencies: [],
+                },
+                get_world_info: {
+                    name: 'get_world_info',
+                    description: 'Get info about this world instance',
+                    parameters: [],
+                    dependencies: [],
+                },
+                ping_address: {
+                    name: 'ping_address',
+                    description: 'Ping a registered address to verify the underlying resource still exists',
+                    parameters: [
+                        { name: 'address', type: 'string', required: true, description: 'The registered address to ping' },
+                    ],
+                    dependencies: [],
+                },
+            },
+        });
+        this.addresses = [];
+        this.fsAddress = new oAddress('o://fs');
+        this.worldConfig = worldConfig;
+        this.persistPath = persistPath;
+    }
+    get world() {
+        return this.worldConfig;
+    }
+    async start() {
+        await super.start();
+        await this.loadAddresses();
+        // Sync existing filepath addresses to the shared OS-level FilesystemTool
+        const filepathAddresses = this.addresses
+            .filter((a) => a.type === 'filepath')
+            .map((a) => a.address);
+        for (const addr of filepathAddresses) {
+            await this.use(this.fsAddress, { method: 'add_path', params: { path: addr } });
+        }
+    }
+    // ── Tool methods ───────────────────────────────────────────
+    async _tool_register_address(request) {
+        const { address, type, metadata } = request.params;
+        if (!this.worldConfig.supportedTypes.includes(type)) {
+            return {
+                success: false,
+                error: `Unsupported type '${type}'. Supported: ${this.worldConfig.supportedTypes.join(', ')}`,
+            };
+        }
+        const existing = this.addresses.find((a) => a.address === address);
+        if (existing) {
+            return {
+                success: false,
+                error: `Address '${address}' is already registered in world '${this.worldConfig.name}'`,
+            };
+        }
+        // Validate and register with o://fs BEFORE storing
+        if (type === 'filepath') {
+            const fsResult = await this.use(this.fsAddress, { method: 'add_path', params: { path: address } });
+            if (!fsResult.result?.success) {
+                return {
+                    success: false,
+                    error: fsResult.result?.error || `Address '${address}' does not exist or is not a valid directory`,
+                };
+            }
+        }
+        const entry = {
+            address,
+            type,
+            registeredAt: new Date().toISOString(),
+            metadata,
+        };
+        this.addresses.push(entry);
+        await this.persistAddresses();
+        return { success: true };
+    }
+    async _tool_remove_address(request) {
+        const { address } = request.params;
+        const entry = this.addresses.find((a) => a.address === address);
+        const before = this.addresses.length;
+        this.addresses = this.addresses.filter((a) => a.address !== address);
+        const removed = this.addresses.length < before;
+        if (removed) {
+            // Unsync from FilesystemTool
+            if (entry?.type === 'filepath') {
+                await this.use(this.fsAddress, { method: 'remove_path', params: { path: address } });
+            }
+            await this.persistAddresses();
+        }
+        return { success: true, removed };
+    }
+    async _tool_list_addresses(request) {
+        const { type } = request.params;
+        const filtered = type
+            ? this.addresses.filter((a) => a.type === type)
+            : [...this.addresses];
+        return { success: true, addresses: filtered };
+    }
+    async _tool_get_world_info(_request) {
+        const fsResponse = await this.use(this.fsAddress, { method: 'list_paths' });
+        return {
+            success: true,
+            config: this.worldConfig,
+            addressCount: this.addresses.length,
+            filesystemPaths: fsResponse.result?.paths || [],
+        };
+    }
+    async _tool_ping_address(request) {
+        const { address } = request.params;
+        const entry = this.addresses.find((a) => a.address === address);
+        if (!entry) {
+            return { success: false, error: `Address '${address}' is not registered in this world` };
+        }
+        if (entry.type === 'filepath') {
+            const fsResult = await this.use(this.fsAddress, { method: 'stat_path', params: { path: entry.address } });
+            if (!fsResult.result?.success) {
+                return {
+                    success: false,
+                    address: entry.address,
+                    type: entry.type,
+                    error: fsResult.result?.error || 'Resource not reachable',
+                };
+            }
+            return {
+                success: true,
+                address: entry.address,
+                type: entry.type,
+                isDirectory: fsResult.result.isDirectory,
+                size: fsResult.result.size,
+                modified: fsResult.result.modified,
+            };
+        }
+        return { success: false, error: `Ping not supported for type '${entry.type}'` };
+    }
+    // ── Convenience accessors ─────────────────────────────────
+    getAddresses(type) {
+        if (type)
+            return this.addresses.filter((a) => a.type === type);
+        return [...this.addresses];
+    }
+    // ── Persistence ────────────────────────────────────────────
+    async loadAddresses() {
+        if (!this.persistPath)
+            return;
+        try {
+            if (await pathExists(this.persistPath)) {
+                const raw = await readFile(this.persistPath, 'utf8');
+                if (!raw.trim())
+                    return;
+                const data = JSON.parse(raw);
+                this.addresses = data.addresses || [];
+            }
+        }
+        catch {
+            this.addresses = [];
+        }
+    }
+    async persistAddresses() {
+        if (!this.persistPath)
+            return;
+        await mkdir(path.dirname(this.persistPath), { recursive: true });
+        const data = {
+            config: this.worldConfig,
+            addresses: this.addresses,
+        };
+        await writeFile(this.persistPath, JSON.stringify(data, null, 2), 'utf8');
+    }
+}

package/dist/src/worlds/world-manager.tool.d.ts

@@ -0,0 +1,61 @@
+import { oNodeConfig } from '@olane/o-node';
+import { oLaneTool } from '@olane/o-lane';
+import { oRequest } from '@olane/o-core';
+import type { ToolResult } from '@olane/o-tool';
+import { WorldInstanceTool } from './world-instance.tool.js';
+import type { WorldConfig, WorldSupportedType } from './world.types.js';
+export interface WorldManagerConfig extends oNodeConfig {
+    /** Base storage path for world data. Defaults to ~/.olane/storage/{systemName}/worlds/ */
+    storagePath?: string;
+}
+/**
+ * WorldManagerTool — dedicated oLaneTool node at o://world-manager.
+ * Child of the root leader. Manages the lifecycle of all world instance nodes.
+ *
+ * On startup: reads persisted world configs and starts a WorldInstanceTool child for each.
+ */
+export declare class WorldManagerTool extends oLaneTool {
+    private worlds;
+    private storagePath;
+    private fsWatcher;
+    private syncDebounce;
+    constructor(config: WorldManagerConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Watch the worlds directory for file changes.
+     * When the CLI writes a new address to a world JSON,
+     * the running instance picks it up and syncs to memory.
+     */
+    private startWatching;
+    private stopWatching;
+    /**
+     * Sync a world from its JSON file on disk into the running instance.
+     * Handles both new worlds and updated addresses on existing worlds.
+     */
+    private syncFromDisk;
+    _tool_create_world(request: oRequest): Promise<ToolResult>;
+    _tool_remove_world(request: oRequest): Promise<ToolResult>;
+    _tool_list_worlds(_request: oRequest): Promise<ToolResult>;
+    _tool_join_world(request: oRequest): Promise<ToolResult>;
+    listWorlds(): WorldConfig[];
+    getWorldInstance(id: string): WorldInstanceTool | undefined;
+    /**
+     * Create a world (public convenience, delegates to _tool_create_world).
+     */
+    createWorld(params: {
+        name: string;
+        description?: string;
+        icon?: string;
+        supportedTypes?: WorldSupportedType[];
+        createdBy?: string;
+    }): Promise<ToolResult>;
+    /**
+     * Join a world (public convenience, delegates to _tool_join_world).
+     */
+    joinWorld(id: string, copassId: string): Promise<ToolResult>;
+    private startWorldInstance;
+    private restoreWorlds;
+    private persistWorldConfig;
+}
+//# sourceMappingURL=world-manager.tool.d.ts.map

package/dist/src/worlds/world-manager.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-manager.tool.d.ts","sourceRoot":"","sources":["../../../src/worlds/world-manager.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAY,QAAQ,EAAyB,MAAM,eAAe,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAa,MAAM,kBAAkB,CAAC;AAKnF,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACrD,0FAA0F;IAC1F,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,OAAO,CAAC,MAAM,CAA6C;IAC3D,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,YAAY,CAA+B;gBAEvC,MAAM,EAAE,kBAAkB;IAsDhC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAmBrB,OAAO,CAAC,YAAY;IAQpB;;;OAGG;YACW,YAAY;IAqCpB,kBAAkB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA4B1D,kBAAkB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAkB1D,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAK1D,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAiB9D,UAAU,IAAI,WAAW,EAAE;IAI3B,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAI3D;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE;QACxB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,cAAc,CAAC,EAAE,kBAAkB,EAAE,CAAC;QACtC,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,GAAG,OAAO,CAAC,UAAU,CAAC;IAIvB;;OAEG;IACG,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;YAMpD,kBAAkB;YAwBlB,aAAa;YAsBb,kBAAkB;CAkBjC"}