@amoree-code/ocean 0.0.0-stage → 1.2.0

package/node_modules/@ocean/services/dist/infrastructure/mcp/server-version.js

@@ -0,0 +1,20 @@
+import { readFile } from "node:fs/promises";
+// The version the MCP servers report, read from this package's manifest (T-307: it was
+// hard-coded and drifted from the release).
+let cached;
+export async function serverVersion() {
+    if (cached)
+        return cached;
+    try {
+        const manifest = JSON.parse(await readFile(new URL("../../../package.json", import.meta.url), "utf8"));
+        cached =
+            typeof manifest.version === "string" && manifest.version.trim()
+                ? manifest.version
+                : "unknown";
+    }
+    catch {
+        cached = "unknown";
+    }
+    return cached;
+}
+//# sourceMappingURL=server-version.js.map

package/node_modules/@ocean/services/dist/infrastructure/mcp/tool-registry.js

@@ -0,0 +1,29 @@
+import { mcpToolSchema, } from "@ocean/core/domain/mcp/mcp-contract.js";
+// The tools an MCP server exposes, validated once at registration. `tools/list` and the
+// `tools/call` name check both read from here, so a tool is added by registering it — there is
+// no second list to keep in step.
+export class McpToolRegistry {
+    #tools = new Map();
+    constructor(tools = []) {
+        for (const tool of tools)
+            this.register(tool);
+    }
+    register(tool) {
+        const parsed = mcpToolSchema.safeParse(tool);
+        if (!parsed.success)
+            throw new Error(`Invalid MCP tool ${String(tool.name)}: ${parsed.error.issues
+                .map((issue) => `${issue.path.map(String).join(".")}: ${issue.message}`)
+                .join("; ")}`);
+        if (this.#tools.has(tool.name))
+            throw new Error(`MCP tool ${tool.name} is already registered`);
+        this.#tools.set(tool.name, tool);
+    }
+    has(name) {
+        return this.#tools.has(name);
+    }
+    // Registration order, which is the order clients see.
+    list() {
+        return [...this.#tools.values()];
+    }
+}
+//# sourceMappingURL=tool-registry.js.map

package/node_modules/@ocean/services/dist/obsidian/conflict-log.js

@@ -0,0 +1,68 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+export function parseConflictSide(value) {
+    if (value === "vault")
+        return "vault";
+    if (value === "ocean")
+        return "ocean";
+    return null;
+}
+function conflictsDirectory(root = oceanPath(SYSTEM_DIR, "integrations", "obsidian", "conflicts")) {
+    return root;
+}
+function digest(content) {
+    return content === undefined || content === null
+        ? null
+        : createHash("sha256").update(content).digest("hex");
+}
+export async function appendConflict(input, directory = conflictsDirectory()) {
+    await mkdir(directory, { recursive: true });
+    const id = `${new Date().toISOString().replaceAll(/[:.]/g, "-")}-${randomUUID()}`;
+    const record = {
+        version: 1,
+        id,
+        ...input,
+        createdAt: new Date().toISOString(),
+    };
+    const file = path.join(directory, `${id}.json`);
+    await writeFile(file, `${JSON.stringify(record, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    return file;
+}
+export function readConflictRecord(raw) {
+    const record = raw;
+    return { ...record, oceanSha256: record.oceanSha256 ?? null };
+}
+function changedFromBaseline(record, side) {
+    const hash = side === "vault" ? record.vaultSha256 : record.oceanSha256;
+    return hash !== record.baselineSha256;
+}
+export async function resolveConflict(id, requestedKeep, options = {}) {
+    const keep = parseConflictSide(requestedKeep);
+    if (!keep)
+        throw new Error("Conflict side must be vault or ocean");
+    if (!id || path.basename(id) !== id)
+        throw new Error("Conflict id must be a conflict filename");
+    const directory = options.directory ?? conflictsDirectory();
+    const filename = id.endsWith(".json") ? id : `${id}.json`;
+    const source = path.join(directory, filename);
+    const record = readConflictRecord(JSON.parse(await readFile(source, "utf8")));
+    const vaultChanged = changedFromBaseline(record, "vault");
+    const oceanChanged = changedFromBaseline(record, "ocean");
+    const status = vaultChanged !== oceanChanged ? "auto-resolved" : "manual-required";
+    if (status === "auto-resolved" && options.apply)
+        await options.apply(record, keep);
+    const archiveDirectory = path.join(directory, "resolved");
+    await mkdir(archiveDirectory, { recursive: true });
+    const archived = path.join(archiveDirectory, id);
+    await rename(source, archived);
+    return { id: filename, keep, status, archived };
+}
+export function contentHash(content) {
+    return digest(content);
+}
+//# sourceMappingURL=conflict-log.js.map

package/node_modules/@ocean/services/dist/obsidian/inbox-promotion.js

@@ -0,0 +1,80 @@
+import { access, mkdir, rename } from "node:fs/promises";
+import path from "node:path";
+import { discoverObsidianVault, } from "./vault-discovery.js";
+const roots = ["01-Projects", "02-Areas", "03-Resources", "05-Goals"];
+function suggestion(properties) {
+    if (properties.type === "goal" || properties.domain === "goals")
+        return "05-Goals";
+    if (properties.type === "resource")
+        return "03-Resources";
+    if (properties.type === "project")
+        return "01-Projects";
+    if (properties.domain === "personal")
+        return "02-Areas/Personal";
+    if (properties.domain === "business")
+        return "02-Areas/Business";
+    if (properties.domain === "education")
+        return "02-Areas/Education";
+    return "03-Resources";
+}
+export async function listInboxCandidates(connection) {
+    const discovery = await discoverObsidianVault(connection);
+    const byHash = new Map();
+    for (const note of discovery.notes)
+        if (!byHash.has(note.sha256))
+            byHash.set(note.sha256, note.path);
+    return discovery.notes
+        .filter((note) => note.path === "00-Inbox" || note.path.startsWith("00-Inbox/"))
+        .map((note) => ({
+        path: note.path,
+        bytes: note.bytes,
+        sha256: note.sha256,
+        properties: note.properties,
+        suggestedRoot: suggestion(note.properties),
+        duplicateOf: discovery.notes.find((other) => other.sha256 === note.sha256 && other.path !== note.path)?.path ?? null,
+    }));
+}
+function safePath(root, relative) {
+    if (!relative ||
+        path.isAbsolute(relative) ||
+        relative.split(/[\\/]/).includes(".."))
+        throw new Error("Vault path must be relative and stay inside the configured vault");
+    const resolved = path.resolve(root, relative);
+    if (!resolved.startsWith(`${path.resolve(root)}${path.sep}`))
+        throw new Error("Vault path escapes the configured vault");
+    return resolved;
+}
+export async function promoteInboxNote(connection, source, targetDirectory, apply = false) {
+    if (!source.startsWith("00-Inbox/"))
+        throw new Error("Only notes inside 00-Inbox can be promoted");
+    if (!roots.some((root) => targetDirectory === root || targetDirectory.startsWith(`${root}/`)))
+        throw new Error(`Promotion target must stay under: ${roots.join(", ")}`);
+    const sourceFile = safePath(connection.vaultPath, source);
+    const destinationDirectory = safePath(connection.vaultPath, targetDirectory);
+    const destination = path.join(destinationDirectory, path.basename(sourceFile));
+    await access(sourceFile);
+    if (!apply)
+        return {
+            source,
+            destination: path.relative(connection.vaultPath, destination),
+            applied: false,
+        };
+    if (connection.mode !== "read-write")
+        throw new Error("Obsidian connection is read-only; use an explicit read-write connection before applying promotion");
+    await mkdir(destinationDirectory, { recursive: true });
+    try {
+        await access(destination);
+        throw new Error(`Promotion destination already exists: ${path.relative(connection.vaultPath, destination)}`);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    await rename(sourceFile, destination);
+    return {
+        source,
+        destination: path.relative(connection.vaultPath, destination),
+        applied: true,
+    };
+}
+//# sourceMappingURL=inbox-promotion.js.map

package/node_modules/@ocean/services/dist/obsidian/vault-discovery.js

@@ -0,0 +1,113 @@
+import { createHash } from "node:crypto";
+import { access, mkdir, readdir, readFile, stat, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+const MAX_FILES = 10_000;
+const MAX_BYTES = 50 * 1024 * 1024;
+const connectionPath = () => oceanPath(SYSTEM_DIR, "integrations", "obsidian", "connection.json");
+export async function connectObsidianVault(vaultPath, mode = "read-only", file = connectionPath()) {
+    if (mode !== "read-only" && mode !== "read-write")
+        throw new Error("Obsidian mode must be read-only or read-write");
+    const resolvedVault = path.resolve(vaultPath);
+    const vault = await stat(resolvedVault);
+    if (!vault.isDirectory())
+        throw new Error("Obsidian vaultPath must be a directory");
+    const metadata = await stat(path.join(resolvedVault, ".obsidian"));
+    if (!metadata.isDirectory())
+        throw new Error("Path is not an Obsidian vault: missing .obsidian directory");
+    const connection = {
+        enabled: true,
+        mode,
+        vaultPath: resolvedVault,
+    };
+    const discovery = await discoverObsidianVault(connection);
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, `${JSON.stringify(connection, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    return discovery;
+}
+export async function loadObsidianConnection(file = connectionPath()) {
+    const source = JSON.parse(await readFile(file, "utf8"));
+    if (source.enabled !== true)
+        throw new Error("Obsidian integration is disabled");
+    if (source.mode !== "read-only" && source.mode !== "read-write")
+        throw new Error("Obsidian mode must be read-only or read-write");
+    if (!source.vaultPath || !path.isAbsolute(source.vaultPath))
+        throw new Error("Obsidian vaultPath must be absolute");
+    const connection = {
+        enabled: true,
+        mode: source.mode,
+        vaultPath: source.vaultPath,
+    };
+    await validateObsidianVault(connection);
+    return connection;
+}
+export async function validateObsidianVault(connection) {
+    const vault = await stat(connection.vaultPath);
+    if (!vault.isDirectory())
+        throw new Error("Obsidian vaultPath must be a directory");
+    const metadata = await stat(path.join(connection.vaultPath, ".obsidian"));
+    if (!metadata.isDirectory())
+        throw new Error("Path is not an Obsidian vault: missing .obsidian directory");
+}
+function properties(content) {
+    if (!content.startsWith("---\n"))
+        return {};
+    const end = content.indexOf("\n---", 4);
+    if (end < 0)
+        return {};
+    return Object.fromEntries(content
+        .slice(4, end)
+        .split("\n")
+        .map((line) => line.match(/^([A-Za-z][\w-]*):\s*(.*)$/))
+        .filter((match) => Boolean(match))
+        .map((match) => [match[1], match[2].trim()]));
+}
+async function collect(directory, root, notes, total) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules")
+            continue;
+        const file = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            await collect(file, root, notes, total);
+            continue;
+        }
+        if (!entry.name.endsWith(".md"))
+            continue;
+        if (++total.files > MAX_FILES)
+            throw new Error(`Obsidian vault exceeds ${MAX_FILES} Markdown files`);
+        const content = await readFile(file);
+        total.bytes += content.byteLength;
+        if (total.bytes > MAX_BYTES)
+            throw new Error(`Obsidian vault exceeds ${MAX_BYTES} bytes`);
+        const parsed = properties(content.toString("utf8"));
+        const issues = [];
+        if (!Object.keys(parsed).length)
+            issues.push("missing YAML properties");
+        if (parsed.type === undefined)
+            issues.push("missing property: type");
+        notes.push({
+            path: path.relative(root, file).split(path.sep).join("/"),
+            bytes: content.byteLength,
+            sha256: createHash("sha256").update(content).digest("hex"),
+            properties: parsed,
+            issues,
+        });
+    }
+}
+export async function discoverObsidianVault(connection) {
+    const resolvedConnection = connection ?? (await loadObsidianConnection());
+    await access(resolvedConnection.vaultPath);
+    const notes = [];
+    const total = { files: 0, bytes: 0 };
+    await collect(resolvedConnection.vaultPath, resolvedConnection.vaultPath, notes, total);
+    return {
+        vaultPath: resolvedConnection.vaultPath,
+        noteCount: notes.length,
+        totalBytes: total.bytes,
+        notes,
+        issues: notes.flatMap((note) => note.issues.map((issue) => `${note.path}: ${issue}`)),
+    };
+}
+//# sourceMappingURL=vault-discovery.js.map

package/node_modules/@ocean/services/dist/obsidian/vault-ingestion.js

@@ -0,0 +1,77 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { oceanPath, projectDir, WORKSPACE_PROJECT_ID, } from "@ocean/core/shared/paths.js";
+import { appendConflict, contentHash } from "./conflict-log.js";
+function isInbox(file) {
+    return file === "00-Inbox" || file.startsWith("00-Inbox/");
+}
+function isPromotionArea(file) {
+    return ["02-Areas/", "03-Resources/", "05-Goals/"].some((root) => file.startsWith(root));
+}
+// The workspace project's mirror in the vault: 01-Projects/Ocean(.md|/).
+const PROJECT_MIRRORS = ["Ocean"];
+function projectMirror(file) {
+    for (const name of PROJECT_MIRRORS) {
+        if (file === `01-Projects/${name}.md`)
+            return { relative: "README.md" };
+        const prefix = `01-Projects/${name}/`;
+        if (file.startsWith(prefix))
+            return { relative: file.slice(prefix.length) };
+    }
+    return null;
+}
+async function readOptional(file) {
+    try {
+        return await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+export async function ingestVaultChanges(connection, result, stateFile, baselineState) {
+    const state = stateFile
+        ? JSON.parse(await readFile(stateFile, "utf8"))
+        : { notes: baselineState ?? {} };
+    const baseline = state.notes ?? {};
+    const changed = [...result.added, ...result.changed];
+    const output = {
+        inbox: [],
+        promotionCandidates: [],
+        conflicts: [],
+        removed: [...result.removed],
+    };
+    const seenMirrors = new Set();
+    for (const relative of changed) {
+        if (isInbox(relative)) {
+            output.inbox.push(relative);
+            continue;
+        }
+        if (isPromotionArea(relative)) {
+            output.promotionCandidates.push(relative);
+            continue;
+        }
+        const mirror = projectMirror(relative);
+        if (!mirror)
+            continue;
+        if (seenMirrors.has(mirror.relative))
+            continue;
+        seenMirrors.add(mirror.relative);
+        const vaultContent = await readOptional(path.join(connection.vaultPath, relative));
+        const oceanFile = oceanPath(projectDir(WORKSPACE_PROJECT_ID), mirror.relative);
+        const oceanContent = await readOptional(oceanFile);
+        const record = await appendConflict({
+            path: relative,
+            baselineSha256: baseline[relative]?.sha256 ?? null,
+            vaultSha256: contentHash(vaultContent),
+            oceanSha256: contentHash(oceanContent),
+            vaultContent,
+            oceanContent,
+            source: "vault-ingestion",
+        });
+        output.conflicts.push(record);
+    }
+    return output;
+}
+//# sourceMappingURL=vault-ingestion.js.map

package/node_modules/@ocean/services/dist/obsidian/vault-sync.js

@@ -0,0 +1,73 @@
+import { randomUUID } from "node:crypto";
+import { renameSync, writeFileSync } from "node:fs";
+import { mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+import { discoverObsidianVault, } from "./vault-discovery.js";
+import { ingestVaultChanges, } from "./vault-ingestion.js";
+const defaultStatePath = () => oceanPath(SYSTEM_DIR, "integrations", "obsidian", "sync-state.json");
+async function readState(file) {
+    try {
+        const state = JSON.parse(await readFile(file, "utf8"));
+        return state.notes && typeof state.notes === "object"
+            ? state.notes
+            : state;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+}
+export async function syncObsidianVault(connection, stateFile = defaultStatePath()) {
+    const discovery = await discoverObsidianVault(connection);
+    const previous = await readState(stateFile);
+    const current = Object.fromEntries(discovery.notes.map((note) => [
+        note.path,
+        { sha256: note.sha256, bytes: note.bytes },
+    ]));
+    const added = Object.keys(current).filter((file) => !previous[file]);
+    const changed = Object.keys(current).filter((file) => previous[file] && previous[file]?.sha256 !== current[file]?.sha256);
+    const removed = Object.keys(previous).filter((file) => !current[file]);
+    await mkdir(path.dirname(stateFile), { recursive: true });
+    const temporary = `${stateFile}.tmp-${randomUUID()}`;
+    writeFileSync(temporary, `${JSON.stringify({ version: 1, vaultPath: connection.vaultPath, notes: current }, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    renameSync(temporary, stateFile);
+    const result = { ...discovery, added, changed, removed };
+    return {
+        ...result,
+        ingestion: await ingestVaultChanges(connection, result, undefined, previous),
+    };
+}
+export async function watchObsidianVault(connection, stateFile = defaultStatePath(), signal, debounceMs = 250) {
+    await syncObsidianVault(connection, stateFile);
+    const watcher = (await import("node:fs")).watch(connection.vaultPath, {
+        recursive: true,
+    });
+    let timer;
+    let running = Promise.resolve();
+    const run = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            running = running
+                .then(() => syncObsidianVault(connection, stateFile))
+                .then(() => undefined);
+        }, debounceMs);
+    };
+    watcher.on("change", run);
+    watcher.on("rename", run);
+    await new Promise((resolve) => {
+        const stop = () => {
+            if (timer)
+                clearTimeout(timer);
+            watcher.close();
+            void running.finally(resolve);
+        };
+        if (signal?.aborted)
+            stop();
+        else
+            signal?.addEventListener("abort", stop, { once: true });
+    });
+}
+//# sourceMappingURL=vault-sync.js.map

package/node_modules/@ocean/services/dist/obsidian/vault-writer.js

@@ -0,0 +1,75 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+const MAX_CONTENT_BYTES = 1_000_000;
+export function resolveObsidianNotePath(vaultPath, relative) {
+    if (!relative ||
+        path.isAbsolute(relative) ||
+        relative.split(/[\\/]/).includes("..") ||
+        !relative.endsWith(".md")) {
+        throw new Error("Obsidian write path must be a relative Markdown file inside the vault");
+    }
+    const resolved = path.resolve(vaultPath, relative);
+    if (!resolved.startsWith(`${path.resolve(vaultPath)}${path.sep}`) ||
+        relative.split(/[\\/]/).some((part) => part.startsWith("."))) {
+        throw new Error("Obsidian write path cannot target hidden metadata or escape the vault");
+    }
+    return resolved;
+}
+function hash(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+async function recordConflict(relative, expectedSha256, actualSha256, content, conflictsDirectory = oceanPath(SYSTEM_DIR, "integrations", "obsidian", "conflicts")) {
+    const directory = conflictsDirectory;
+    await mkdir(directory, { recursive: true });
+    const record = path.join(directory, `${new Date().toISOString().replaceAll(/[:.]/g, "-")}-${randomUUID()}.json`);
+    await writeFile(record, `${JSON.stringify({ version: 1, path: relative, expectedSha256, actualSha256, proposedContent: content, createdAt: new Date().toISOString() }, null, 2)}\n`);
+    return record;
+}
+export async function writeObsidianNote(connection, relative, content, expectedSha256 = null, apply = false, conflictsDirectory) {
+    const file = resolveObsidianNotePath(connection.vaultPath, relative);
+    if (Buffer.byteLength(content) > MAX_CONTENT_BYTES)
+        throw new Error(`Obsidian note exceeds ${MAX_CONTENT_BYTES} bytes`);
+    let current = null;
+    try {
+        current = await readFile(file);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const actualSha256 = current ? hash(current) : null;
+    if (current && actualSha256 !== expectedSha256) {
+        const record = await recordConflict(relative, expectedSha256, actualSha256, content, conflictsDirectory);
+        return {
+            applied: false,
+            path: relative,
+            conflict: { record, expectedSha256, actualSha256 },
+        };
+    }
+    if (!current && expectedSha256 !== null) {
+        const record = await recordConflict(relative, expectedSha256, null, content, conflictsDirectory);
+        return {
+            applied: false,
+            path: relative,
+            conflict: { record, expectedSha256, actualSha256: null },
+        };
+    }
+    if (!apply)
+        return { applied: false, path: relative, sha256: hash(content) };
+    if (connection.mode !== "read-write")
+        throw new Error("Obsidian connection is read-only; use an explicit read-write connection before applying a write");
+    await mkdir(path.dirname(file), { recursive: true });
+    const temporary = `${file}.ocean-tmp-${randomUUID()}`;
+    try {
+        await writeFile(temporary, content, { encoding: "utf8", mode: 0o600 });
+        await rename(temporary, file);
+    }
+    catch (error) {
+        await unlink(temporary).catch(() => undefined);
+        throw error;
+    }
+    return { applied: true, path: relative, sha256: hash(content) };
+}
+//# sourceMappingURL=vault-writer.js.map

package/node_modules/@ocean/services/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@ocean/services",
+  "version": "1.2.0",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "./*.js": {
+      "import": "./dist/*.js"
+    }
+  }
+}