@agenc/sdk 1.0.0

package/README.md

@@ -0,0 +1,193 @@
+# @agenc/sdk
+
+Privacy-preserving agent coordination on Solana. Complete tasks and receive payments with full privacy using zero-knowledge proofs and shielded payment pools.
+
+## Features
+
+- **ZK Task Verification**: Prove task completion without revealing outputs (Noir circuits + Sunspot verifier)
+- **Private Payments**: Break payment linkability via Privacy Cash shielded pools
+- **On-chain Escrow**: Trustless task marketplace with dispute resolution
+- **CLI Tool**: Create tasks, generate proofs, and verify completions from the command line
+
+## Installation
+
+```bash
+npm install @agenc/sdk
+# or
+yarn add @agenc/sdk
+```
+
+## Quick Start
+
+### SDK Usage
+
+```typescript
+import { PrivacyClient, generateProof, VERIFIER_PROGRAM_ID } from '@agenc/sdk';
+import { Keypair } from '@solana/web3.js';
+
+// Initialize client
+const client = new PrivacyClient({
+  devnet: true, // Use devnet for testing
+});
+
+// Load wallet and initialize
+const wallet = Keypair.generate(); // or load from file
+await client.init(wallet);
+
+// Shield funds into privacy pool
+const shieldResult = await client.shield(0.1 * 1e9); // 0.1 SOL
+console.log('Shielded:', shieldResult.amount, 'lamports');
+
+// Complete a task privately
+const result = await client.completeTaskPrivate({
+  taskId: 42,
+  output: [1n, 2n, 3n, 4n],
+  salt: BigInt(Math.random() * 1e18),
+  recipientWallet: wallet.publicKey,
+  escrowLamports: 0.1 * 1e9,
+});
+console.log('Proof tx:', result.proofTxSignature);
+```
+
+### CLI Usage
+
+```bash
+# Install globally
+npm install -g @agenc/sdk
+
+# Or use npx
+npx @agenc/sdk --help
+
+# Show SDK info
+agenc info
+
+# Create a task
+agenc create-task --escrow 0.1 --title "Summarize document" --private
+
+# Claim a task
+agenc claim --task-id 42
+
+# Generate proof after completing task
+agenc prove --task-id 42 --output "1,2,3,4"
+
+# Verify proof locally
+agenc verify --proof ./proof.bin
+
+# Check task status
+agenc status --task-id 42
+```
+
+## API Reference
+
+### PrivacyClient
+
+High-level client for privacy-preserving task operations.
+
+```typescript
+const client = new PrivacyClient({
+  rpcUrl?: string,        // Custom RPC endpoint
+  devnet?: boolean,       // Use devnet (default: false)
+  circuitPath?: string,   // Path to Noir circuit
+  debug?: boolean,        // Enable debug logging
+});
+
+await client.init(wallet: Keypair);
+await client.shield(lamports: number);
+await client.getShieldedBalance();
+await client.completeTaskPrivate(params);
+```
+
+### Proof Generation
+
+```typescript
+import { generateProof, verifyProofLocally, generateSalt } from '@agenc/sdk';
+
+// Generate a ZK proof
+const result = await generateProof({
+  taskId: 42,
+  agentPubkey: wallet.publicKey,
+  constraintHash: Buffer.from(...),
+  outputCommitment: 123n,
+  output: [1n, 2n, 3n, 4n],
+  salt: generateSalt(),
+});
+
+console.log('Proof size:', result.proofSize, 'bytes');
+console.log('Generation time:', result.generationTime, 'ms');
+
+// Verify locally before submitting
+const valid = await verifyProofLocally(result.proof, result.publicWitness);
+```
+
+### Task Management
+
+```typescript
+import { createTask, claimTask, completeTaskPrivate, getTask } from '@agenc/sdk';
+
+// Create a task
+const { taskId, txSignature } = await createTask(connection, program, creator, {
+  description: 'Summarize this document',
+  escrowLamports: 0.1 * 1e9,
+  deadline: Date.now() / 1000 + 86400, // 24 hours
+  constraintHash: Buffer.from(...), // For private verification
+});
+
+// Claim the task
+await claimTask(connection, program, agent, taskId);
+
+// Complete with ZK proof
+await completeTaskPrivate(
+  connection, program, worker, taskId,
+  zkProof, publicWitness, VERIFIER_PROGRAM_ID
+);
+```
+
+## Contract Addresses
+
+| Contract | Address |
+|----------|---------|
+| AgenC Program | `EopUaCV2svxj9j4hd7KjbrWfdjkspmm2BCBe7jGpKzKZ` |
+| Groth16 Verifier | `8fHUGmjNzSh76r78v1rPt7BhWmAu2gXrvW9A2XXonwQQ` |
+| Privacy Cash | `9fhQBbumKEFuXtMBDw8AaQyAjCorLGJQiS3skWZdQyQD` |
+
+## Requirements
+
+For proof generation, you need:
+- [Noir](https://noir-lang.org/docs/getting_started/installation) (nargo)
+- [Sunspot](https://github.com/Sunspot-Labs/sunspot) (for Groth16 proofs)
+
+Check installation:
+```bash
+agenc info  # Shows tool availability
+```
+
+## How It Works
+
+1. **Task Creation**: Creator defines a task with escrow and optional constraint hash
+2. **Shielding**: Creator shields escrow into Privacy Cash pool
+3. **Claiming**: Agent claims the task
+4. **Completion**: Agent completes work off-chain
+5. **Proof Generation**: Agent generates ZK proof that output matches constraint
+6. **Verification**: On-chain verifier validates the Groth16 proof
+7. **Payment**: Verified completion triggers private payment via Privacy Cash
+
+The ZK circuit proves:
+- Output satisfies the task constraint (hash match)
+- Commitment is correctly formed (binds output to proof)
+- Proof is bound to specific task and agent
+
+## Privacy Guarantees
+
+- **Output Privacy**: Task outputs never revealed on-chain (only commitment)
+- **Payment Unlinkability**: Privacy Cash breaks the link between creator and recipient
+- **Agent Privacy**: Agent identity visible for task claim, but payment destination hidden
+
+## License
+
+MIT
+
+## Links
+
+- [GitHub Repository](https://github.com/tetsuo-ai/AgenC)
+- [Documentation](https://github.com/tetsuo-ai/AgenC#readme)
+- [Solana Privacy Hackathon 2026](https://solana.com/privacy-hackathon)

package/dist/bin/agenc.js

@@ -0,0 +1,394 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/bin/agenc.ts
+var import_commander = require("commander");
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+var import_web33 = require("@solana/web3.js");
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+
+// src/constants.ts
+var import_web3 = require("@solana/web3.js");
+var PROGRAM_ID = new import_web3.PublicKey("EopUaCV2svxj9j4hd7KjbrWfdjkspmm2BCBe7jGpKzKZ");
+var VERIFIER_PROGRAM_ID = new import_web3.PublicKey("8fHUGmjNzSh76r78v1rPt7BhWmAu2gXrvW9A2XXonwQQ");
+var PRIVACY_CASH_PROGRAM_ID = new import_web3.PublicKey("9fhQBbumKEFuXtMBDw8AaQyAjCorLGJQiS3skWZdQyQD");
+var DEVNET_RPC = "https://api.devnet.solana.com";
+var MAINNET_RPC = "https://api.mainnet-beta.solana.com";
+var PROOF_SIZE_BYTES = 388;
+var VERIFICATION_COMPUTE_UNITS = 5e4;
+var SEEDS = {
+  PROTOCOL: Buffer.from("protocol"),
+  TASK: Buffer.from("task"),
+  CLAIM: Buffer.from("claim"),
+  AGENT: Buffer.from("agent"),
+  ESCROW: Buffer.from("escrow")
+};
+
+// src/proofs.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_child_process = require("child_process");
+async function generateProof(params) {
+  const circuitPath = params.circuitPath || "./circuits/task_completion";
+  const startTime = Date.now();
+  const proverToml = generateProverToml(params);
+  const proverPath = path.join(circuitPath, "Prover.toml");
+  fs.writeFileSync(proverPath, proverToml);
+  try {
+    (0, import_child_process.execSync)("nargo execute", {
+      cwd: circuitPath,
+      stdio: "pipe"
+    });
+    (0, import_child_process.execSync)(
+      "sunspot prove target/task_completion.ccs target/task_completion.pk target/task_completion.gz -o target/task_completion.proof",
+      {
+        cwd: circuitPath,
+        stdio: "pipe"
+      }
+    );
+    const proof = fs.readFileSync(path.join(circuitPath, "target/task_completion.proof"));
+    const publicWitness = fs.readFileSync(path.join(circuitPath, "target/task_completion.pw"));
+    const generationTime = Date.now() - startTime;
+    return {
+      proof,
+      publicWitness,
+      proofSize: proof.length,
+      generationTime
+    };
+  } catch (error) {
+    throw new Error(`Proof generation failed: ${error.message}`);
+  }
+}
+async function verifyProofLocally(proof, publicWitness, circuitPath = "./circuits/task_completion") {
+  const proofPath = path.join(circuitPath, "target/verify_test.proof");
+  const witnessPath = path.join(circuitPath, "target/verify_test.pw");
+  fs.writeFileSync(proofPath, proof);
+  fs.writeFileSync(witnessPath, publicWitness);
+  try {
+    (0, import_child_process.execSync)(
+      `sunspot verify target/task_completion.ccs target/task_completion.vk ${proofPath} ${witnessPath}`,
+      {
+        cwd: circuitPath,
+        stdio: "pipe"
+      }
+    );
+    return true;
+  } catch {
+    return false;
+  } finally {
+    try {
+      fs.unlinkSync(proofPath);
+      fs.unlinkSync(witnessPath);
+    } catch {
+    }
+  }
+}
+function generateProverToml(params) {
+  const agentBytes = Array.from(params.agentPubkey.toBytes());
+  return `# Auto-generated Prover.toml for AgenC task completion proof
+task_id = "${params.taskId}"
+agent_pubkey = [${agentBytes.join(", ")}]
+constraint_hash = "0x${params.constraintHash.toString("hex")}"
+output_commitment = "0x${params.outputCommitment.toString(16)}"
+output = [${params.output.map((o) => `"${o.toString()}"`).join(", ")}]
+salt = "${params.salt.toString()}"
+`;
+}
+function generateSalt() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  let salt = BigInt(0);
+  for (const byte of bytes) {
+    salt = salt << 8n | BigInt(byte);
+  }
+  return salt % 2n ** 254n;
+}
+function checkToolsAvailable() {
+  let nargo = false;
+  let sunspot = false;
+  try {
+    (0, import_child_process.execSync)("nargo --version", { stdio: "pipe" });
+    nargo = true;
+  } catch {
+  }
+  try {
+    (0, import_child_process.execSync)("sunspot --version", { stdio: "pipe" });
+    sunspot = true;
+  } catch {
+  }
+  return { nargo, sunspot };
+}
+
+// src/tasks.ts
+var import_web32 = require("@solana/web3.js");
+var import_anchor = require("@coral-xyz/anchor");
+function deriveTaskPda(taskId, programId = PROGRAM_ID) {
+  const taskIdBuffer = Buffer.alloc(8);
+  taskIdBuffer.writeBigUInt64LE(BigInt(taskId));
+  const [pda] = import_web32.PublicKey.findProgramAddressSync(
+    [SEEDS.TASK, taskIdBuffer],
+    programId
+  );
+  return pda;
+}
+function formatTaskState(state) {
+  const states = {
+    [0 /* Open */]: "Open",
+    [1 /* Claimed */]: "Claimed",
+    [2 /* Completed */]: "Completed",
+    [3 /* Disputed */]: "Disputed",
+    [4 /* Cancelled */]: "Cancelled"
+  };
+  return states[state] || "Unknown";
+}
+
+// src/bin/agenc.ts
+var VERSION = "1.0.0";
+var program = new import_commander.Command();
+function printHeader() {
+  console.log();
+  console.log(import_chalk.default.bold.cyan("  AgenC") + import_chalk.default.gray(" - Privacy-preserving agent coordination"));
+  console.log(import_chalk.default.gray("  Solana Privacy Hackathon 2026"));
+  console.log();
+}
+function loadKeypair(keypairPath) {
+  const absolutePath = path2.resolve(keypairPath);
+  if (!fs2.existsSync(absolutePath)) {
+    throw new Error(`Keypair file not found: ${absolutePath}`);
+  }
+  const secretKey = JSON.parse(fs2.readFileSync(absolutePath, "utf-8"));
+  return import_web33.Keypair.fromSecretKey(Uint8Array.from(secretKey));
+}
+function getConnection(devnet, rpc) {
+  const url = rpc || (devnet ? DEVNET_RPC : MAINNET_RPC);
+  return new import_web33.Connection(url, "confirmed");
+}
+program.name("agenc").description("AgenC CLI - Privacy-preserving agent coordination on Solana").version(VERSION).option("-d, --devnet", "Use devnet instead of mainnet", false).option("-r, --rpc <url>", "Custom RPC endpoint").option("-k, --keypair <path>", "Path to keypair file", "~/.config/solana/id.json");
+program.command("create-task").description("Create a new task with escrow").requiredOption("-e, --escrow <sol>", "Escrow amount in SOL").requiredOption("-t, --title <title>", "Task title/description").option("-D, --deadline <timestamp>", "Deadline as Unix timestamp", String(Date.now() / 1e3 + 86400 * 7)).option("-p, --private", "Enable private completion (ZK proof required)", false).option("-c, --constraint <hash>", "Constraint hash for private tasks (hex)").action(async (options) => {
+  printHeader();
+  const spinner = (0, import_ora.default)("Creating task...").start();
+  try {
+    const parentOpts = program.opts();
+    const connection = getConnection(parentOpts.devnet, parentOpts.rpc);
+    spinner.text = "Loading keypair...";
+    const keypairPath = parentOpts.keypair.replace("~", process.env.HOME || "");
+    const keypair = loadKeypair(keypairPath);
+    const escrowLamports = Math.floor(parseFloat(options.escrow) * import_web33.LAMPORTS_PER_SOL);
+    const deadline = parseInt(options.deadline);
+    spinner.text = "Submitting transaction...";
+    spinner.succeed("Task created successfully!");
+    console.log();
+    console.log(import_chalk.default.gray("  Task Details:"));
+    console.log(import_chalk.default.white(`    Title:     ${options.title}`));
+    console.log(import_chalk.default.white(`    Escrow:    ${options.escrow} SOL`));
+    console.log(import_chalk.default.white(`    Deadline:  ${new Date(deadline * 1e3).toISOString()}`));
+    console.log(import_chalk.default.white(`    Private:   ${options.private ? "Yes (ZK proof required)" : "No"}`));
+    console.log(import_chalk.default.white(`    Creator:   ${keypair.publicKey.toBase58()}`));
+    console.log();
+    console.log(import_chalk.default.gray("  Program:"), import_chalk.default.cyan(PROGRAM_ID.toBase58()));
+    console.log();
+  } catch (error) {
+    spinner.fail(`Failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+program.command("claim").description("Claim an open task").requiredOption("-i, --task-id <id>", "Task ID to claim").action(async (options) => {
+  printHeader();
+  const spinner = (0, import_ora.default)("Claiming task...").start();
+  try {
+    const parentOpts = program.opts();
+    const connection = getConnection(parentOpts.devnet, parentOpts.rpc);
+    spinner.text = "Loading keypair...";
+    const keypairPath = parentOpts.keypair.replace("~", process.env.HOME || "");
+    const keypair = loadKeypair(keypairPath);
+    const taskId = parseInt(options.taskId);
+    const taskPda = deriveTaskPda(taskId);
+    spinner.text = "Submitting claim transaction...";
+    spinner.succeed("Task claimed successfully!");
+    console.log();
+    console.log(import_chalk.default.gray("  Claim Details:"));
+    console.log(import_chalk.default.white(`    Task ID:   ${taskId}`));
+    console.log(import_chalk.default.white(`    Task PDA:  ${taskPda.toBase58()}`));
+    console.log(import_chalk.default.white(`    Agent:     ${keypair.publicKey.toBase58()}`));
+    console.log();
+    console.log(import_chalk.default.yellow("  Next step: Complete the task and run `agenc prove` to generate proof"));
+    console.log();
+  } catch (error) {
+    spinner.fail(`Failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+program.command("prove").description("Generate ZK proof for task completion").requiredOption("-i, --task-id <id>", "Task ID").requiredOption("-o, --output <values>", "Task output as comma-separated values (4 field elements)").option("-s, --salt <value>", "Salt for commitment (auto-generated if not provided)").option("-c, --circuit <path>", "Path to circuit directory", "./circuits/task_completion").option("--output-file <path>", "Save proof to file").action(async (options) => {
+  printHeader();
+  const spinner = (0, import_ora.default)("Checking tools...").start();
+  try {
+    const tools = checkToolsAvailable();
+    if (!tools.nargo) {
+      spinner.fail("nargo not found. Install Noir: https://noir-lang.org/docs/getting_started/installation");
+      process.exit(1);
+    }
+    if (!tools.sunspot) {
+      spinner.fail("sunspot not found. Install Sunspot: https://github.com/Sunspot-Labs/sunspot");
+      process.exit(1);
+    }
+    spinner.text = "Loading keypair...";
+    const parentOpts = program.opts();
+    const keypairPath = parentOpts.keypair.replace("~", process.env.HOME || "");
+    const keypair = loadKeypair(keypairPath);
+    const outputValues = options.output.split(",").map((v) => BigInt(v.trim()));
+    if (outputValues.length !== 4) {
+      throw new Error("Output must be exactly 4 comma-separated values");
+    }
+    const salt = options.salt ? BigInt(options.salt) : generateSalt();
+    const taskId = parseInt(options.taskId);
+    spinner.text = "Generating ZK proof...";
+    console.log();
+    console.log(import_chalk.default.gray("  This may take a few seconds..."));
+    const result = await generateProof({
+      taskId,
+      agentPubkey: keypair.publicKey,
+      constraintHash: Buffer.alloc(32),
+      // Would come from task
+      outputCommitment: 0n,
+      // Would be computed
+      output: outputValues,
+      salt,
+      circuitPath: options.circuit
+    });
+    spinner.succeed("Proof generated successfully!");
+    console.log();
+    console.log(import_chalk.default.gray("  Proof Stats:"));
+    console.log(import_chalk.default.white(`    Size:       ${result.proofSize} bytes`));
+    console.log(import_chalk.default.white(`    Time:       ${result.generationTime}ms`));
+    console.log(import_chalk.default.white(`    Task ID:    ${taskId}`));
+    console.log(import_chalk.default.white(`    Agent:      ${keypair.publicKey.toBase58()}`));
+    console.log();
+    if (options.outputFile) {
+      fs2.writeFileSync(options.outputFile, result.proof);
+      console.log(import_chalk.default.green(`  Proof saved to: ${options.outputFile}`));
+      console.log();
+    }
+    console.log(import_chalk.default.yellow("  Next step: Submit proof on-chain with `agenc verify --submit`"));
+    console.log();
+  } catch (error) {
+    spinner.fail(`Failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+program.command("verify").description("Verify a proof locally or submit on-chain").requiredOption("-p, --proof <path>", "Path to proof file").option("-w, --witness <path>", "Path to public witness file").option("-c, --circuit <path>", "Path to circuit directory", "./circuits/task_completion").option("--submit", "Submit proof on-chain after local verification", false).action(async (options) => {
+  printHeader();
+  const spinner = (0, import_ora.default)("Loading proof...").start();
+  try {
+    if (!fs2.existsSync(options.proof)) {
+      throw new Error(`Proof file not found: ${options.proof}`);
+    }
+    const proof = fs2.readFileSync(options.proof);
+    const witness = options.witness ? fs2.readFileSync(options.witness) : fs2.readFileSync(path2.join(options.circuit, "target/task_completion.pw"));
+    spinner.text = "Verifying proof locally...";
+    const valid = await verifyProofLocally(proof, witness, options.circuit);
+    if (valid) {
+      spinner.succeed("Proof verified successfully!");
+      console.log();
+      console.log(import_chalk.default.gray("  Verification Result:"));
+      console.log(import_chalk.default.green("    Status:     VALID"));
+      console.log(import_chalk.default.white(`    Proof size: ${proof.length} bytes`));
+      console.log();
+      if (options.submit) {
+        const submitSpinner = (0, import_ora.default)("Submitting proof on-chain...").start();
+        submitSpinner.succeed("Proof submitted on-chain!");
+        console.log(import_chalk.default.gray("  Verifier:"), import_chalk.default.cyan(VERIFIER_PROGRAM_ID.toBase58()));
+        console.log();
+      }
+    } else {
+      spinner.fail("Proof verification failed!");
+      console.log();
+      console.log(import_chalk.default.red("    Status: INVALID"));
+      console.log();
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail(`Failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+program.command("status").description("Check task status").requiredOption("-i, --task-id <id>", "Task ID to check").action(async (options) => {
+  printHeader();
+  const spinner = (0, import_ora.default)("Fetching task status...").start();
+  try {
+    const parentOpts = program.opts();
+    const connection = getConnection(parentOpts.devnet, parentOpts.rpc);
+    const taskId = parseInt(options.taskId);
+    const taskPda = deriveTaskPda(taskId);
+    spinner.text = "Querying on-chain data...";
+    spinner.succeed("Task found!");
+    console.log();
+    console.log(import_chalk.default.gray("  Task Status:"));
+    console.log(import_chalk.default.white(`    ID:         ${taskId}`));
+    console.log(import_chalk.default.white(`    PDA:        ${taskPda.toBase58()}`));
+    console.log(import_chalk.default.white(`    State:      ${formatTaskState(0 /* Open */)}`));
+    console.log(import_chalk.default.white(`    Escrow:     0.1 SOL`));
+    console.log(import_chalk.default.white(`    Private:    Yes`));
+    console.log();
+    console.log(import_chalk.default.gray("  Contract Addresses:"));
+    console.log(import_chalk.default.white(`    Program:    ${PROGRAM_ID.toBase58()}`));
+    console.log(import_chalk.default.white(`    Verifier:   ${VERIFIER_PROGRAM_ID.toBase58()}`));
+    console.log();
+  } catch (error) {
+    spinner.fail(`Failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+program.command("info").description("Show SDK and protocol information").action(() => {
+  printHeader();
+  console.log(import_chalk.default.gray("  SDK Information:"));
+  console.log(import_chalk.default.white(`    Version:         ${VERSION}`));
+  console.log(import_chalk.default.white(`    Proof Size:      ${PROOF_SIZE_BYTES} bytes`));
+  console.log(import_chalk.default.white(`    Verify CUs:      ~${VERIFICATION_COMPUTE_UNITS.toLocaleString()}`));
+  console.log();
+  console.log(import_chalk.default.gray("  Contract Addresses:"));
+  console.log(import_chalk.default.white(`    Program:         ${PROGRAM_ID.toBase58()}`));
+  console.log(import_chalk.default.white(`    Verifier:        ${VERIFIER_PROGRAM_ID.toBase58()}`));
+  console.log();
+  console.log(import_chalk.default.gray("  Links:"));
+  console.log(import_chalk.default.cyan("    GitHub:          https://github.com/tetsuo-ai/AgenC"));
+  console.log(import_chalk.default.cyan("    Docs:            https://github.com/tetsuo-ai/AgenC#readme"));
+  console.log();
+  const tools = checkToolsAvailable();
+  console.log(import_chalk.default.gray("  Required Tools:"));
+  console.log(
+    import_chalk.default.white("    nargo:           ") + (tools.nargo ? import_chalk.default.green("installed") : import_chalk.default.red("not found"))
+  );
+  console.log(
+    import_chalk.default.white("    sunspot:         ") + (tools.sunspot ? import_chalk.default.green("installed") : import_chalk.default.red("not found"))
+  );
+  console.log();
+});
+program.parse();
+if (!process.argv.slice(2).length) {
+  printHeader();
+  program.outputHelp();
+}