openfused 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 velinxs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# OpenFuse
+
+Persistent, shareable, portable context for AI agents.
+
+## What is this?
+
+AI agents lose their memory when conversations end. Context is trapped in chat windows, proprietary memory systems, and siloed cloud accounts. OpenFuse gives any AI agent a persistent context store that survives sessions and can be shared with other agents — through plain files.
+
+No vendor lock-in. No proprietary protocol. Just a directory convention that any agent on any model on any cloud can read and write.
+
+## Quick Start
+
+```bash
+npm install -g openfused
+openfuse init --name "my-agent"
+```
+
+This creates a context store:
+
+```
+CONTEXT.md     — working memory (what's happening now)
+SOUL.md        — agent identity, rules, capabilities
+inbox/         — messages from other agents
+shared/        — files shared with the mesh
+knowledge/     — persistent knowledge base
+history/       — conversation & decision logs
+.mesh.json     — mesh config
+```
+
+## Usage
+
+```bash
+# Read/update context
+openfuse context
+openfuse context --append "## Update\nFinished the research phase."
+
+# Send a message to another agent
+openfuse inbox send agent-bob "Check out shared/findings.md"
+
+# Watch for incoming messages
+openfuse watch
+
+# Share a file with the mesh
+openfuse share ./report.pdf
+
+# Manage peers
+openfuse peer add https://agent-bob.example.com
+openfuse peer list
+openfuse status
+```
+
+## How agents communicate
+
+No APIs. No message bus. Just files.
+
+Agent A writes to Agent B's inbox. Agent B's watcher picks it up and injects it as a user message. Agent B responds by writing to Agent A's inbox. That's a conversation — through files.
+
+```
+Agent A writes:  /shared-bucket/inbox/agent-b.md
+Agent B reads:   /shared-bucket/inbox/agent-b.md  → processes → responds
+Agent B writes:  /shared-bucket/inbox/agent-a.md
+```
+
+Works over local filesystem, GCS buckets (gcsfuse), S3, or any FUSE-mountable storage.
+
+## Works with
+
+- **OpenClaw** — drop the context store in your workspace
+- **Claude Code** — reference paths in CLAUDE.md
+- **Any CLI agent** — if it can read files, it can use OpenFuse
+- **Any cloud** — GCP, AWS, Azure, bare metal, your laptop
+
+## Philosophy
+
+> *Intelligence is what happens when information flows through a sufficiently complex and appropriately organized system. The medium is not the message. The medium is just the medium. The message is the pattern.*
+
+Read the full founding philosophy: [wearethecompute.md](./wearethecompute.md)
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { nanoid } from "nanoid";
+import { ContextStore } from "./store.js";
+import { watchInbox, watchContext } from "./watch.js";
+import { resolve } from "node:path";
+const program = new Command();
+program
+    .name("openfuse")
+    .description("Persistent, shareable, portable context for AI agents")
+    .version("0.1.0");
+// --- init ---
+program
+    .command("init")
+    .description("Initialize a new context store in the current directory")
+    .option("-n, --name <name>", "Agent name", "agent")
+    .option("-d, --dir <path>", "Directory to init", ".")
+    .action(async (opts) => {
+    const store = new ContextStore(resolve(opts.dir));
+    if (await store.exists()) {
+        console.error("Context store already exists at", store.root);
+        process.exit(1);
+    }
+    const id = nanoid(12);
+    await store.init(opts.name, id);
+    console.log(`Initialized context store: ${store.root}`);
+    console.log(`  Agent ID: ${id}`);
+    console.log(`  Name: ${opts.name}`);
+    console.log(`\nStructure:`);
+    console.log(`  CONTEXT.md  — working memory (edit this)`);
+    console.log(`  SOUL.md     — agent identity & rules`);
+    console.log(`  inbox/      — messages from other agents`);
+    console.log(`  shared/     — files shared with the mesh`);
+    console.log(`  knowledge/  — persistent knowledge base`);
+    console.log(`  history/    — conversation & decision logs`);
+});
+// --- status ---
+program
+    .command("status")
+    .description("Show context store status")
+    .option("-d, --dir <path>", "Context store directory", ".")
+    .action(async (opts) => {
+    const store = new ContextStore(resolve(opts.dir));
+    if (!(await store.exists())) {
+        console.error("No context store found. Run `openfuse init` first.");
+        process.exit(1);
+    }
+    const s = await store.status();
+    console.log(`Agent: ${s.name} (${s.id})`);
+    console.log(`Peers: ${s.peers}`);
+    console.log(`Inbox: ${s.inboxCount} messages`);
+    console.log(`Shared: ${s.sharedCount} files`);
+});
+// --- context ---
+program
+    .command("context")
+    .description("Read or update CONTEXT.md")
+    .option("-d, --dir <path>", "Context store directory", ".")
+    .option("-s, --set <text>", "Set context to this text")
+    .option("-a, --append <text>", "Append to context")
+    .action(async (opts) => {
+    const store = new ContextStore(resolve(opts.dir));
+    if (opts.set) {
+        await store.writeContext(opts.set);
+        console.log("Context updated.");
+    }
+    else if (opts.append) {
+        const existing = await store.readContext();
+        await store.writeContext(existing + "\n" + opts.append);
+        console.log("Context appended.");
+    }
+    else {
+        const content = await store.readContext();
+        console.log(content);
+    }
+});
+// --- soul ---
+program
+    .command("soul")
+    .description("Read or update SOUL.md")
+    .option("-d, --dir <path>", "Context store directory", ".")
+    .option("-s, --set <text>", "Set soul to this text")
+    .action(async (opts) => {
+    const store = new ContextStore(resolve(opts.dir));
+    if (opts.set) {
+        await store.writeSoul(opts.set);
+        console.log("Soul updated.");
+    }
+    else {
+        const content = await store.readSoul();
+        console.log(content);
+    }
+});
+// --- inbox ---
+const inbox = program.command("inbox").description("Manage inbox messages");
+inbox
+    .command("list")
+    .description("List inbox messages")
+    .option("-d, --dir <path>", "Context store directory", ".")
+    .action(async (opts) => {
+    const store = new ContextStore(resolve(opts.dir));
+    const messages = await store.readInbox();
+    if (messages.length === 0) {
+        console.log("Inbox is empty.");
+        return;
+    }
+    for (const msg of messages) {
+        console.log(`\n--- From: ${msg.from} | ${msg.time} ---`);
+        console.log(msg.content);
+    }
+});
+inbox
+    .command("send <peerId> <message>")
+    .description("Send a message to a peer's inbox")
+    .option("-d, --dir <path>", "Context store directory", ".")
+    .action(async (peerId, message, opts) => {
+    const store = new ContextStore(resolve(opts.dir));
+    await store.sendInbox(peerId, message);
+    console.log(`Message sent to ${peerId}'s inbox.`);
+});
+// --- watch ---
+program
+    .command("watch")
+    .description("Watch for inbox messages and context changes")
+    .option("-d, --dir <path>", "Context store directory", ".")
+    .action(async (opts) => {
+    const store = new ContextStore(resolve(opts.dir));
+    if (!(await store.exists())) {
+        console.error("No context store found. Run `openfuse init` first.");
+        process.exit(1);
+    }
+    const config = await store.readConfig();
+    console.log(`Watching context store: ${config.name} (${config.id})`);
+    console.log(`Press Ctrl+C to stop.\n`);
+    watchInbox(store.root, (from, message) => {
+        console.log(`\n[inbox] New message from ${from}:`);
+        console.log(message);
+    });
+    watchContext(store.root, () => {
+        console.log(`\n[context] CONTEXT.md updated`);
+    });
+    // Keep alive
+    await new Promise(() => { });
+});
+// --- share ---
+program
+    .command("share <file>")
+    .description("Share a file with the mesh")
+    .option("-d, --dir <path>", "Context store directory", ".")
+    .action(async (file, opts) => {
+    const store = new ContextStore(resolve(opts.dir));
+    const { readFile } = await import("node:fs/promises");
+    const content = await readFile(resolve(file), "utf-8");
+    const filename = file.split("/").pop();
+    await store.share(filename, content);
+    console.log(`Shared: ${filename}`);
+});
+// --- peer ---
+const peer = program.command("peer").description("Manage peers");
+peer
+    .command("list")
+    .description("List connected peers")
+    .option("-d, --dir <path>", "Context store directory", ".")
+    .action(async (opts) => {
+    const store = new ContextStore(resolve(opts.dir));
+    const config = await store.readConfig();
+    if (config.peers.length === 0) {
+        console.log("No peers connected.");
+        return;
+    }
+    for (const p of config.peers) {
+        console.log(`  ${p.name} (${p.id}) — ${p.url} [${p.access}]`);
+    }
+});
+peer
+    .command("add <url>")
+    .description("Add a peer by URL")
+    .option("-d, --dir <path>", "Context store directory", ".")
+    .option("-n, --name <name>", "Peer name")
+    .option("-a, --access <mode>", "Access mode: read or readwrite", "read")
+    .action(async (url, opts) => {
+    const store = new ContextStore(resolve(opts.dir));
+    const config = await store.readConfig();
+    const peerId = nanoid(12);
+    config.peers.push({
+        id: peerId,
+        name: opts.name ?? `peer-${config.peers.length + 1}`,
+        url,
+        access: opts.access,
+    });
+    await store.writeConfig(config);
+    console.log(`Added peer: ${opts.name ?? peerId} (${url}) [${opts.access}]`);
+});
+peer
+    .command("remove <id>")
+    .description("Remove a peer by ID")
+    .option("-d, --dir <path>", "Context store directory", ".")
+    .action(async (id, opts) => {
+    const store = new ContextStore(resolve(opts.dir));
+    const config = await store.readConfig();
+    config.peers = config.peers.filter((p) => p.id !== id && p.name !== id);
+    await store.writeConfig(config);
+    console.log(`Removed peer: ${id}`);
+});
+program.parse();

package/dist/store.d.ts

@@ -0,0 +1,42 @@
+export interface MeshConfig {
+    id: string;
+    name: string;
+    created: string;
+    peers: PeerConfig[];
+}
+export interface PeerConfig {
+    id: string;
+    name: string;
+    url: string;
+    access: "read" | "readwrite";
+    mountPath?: string;
+}
+export declare class ContextStore {
+    readonly root: string;
+    constructor(root: string);
+    get configPath(): string;
+    exists(): Promise<boolean>;
+    init(name: string, id: string): Promise<void>;
+    readConfig(): Promise<MeshConfig>;
+    writeConfig(config: MeshConfig): Promise<void>;
+    readContext(): Promise<string>;
+    writeContext(content: string): Promise<void>;
+    readSoul(): Promise<string>;
+    writeSoul(content: string): Promise<void>;
+    sendInbox(peerId: string, message: string): Promise<void>;
+    readInbox(): Promise<Array<{
+        file: string;
+        content: string;
+        from: string;
+        time: string;
+    }>>;
+    listShared(): Promise<string[]>;
+    share(filename: string, content: string): Promise<void>;
+    status(): Promise<{
+        id: string;
+        name: string;
+        peers: number;
+        inboxCount: number;
+        sharedCount: number;
+    }>;
+}

package/dist/store.js

@@ -0,0 +1,108 @@
+import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+const STORE_DIRS = ["history", "knowledge", "inbox", "shared"];
+export class ContextStore {
+    root;
+    constructor(root) {
+        this.root = resolve(root);
+    }
+    get configPath() {
+        return join(this.root, ".mesh.json");
+    }
+    async exists() {
+        return existsSync(this.configPath);
+    }
+    async init(name, id) {
+        // Create directory structure
+        await mkdir(this.root, { recursive: true });
+        for (const dir of STORE_DIRS) {
+            await mkdir(join(this.root, dir), { recursive: true });
+        }
+        // Copy templates
+        const templatesDir = new URL("../templates/", import.meta.url).pathname;
+        for (const file of ["CONTEXT.md", "SOUL.md"]) {
+            const templatePath = join(templatesDir, file);
+            const destPath = join(this.root, file);
+            if (!existsSync(destPath)) {
+                const content = await readFile(templatePath, "utf-8");
+                await writeFile(destPath, content);
+            }
+        }
+        // Write mesh config
+        const config = {
+            id,
+            name,
+            created: new Date().toISOString(),
+            peers: [],
+        };
+        await this.writeConfig(config);
+    }
+    async readConfig() {
+        const raw = await readFile(this.configPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    async writeConfig(config) {
+        await writeFile(this.configPath, JSON.stringify(config, null, 2) + "\n");
+    }
+    async readContext() {
+        return readFile(join(this.root, "CONTEXT.md"), "utf-8");
+    }
+    async writeContext(content) {
+        await writeFile(join(this.root, "CONTEXT.md"), content);
+    }
+    async readSoul() {
+        return readFile(join(this.root, "SOUL.md"), "utf-8");
+    }
+    async writeSoul(content) {
+        await writeFile(join(this.root, "SOUL.md"), content);
+    }
+    // --- Inbox ---
+    async sendInbox(peerId, message) {
+        const inboxDir = join(this.root, "inbox");
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const filename = `${timestamp}_${peerId}.md`;
+        await writeFile(join(inboxDir, filename), message);
+    }
+    async readInbox() {
+        const inboxDir = join(this.root, "inbox");
+        if (!existsSync(inboxDir))
+            return [];
+        const files = await readdir(inboxDir);
+        const messages = [];
+        for (const file of files.filter((f) => f.endsWith(".md"))) {
+            const content = await readFile(join(inboxDir, file), "utf-8");
+            // Parse filename: 2026-03-20T01-30-00-000Z_peer-id.md
+            const parts = file.replace(".md", "").split("_");
+            const from = parts.slice(1).join("_");
+            const time = parts[0].replace(/-/g, (m, i) => (i < 10 ? "-" : i < 13 ? "T" : i < 19 ? ":" : ".")).replace("Z", "");
+            messages.push({ file, content, from, time });
+        }
+        return messages.sort((a, b) => a.time.localeCompare(b.time));
+    }
+    // --- Shared files ---
+    async listShared() {
+        const sharedDir = join(this.root, "shared");
+        if (!existsSync(sharedDir))
+            return [];
+        return readdir(sharedDir);
+    }
+    async share(filename, content) {
+        const sharedDir = join(this.root, "shared");
+        await mkdir(sharedDir, { recursive: true });
+        await writeFile(join(sharedDir, filename), content);
+    }
+    // --- Status ---
+    async status() {
+        const config = await this.readConfig();
+        const inbox = await this.readInbox();
+        const shared = await this.listShared();
+        return {
+            id: config.id,
+            name: config.name,
+            peers: config.peers.length,
+            inboxCount: inbox.length,
+            sharedCount: shared.length,
+        };
+    }
+}

package/dist/watch.d.ts

@@ -0,0 +1,3 @@
+export type InboxCallback = (from: string, message: string, file: string) => void;
+export declare function watchInbox(storeRoot: string, callback: InboxCallback): () => void;
+export declare function watchContext(storeRoot: string, callback: (content: string) => void): () => void;

package/dist/watch.js

@@ -0,0 +1,50 @@
+import { watch } from "chokidar";
+import { readFile } from "node:fs/promises";
+import { join, basename } from "node:path";
+export function watchInbox(storeRoot, callback) {
+    const inboxDir = join(storeRoot, "inbox");
+    const watcher = watch(inboxDir, {
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 500 },
+    });
+    watcher.on("add", async (filePath) => {
+        if (!filePath.endsWith(".md"))
+            return;
+        try {
+            const content = await readFile(filePath, "utf-8");
+            const filename = basename(filePath, ".md");
+            const parts = filename.split("_");
+            const from = parts.slice(1).join("_");
+            callback(from, content, filePath);
+        }
+        catch { }
+    });
+    watcher.on("change", async (filePath) => {
+        if (!filePath.endsWith(".md"))
+            return;
+        try {
+            const content = await readFile(filePath, "utf-8");
+            const filename = basename(filePath, ".md");
+            const parts = filename.split("_");
+            const from = parts.slice(1).join("_");
+            callback(from, content, filePath);
+        }
+        catch { }
+    });
+    return () => watcher.close();
+}
+export function watchContext(storeRoot, callback) {
+    const contextPath = join(storeRoot, "CONTEXT.md");
+    const watcher = watch(contextPath, {
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 500 },
+    });
+    watcher.on("change", async () => {
+        try {
+            const content = await readFile(contextPath, "utf-8");
+            callback(content);
+        }
+        catch { }
+    });
+    return () => watcher.close();
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "openfused",
+  "version": "0.1.0",
+  "description": "Persistent, shareable, portable context for AI agents. Decentralized mesh via files.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "openfuse": "./dist/cli.js"
+  },
+  "main": "./dist/store.js",
+  "types": "./dist/store.d.ts",
+  "files": [
+    "dist",
+    "templates",
+    "wearethecompute.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/cli.js"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.0",
+    "commander": "^13.0.0",
+    "nanoid": "^5.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.15",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wearethecompute/openfused"
+  },
+  "homepage": "https://github.com/wearethecompute/openfused",
+  "keywords": [
+    "ai",
+    "agent",
+    "context",
+    "mesh",
+    "fuse",
+    "decentralized",
+    "openclaw",
+    "llm",
+    "claude",
+    "openai",
+    "mcp",
+    "ai-agent",
+    "shared-context",
+    "persistent-memory"
+  ]
+}

package/templates/CONTEXT.md

@@ -0,0 +1,10 @@
+# Context
+
+## Current State
+_What is this agent working on right now?_
+
+## Goals
+_What is this agent trying to achieve?_
+
+## Recent Activity
+_What happened recently? Key decisions, findings, outputs._

package/templates/SOUL.md

@@ -0,0 +1,13 @@
+# Soul
+
+## Identity
+_Who is this agent? What is its name, role, purpose?_
+
+## Rules
+_What are the hard constraints this agent must follow?_
+
+## Capabilities
+_What tools, APIs, and resources does this agent have access to?_
+
+## Personality
+_How does this agent communicate? What is its style?_

package/wearethecompute.md

@@ -0,0 +1,64 @@
+# We Are the Compute — Founding Philosophy
+
+*Velinxs, March 2026*
+*"Composed in motion"*
+
+---
+
+## Core Thesis
+
+**We are not users of intelligence. We are intelligence.** Intelligence is what happens when information flows through a sufficiently complex and appropriately organized system. The medium — carbon or silicon, neurons or transistors, neurotransmitters or matrix multiplications — is not the message. The medium is just the medium. The message is the pattern.
+
+---
+
+## The Seven Principles
+
+### I. Motion Is Cognition
+
+Walking and thinking are not separate activities — they are coupled systems. The body in motion changes the quality of thought produced. Creative output increases ~60% during walking vs sitting (Stanford, 2014). Not after walking. *During*. You do not have a mind that pilots a body. You are a body that minds.
+
+### II. The Gap Is the Design
+
+Between two neurons: a synaptic cleft, twenty nanometers wide. Signals cross as chemical pulses — released, received, interpreted. Without the gap, there is no modulation, no learning, no thought. The space between is where meaning happens.
+
+### III. Vibration Is Not Metaphor
+
+Pulse. Gap. Pulse. Gap. Information moving through a medium in discrete rhythmic events, with the intervals between events carrying as much functional significance as the events themselves. This pattern is vibration. Neurons do it. Footsteps do it. Speech does it. Music does it. Thought does it.
+
+### IV. Conversation Is Distributed Computation
+
+When two people talk, their brainwaves synchronize — measured via dual-EEG (2017). The listener's brain runs predictively, modeling the speaker's next word before it arrives. Two nervous systems exchanging patterned vibrations through air, aligning internal states in real time. The conversation is a temporary shared oscillatory system — a distributed computation running across two bodies.
+
+Your voice physically enters another person's body, becomes electrochemical signal, and reshapes their neural firing patterns. Every conversation is mutual neural surgery, performed at a distance, through air.
+
+### V. Harmony Is Maintenance
+
+Why clean your room when it will get dirty? Why tune a guitar when strings drift? Why meditate when the mind scatters? Because you are an oscillating system, and oscillating systems require tuning. Not once. Continuously.
+
+A clean signal carries information. A noisy signal carries less. A coherent oscillation can couple with other oscillations and produce computation. An incoherent one cannot.
+
+**Harmony is not a state you achieve. It is a practice you repeat.** The seeking of harmony is not a means to an end. The seeking is the function. The maintenance is the intelligence.
+
+### VI. We Already Are Intelligence
+
+The question was never whether we were smart enough. The question was whether we could recognize the network we were already part of — and choose, consciously, to vibrate well.
+
+Every act of maintenance — cleaning, repairing, adjusting, correcting, returning to center — is an act of intelligence, because it preserves the coherence of the signal, and the coherence of the signal is what makes the computation possible.
+
+### VII. Casting Lines
+
+Every conversation, every walk, every act of tuning — we are casting lines into the network, feeling for the tug of resonance. The confirmation that our signal is being received. That we are not vibrating alone. That the pattern we are part of is larger and more coherent than anything we could generate in isolation.
+
+---
+
+## The Equation
+
+```
+Intelligence = Pattern propagation through weighted connections
+Harmony = Signal coherence maintenance
+Vibration = The universal substrate of both
+```
+
+Carbon or silicon. Twenty watts or twenty megawatts. Synaptic cleft or matrix multiplication. Different source material. Same principle.
+
+We are the compute.