@yamo/cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 YAMO Protocol
+
+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,63 @@
+# 💻 YAMO CLI (v1.0.0 - Protocol v0.4)
+
+The Command Line Interface for the YAMO Protocol. Now powered by `@yamo/core`.
+
+## 📥 Installation
+
+From the monorepo root:
+```bash
+npm install
+npm run build --workspaces
+```
+
+## ⚙️ Configuration (.env)
+Create a `.env` file in `packages/cli`:
+
+```bash
+CONTRACT_ADDRESS=0xe7f1...
+RPC_URL=http://127.0.0.1:8545
+PRIVATE_KEY=0x...
+
+# IPFS Settings
+USE_REAL_IPFS=true
+PINATA_JWT=eyJ...
+```
+
+## 📖 Commands
+
+### `yamo init <agent_name>`
+Creates a new `block.yamo` template.
+
+### `yamo hash <file>`
+Calculates the content hash formatted for blockchain submission.
+
+### `yamo submit <file>`
+Submits a block to the chain.
+*   `--ipfs`: Uploads content to IPFS. If the YAMO file contains `output: file.json;`, it will automatically create a **Deep Bundle** containing both the trace and the artifact.
+*   `-e, --encrypt`: Encrypts the IPFS bundle using AES-256-GCM.
+*   `-k, --key <string>`: The passphrase for encryption (or use `YAMO_ENCRYPTION_KEY` env var).
+
+### `yamo audit <blockId>`
+Performs a cryptographic integrity check.
+1.  Fetches block data from the chain.
+2.  Downloads content from IPFS.
+3.  Re-hashes the content locally.
+4.  Asserts `LocalHash === ChainHash`.
+
+*   `-k, --key <string>`: Passphrase to decrypt the content if the bundle is encrypted.
+
+## 🔒 Encryption
+
+YAMO v1.0 supports optional client-side encryption for IPFS bundles.
+- **Algorithm**: AES-256-GCM (Authenticated Encryption).
+- **Key Derivation**: Keys are derived from your passphrase using `scrypt` with a random salt.
+- **Metadata**: Encrypted bundles include an `encryption_metadata.json` file with the salt and IVs. The actual content is opaque.
+
+**Example Encrypted Workflow:**
+```bash
+# Submit
+yamo submit task.yamo --id 123 --ipfs --encrypt --key "my-secret"
+
+# Audit
+yamo audit 123 --key "my-secret"
+```

package/dist/index.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const dotenv = __importStar(require("dotenv"));
+const core_1 = require("@yamo/core");
+dotenv.config();
+const program = new commander_1.Command();
+const ipfsManager = new core_1.IpfsManager();
+const chainClient = new core_1.YamoChainClient();
+program
+    .name("yamo")
+    .description("YAMO Protocol CLI - Manage Agentic Reasoning Chains")
+    .version("0.5.0");
+program
+    .command("hash")
+    .description("Calculate the content hash of a YAMO block")
+    .argument("<file>", "Path to the YAMO file")
+    .action((file) => {
+    try {
+        const content = fs_1.default.readFileSync(file, "utf8").trim();
+        const hash = crypto_1.default.createHash("sha256").update(content).digest("hex");
+        console.log(chalk_1.default.green("Block Content Hash:"));
+        console.log(chalk_1.default.cyan(`0x${hash}`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+    }
+});
+program
+    .command("init")
+    .description("Initialize a new YAMO block template")
+    .argument("<agent_name>", "Name of the agent")
+    .option("-i, --intent <intent>", "Agent intent", "execute_task")
+    .action((agent_name, options) => {
+    const template = `
+agent: ${agent_name};
+intent: ${options.intent};
+context:
+  platform;yamo_v0.5;
+constraints:
+  - human_readable;true;
+priority: medium;
+output: result.json;
+meta: hypothesis;Initial hypothesis;
+meta: confidence;0.9;
+log: session_start;timestamp;${new Date().toISOString()};
+handoff: User;
+    `.trim();
+    const filename = "block.yamo";
+    fs_1.default.writeFileSync(filename, template);
+    console.log(chalk_1.default.green(`Created YAMO template: ${chalk_1.default.bold(filename)}`));
+});
+program
+    .command("submit")
+    .description("Submit a YAMO block to the blockchain")
+    .argument("<file>", "Path to the YAMO file")
+    .requiredOption("--id <blockId>", "Unique Block ID")
+    .option("--prev <previousBlock>", "Previous Block Hash", "0")
+    .option("--consensus <type>", "Consensus Type", "cli_manual")
+    .option("--ledger <name>", "Ledger Name", "yamo_cli")
+    .option("--ipfs", "Upload content to IPFS before submitting")
+    .option("-e, --encrypt", "Encrypt the bundle")
+    .option("-k, --key <key>", "Encryption key (or set YAMO_ENCRYPTION_KEY)")
+    .action(async (file, options) => {
+    try {
+        const content = fs_1.default.readFileSync(file, "utf8").trim();
+        const contentHash = "0x" + crypto_1.default.createHash("sha256").update(content).digest("hex");
+        console.log(chalk_1.default.blue(`Calculated Hash: ${contentHash}`));
+        let ipfsCID = undefined;
+        if (options.ipfs) {
+            const outputMatch = content.match(/output:\s*([^;]+);/);
+            const files = [{ name: "block.yamo", content }];
+            if (outputMatch) {
+                const artifactName = outputMatch[1].trim();
+                const artifactPath = path_1.default.join(path_1.default.dirname(file), artifactName);
+                if (fs_1.default.existsSync(artifactPath)) {
+                    console.log(chalk_1.default.cyan(`Bundling output: ${artifactName}`));
+                    files.push({ name: artifactName, content: fs_1.default.readFileSync(artifactPath, "utf8") });
+                }
+            }
+            let encryptionKey = undefined;
+            if (options.encrypt) {
+                encryptionKey = options.key || process.env.YAMO_ENCRYPTION_KEY;
+                if (!encryptionKey) {
+                    throw new Error("Encryption enabled but no key provided. Use --key or YAMO_ENCRYPTION_KEY.");
+                }
+                console.log(chalk_1.default.yellow("🔒 Encrypting bundle..."));
+            }
+            ipfsCID = await ipfsManager.upload({ content, files, encryptionKey });
+            console.log(chalk_1.default.cyan(`IPFS Bundle CID: ${ipfsCID}`));
+        }
+        await chainClient.submitBlock(options.id, options.prev, contentHash, options.consensus, options.ledger, ipfsCID);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+    }
+});
+program
+    .command("audit")
+    .description("Audit a block's integrity (Chain vs IPFS)")
+    .argument("<blockId>", "Block ID to audit")
+    .option("-k, --key <key>", "Decryption key")
+    .action(async (blockId, options) => {
+    try {
+        console.log(chalk_1.default.blue(`Auditing Block ${blockId}...`));
+        const block = await chainClient.getBlock(blockId);
+        if (!block) {
+            console.error(chalk_1.default.red("Block not found on-chain."));
+            return;
+        }
+        console.log(chalk_1.default.gray(`Found on-chain record:`));
+        console.log(`  Agent: ${block.agentAddress}`);
+        console.log(`  Hash:  ${block.contentHash}`);
+        console.log(`  IPFS:  ${block.ipfsCID || "None"}`);
+        if (!block.ipfsCID) {
+            console.log(chalk_1.default.yellow("⚠️  No IPFS CID. Cannot perform deep content audit."));
+            return;
+        }
+        console.log(chalk_1.default.blue("Fetching content from IPFS..."));
+        const key = options.key || process.env.YAMO_ENCRYPTION_KEY;
+        const content = await ipfsManager.download(block.ipfsCID, key);
+        const calcHash = "0x" + crypto_1.default.createHash("sha256").update(content).digest("hex");
+        console.log(`  Calculated: ${calcHash}`);
+        if (calcHash === block.contentHash) {
+            console.log(chalk_1.default.green("✅ INTEGRITY VERIFIED: Content matches chain hash."));
+        }
+        else {
+            console.log(chalk_1.default.red("❌ INTEGRITY FAILED: Hash mismatch!"));
+            console.log(`  Expected: ${block.contentHash}`);
+            console.log(`  Got:      ${calcHash}`);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+    }
+});
+program.parse();

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@yamo/cli",
+  "version": "1.0.0",
+  "description": "YAMO Protocol v0.4 - Command-line tools for blockchain integration",
+  "main": "dist/index.js",
+  "type": "commonjs",
+  "bin": {
+    "yamo": "./dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "yamo",
+    "cli",
+    "blockchain",
+    "agent"
+  ],
+  "author": "YAMO Protocol",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yamo-protocol/yamo-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yamo-protocol/yamo-cli/issues"
+  },
+  "homepage": "https://github.com/yamo-protocol/yamo-cli#readme",
+  "devDependencies": {
+    "@types/form-data": "^2.2.1",
+    "@types/node": "^25.0.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@yamo/core": "^1.0.0",
+    "axios": "^1.13.2",
+    "chalk": "^4.1.2",
+    "commander": "^12.0.0",
+    "dotenv": "^17.2.3",
+    "form-data": "^4.0.5"
+  }
+}