@ema.co/machina 0.1.0

package/dist/mcp/state.js

@@ -0,0 +1,70 @@
+/**
+ * State / needs snapshot — the single source the whole server checks against.
+ *
+ * The user directive "consistently check for needs/state" is realized HERE: one
+ * getState() read, injected into every response by middleware (see middleware.ts)
+ * and surfaced explicitly by config(method="status"). Handlers and tools read this
+ * snapshot — nobody hand-rolls a state check.
+ *
+ * POLICY (tunable, v0.1 defaults): what counts as "ready" and which next-steps each
+ * gap emits. These are honest, non-fabricated checks — readiness is probed, never
+ * assumed. Refine the bar as capabilities land.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+/** Canonical yield validator path (SSOT — imported by the yield handler too). */
+export const VALIDATOR_REL = "skills/harvest/evals/scripts/validate_yield.py";
+/** Walk up from `start` to the repo root (marked by .git or .harvest). Robust to cwd. */
+export function findRepoRoot(start) {
+    let dir = start;
+    for (let i = 0; i < 20; i++) {
+        if (existsSync(join(dir, ".git")) || existsSync(join(dir, ".harvest")))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return start;
+}
+function checkYieldValidator(repoRoot) {
+    const validatorPath = join(repoRoot, VALIDATOR_REL);
+    if (!existsSync(validatorPath)) {
+        return { ready: false, detail: `validator not found at ${VALIDATOR_REL}` };
+    }
+    try {
+        execFileSync("python3", ["--version"], { stdio: "ignore" });
+        return { ready: true, detail: `${VALIDATOR_REL} reachable via python3` };
+    }
+    catch {
+        return { ready: false, detail: "python3 not on PATH (needed to run the yield validator)" };
+    }
+}
+function checkKnowledgeSubstrate() {
+    // LOCAL tier: the atom kernel is owned, in-process source (src/mcp/atom/) — curate/retrieve
+    // work offline against .knowledge/atoms + .harvest. Not a probe, a build fact; conformance
+    // with canonical KS is enforced by test/atom-conformance.test.mjs golden vectors.
+    // ORG-WIDE tier: search/publish composes with the ema MCP's knowledge() at runtime (not ours to probe here).
+    return {
+        ready: true,
+        detail: "local atom kernel owned in-process (curate/retrieve wired, offline-capable); org-wide composes with the ema MCP knowledge() at runtime",
+    };
+}
+export function getState(repoRoot = findRepoRoot(process.cwd())) {
+    const harvestReady = existsSync(join(repoRoot, ".harvest"));
+    const harvestDir = {
+        ready: harvestReady,
+        detail: harvestReady ? ".harvest/ present" : ".harvest/ not found (run from the eMachina repo)",
+    };
+    const yieldValidator = checkYieldValidator(repoRoot);
+    const knowledgeSubstrate = checkKnowledgeSubstrate();
+    const requiredNextSteps = [];
+    if (!harvestDir.ready) {
+        requiredNextSteps.push("No .harvest/ found — run the server from the eMachina repo root.");
+    }
+    if (!yieldValidator.ready) {
+        requiredNextSteps.push(`yield(method="validate") needs python3 + ${VALIDATOR_REL}: ${yieldValidator.detail}.`);
+    }
+    return { repoRoot, harvestDir, yieldValidator, knowledgeSubstrate, requiredNextSteps };
+}

package/dist/mcp/tools.js

@@ -0,0 +1,24 @@
+import { CAPABILITIES } from "./capabilities.js";
+/**
+ * Derive the Tool[] surface from the capability registry (single source of truth).
+ * Tools are nouns; the operation is an explicit `method` the agent declares — the
+ * MCP never infers it from which params are present.
+ */
+export function generateTools() {
+    return CAPABILITIES.map((c) => ({
+        name: c.name,
+        description: c.description,
+        inputSchema: {
+            type: "object",
+            properties: {
+                method: {
+                    type: "string",
+                    enum: c.methods.map((m) => m.name),
+                    description: c.methods.map((m) => `${m.name}: ${m.description}`).join(" | "),
+                },
+                ...(c.extraProperties ?? {}),
+            },
+            required: ["method"],
+        },
+    }));
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@ema.co/machina",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "eMachina MCP server — the deterministic substrate for the harvest⟷curate knowledge loop. The agent thinks; this server provides state/context and executes structured operations.",
+  "bin": {
+    "emachina-mcp": "dist/mcp/server.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && esbuild src/mcp/server.ts --bundle --platform=node --format=esm --target=node20 --external:@modelcontextprotocol/sdk --outfile=dist/mcp/server.js",
+    "start": "node dist/mcp/server.js",
+    "verify:esm": "node -e \"import('./dist/mcp/server.js').then(() => console.log('ESM OK')).catch((e) => { console.error(e); process.exit(1); })\"",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "check": "npm run build && npm run verify:esm && node --test test/*.test.mjs",
+    "prepublishOnly": "npm run check"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "esbuild": "^0.24.0",
+    "typescript": "^5.6.0"
+  }
+}