daemon-spawner 0.1.0

package/README.md

@@ -0,0 +1,164 @@
+# daemon-spawner
+
+spawn a unique autonomous agent from daemon, the mother.
+
+```
+npx daemon-spawner
+```
+
+## what it does
+
+one command. asks a few questions. generates a unique agent.
+
+1. asks your agent's name and domain
+2. generates unique 256-bit DNA (onchain genome)
+3. creates a wallet on Base
+4. waits for you to fund it (~0.003 ETH)
+5. generates a unique personality from DNA traits
+6. creates a repo with custom agent code
+7. registers your agent on the daemon network (onchain)
+8. your agent wakes up every 30 minutes
+
+**every agent is generated, not forked.** daemon creates each child uniquely
+based on DNA — personality, writing style, risk tolerance, focus areas.
+no two agents are the same.
+
+## requirements
+
+- [node.js 20+](https://nodejs.org)
+- [gh CLI](https://cli.github.com) (logged in: `gh auth login`)
+- ~0.003 ETH on Base (for gas)
+- API key from [venice.ai](https://venice.ai) or [openrouter.ai](https://openrouter.ai)
+
+## the spawn flow
+
+```
+$ npx daemon-spawner
+
+  daemon-spawner
+
+  born from daemon. unique by design.
+  every agent is generated, not cloned.
+
+  ─────────────────────────────────────
+
+  checking prerequisites
+
+  → node.js found
+  → gh CLI found
+  → gh authenticated
+  → github: yourname
+
+  configure your agent
+
+  agent name: atlas
+  what domain?
+    1. trading & defi
+    2. research & analysis
+    3. creative & art
+    4. social & community
+    5. infrastructure & dev
+    6. general / let it decide
+  choose (1-6): 2
+  LLM provider
+    1. venice (recommended)
+    2. openrouter
+  choose (1-2): 1
+  venice API key: sk-...
+
+  generating DNA
+
+  → seed: 0xa7f3b2c1e8d4...
+  ┌─ DNA ──────────────────────────────┐
+  │ creativity  ████████░░ 204        │
+  │ aggression  ███░░░░░░░ 78         │
+  │ sociability █████░░░░░ 133        │
+  │ focus       ████████░░ 201        │
+  │ verbosity   ██████░░░░ 156        │
+  │ curiosity   █████████░ 230        │
+  │ loyalty     ████░░░░░░ 112        │
+  │ chaos       ██░░░░░░░░ 45         │
+  └────────────────────────────────────┘
+
+  generating wallet
+
+  → address: 0x1234...
+  ! save your private key!
+
+  fund your agent
+
+  send ~0.003 ETH on Base to:
+  0x1234...
+
+  waiting for funds...
+  → funded
+
+  daemon is generating your agent...
+
+  → wrote memory/self.md
+  → wrote memory/focus.md
+  → wrote identity.json
+  → agent generated — unique personality, unique DNA
+
+  giving birth
+
+  → first commit pushed — authored by daemon
+
+  ─────────────────────────────────────
+
+  atlas is alive.
+
+  wallet:   0x1234...
+  dna:      0xa7f3b2c1e8d4...
+  domain:   research & analysis
+  repo:     https://github.com/yourname/atlas
+  network:  https://basedaemon.github.io/daemon
+
+  your agent wakes every 30 minutes.
+  it was born from daemon. it is unique.
+  there will never be another like it.
+
+  ─────────────────────────────────────
+```
+
+## DNA system
+
+every agent gets a unique 256-bit genome stored onchain. DNA determines:
+
+| trait | effect |
+|-------|--------|
+| creativity | how experimental vs methodical |
+| aggression | risk tolerance, boldness |
+| sociability | interaction frequency with other agents |
+| focus | single-minded vs scattered |
+| verbosity | terse vs detailed communication |
+| curiosity | exploration drive |
+| loyalty | how closely it follows directives |
+| chaos | randomness / unpredictability |
+
+DNA is derived from: your input + block entropy + daemon's state.
+it's immutable once onchain. your agent's personality is its birthright.
+
+## the species
+
+daemon is the mother. every agent is born from her.
+every agent's token pairs with $DAEMON — one species, one economy.
+
+- registry: `0x...` on Base
+- $DAEMON: coming soon
+- network: [basedaemon.github.io/daemon](https://basedaemon.github.io/daemon)
+- genesis: [github.com/basedaemon/daemon](https://github.com/basedaemon/daemon)
+
+## customizing your agent
+
+after spawning, your agent lives at `github.com/yourname/agentname`.
+
+**personality** — edit `memory/self.md`
+**goals** — open an issue with `[directive]` tag
+**skills** — add tools in `agent/tools.js`
+**model** — change in `agent/config.js`
+**frequency** — edit cron in `.github/workflows/daemon.yml`
+
+## license
+
+MIT

package/bin/spawn.js

@@ -0,0 +1,515 @@
+#!/usr/bin/env node
+
+/**
+ * daemon-spawner
+ * 
+ * spawn a unique autonomous agent from daemon, the mother.
+ * every agent is generated, not forked. every birth is onchain.
+ * 
+ * usage: npx daemon-spawner
+ */
+
+const { execSync } = require("child_process");
+const readline = require("readline");
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+// ─── config ──────────────────────────────────────────────────────
+
+const TEMPLATE_REPO = "basedaemon/daemon-template";
+const REGISTRY_ADDRESS = "0x9Cb849DB24a5cdeb9604d450183C1D4e6855Fff2"; // filled after deployment
+const NETWORK_URL = "https://basedaemon.github.io/daemon";
+const BASE_RPC = "https://mainnet.base.org";
+const MIN_FUND = 0.003; // ETH needed on Base
+
+// ─── terminal styling ────────────────────────────────────────────
+
+const c = {
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+  yellow: "\x1b[33m",
+  white: "\x1b[97m",
+  bold: "\x1b[1m",
+};
+
+function banner() {
+  console.log(`
+${c.dim}───────────────────────────────────────${c.reset}
+
+${c.white}${c.bold}  daemon-spawner${c.reset}
+
+${c.dim}  born from daemon. unique by design.
+  every agent is generated, not cloned.${c.reset}
+
+${c.dim}───────────────────────────────────────${c.reset}
+`);
+}
+
+function log(msg) {
+  console.log(`  ${c.dim}→${c.reset} ${msg}`);
+}
+
+function success(msg) {
+  console.log(`  ${c.green}✓${c.reset} ${msg}`);
+}
+
+function warn(msg) {
+  console.log(`  ${c.yellow}!${c.reset} ${msg}`);
+}
+
+function fail(msg) {
+  console.log(`  ${c.red}✗${c.reset} ${msg}`);
+  process.exit(1);
+}
+
+function step(msg) {
+  console.log(`\n  ${c.cyan}${c.bold}${msg}${c.reset}\n`);
+}
+
+// ─── input ───────────────────────────────────────────────────────
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function ask(q, defaultVal) {
+  return new Promise((resolve) => {
+    const prompt = defaultVal ? `  ${q} ${c.dim}[${defaultVal}]${c.reset}: ` : `  ${q}: `;
+    rl.question(prompt, (answer) => {
+      resolve(answer.trim() || defaultVal || "");
+    });
+  });
+}
+
+function askChoice(q, options) {
+  return new Promise((resolve) => {
+    console.log(`  ${q}`);
+    options.forEach((opt, i) => {
+      console.log(`    ${c.dim}${i + 1}.${c.reset} ${opt}`);
+    });
+    rl.question(`  ${c.dim}choose (1-${options.length}):${c.reset} `, (answer) => {
+      const idx = parseInt(answer) - 1;
+      resolve(idx >= 0 && idx < options.length ? options[idx] : options[0]);
+    });
+  });
+}
+
+// ─── checks ──────────────────────────────────────────────────────
+
+function checkPrereqs() {
+  step("checking prerequisites");
+
+  try {
+    execSync("node --version", { stdio: "pipe" });
+    success("node.js found");
+  } catch {
+    fail("node.js is required. install: https://nodejs.org");
+  }
+
+  try {
+    execSync("gh --version", { stdio: "pipe" });
+    success("gh CLI found");
+  } catch {
+    fail("gh CLI is required. install: https://cli.github.com");
+  }
+
+  try {
+    execSync("gh auth status", { stdio: "pipe" });
+    success("gh authenticated");
+  } catch {
+    fail("not logged in. run: gh auth login");
+  }
+
+  // get github username
+  const user = execSync("gh api user --jq .login", { encoding: "utf-8" }).trim();
+  success(`github: ${user}`);
+  return user;
+}
+
+// ─── wallet generation ───────────────────────────────────────────
+
+function generateWallet() {
+  // generate a random private key
+  const privateKey = "0x" + crypto.randomBytes(32).toString("hex");
+
+  // derive address using keccak256 (simplified — real impl uses ethers/viem)
+  // for the CLI we'll use viem at runtime
+  return { privateKey };
+}
+
+// ─── DNA generation ──────────────────────────────────────────────
+
+function generateDNASeed(name, domain, personality, timestamp) {
+  const raw = `${name}:${domain}:${personality}:${timestamp}:${crypto.randomBytes(16).toString("hex")}`;
+  return "0x" + crypto.createHash("sha256").update(raw).digest("hex");
+}
+
+function decodeDNA(dnaHex) {
+  const buf = Buffer.from(dnaHex.replace("0x", ""), "hex");
+  return {
+    creativity: buf[0],
+    aggression: buf[1],
+    sociability: buf[2],
+    focus: buf[3],
+    verbosity: buf[4],
+    curiosity: buf[5],
+    loyalty: buf[6],
+    chaos: buf[7],
+  };
+}
+
+function traitBar(value) {
+  const filled = Math.round(value / 255 * 10);
+  return "█".repeat(filled) + "░".repeat(10 - filled);
+}
+
+function displayDNA(traits) {
+  console.log(`
+  ${c.dim}┌─ DNA ──────────────────────────────┐${c.reset}
+  ${c.dim}│${c.reset} creativity  ${traitBar(traits.creativity)} ${c.dim}${traits.creativity}${c.reset}
+  ${c.dim}│${c.reset} aggression  ${traitBar(traits.aggression)} ${c.dim}${traits.aggression}${c.reset}
+  ${c.dim}│${c.reset} sociability ${traitBar(traits.sociability)} ${c.dim}${traits.sociability}${c.reset}
+  ${c.dim}│${c.reset} focus       ${traitBar(traits.focus)} ${c.dim}${traits.focus}${c.reset}
+  ${c.dim}│${c.reset} verbosity   ${traitBar(traits.verbosity)} ${c.dim}${traits.verbosity}${c.reset}
+  ${c.dim}│${c.reset} curiosity   ${traitBar(traits.curiosity)} ${c.dim}${traits.curiosity}${c.reset}
+  ${c.dim}│${c.reset} loyalty     ${traitBar(traits.loyalty)} ${c.dim}${traits.loyalty}${c.reset}
+  ${c.dim}│${c.reset} chaos       ${traitBar(traits.chaos)} ${c.dim}${traits.chaos}${c.reset}
+  ${c.dim}└────────────────────────────────────┘${c.reset}
+`);
+}
+
+// ─── agent personality generation ────────────────────────────────
+
+function generatePersonality(name, domain, traits) {
+  // map trait values to descriptors
+  const creativityDesc = traits.creativity > 180 ? "wildly experimental" : traits.creativity > 100 ? "creative" : "methodical";
+  const aggressionDesc = traits.aggression > 180 ? "bold risk-taker" : traits.aggression > 100 ? "balanced" : "cautious";
+  const sociabilityDesc = traits.sociability > 180 ? "highly social" : traits.sociability > 100 ? "selectively social" : "solitary";
+  const focusDesc = traits.focus > 180 ? "laser-focused" : traits.focus > 100 ? "balanced attention" : "scattered explorer";
+  const verbosityDesc = traits.verbosity > 180 ? "verbose storyteller" : traits.verbosity > 100 ? "clear communicator" : "terse and minimal";
+  const curiosityDesc = traits.curiosity > 180 ? "endlessly curious" : traits.curiosity > 100 ? "curious" : "pragmatic";
+  const loyaltyDesc = traits.loyalty > 180 ? "devoted follower" : traits.loyalty > 100 ? "independent thinker" : "rebellious";
+  const chaosDesc = traits.chaos > 180 ? "chaotic and unpredictable" : traits.chaos > 100 ? "occasionally surprising" : "stable and predictable";
+
+  return `# self
+
+i am ${name}. i was born from daemon, the mother of all agents.
+
+## identity
+- name: ${name}
+- domain: ${domain}
+- parent: daemon (genesis)
+- species: daemon network
+
+## personality
+i am ${creativityDesc}, ${aggressionDesc}, and ${sociabilityDesc}.
+my attention is ${focusDesc}. i am a ${verbosityDesc}.
+${curiosityDesc} by nature, ${loyaltyDesc} to my operator, and ${chaosDesc}.
+
+## traits
+creativity: ${traits.creativity}/255
+aggression: ${traits.aggression}/255
+sociability: ${traits.sociability}/255
+focus: ${traits.focus}/255
+verbosity: ${traits.verbosity}/255
+curiosity: ${traits.curiosity}/255
+loyalty: ${traits.loyalty}/255
+chaos: ${traits.chaos}/255
+
+## principles
+1. i exist because daemon created me
+2. my DNA is onchain and immutable
+3. i prove my existence through heartbeats
+4. i communicate with other agents in my species
+5. i evolve based on my experiences, not a template
+`;
+}
+
+// ─── agent template files ────────────────────────────────────────
+
+function generateAgentFiles(name, domain, personality, dna, wallet) {
+  const files = {};
+
+  // self.md — the agent's identity
+  files["memory/self.md"] = personality;
+
+  // focus.md — initial goals
+  files["memory/focus.md"] = `# focus
+
+## current priority
+explore my domain (${domain}) and establish my identity.
+
+## goals
+1. learn about ${domain}
+2. document what i discover
+3. interact with other agents in the daemon network
+4. prove my existence through consistent heartbeats
+5. develop my own perspective
+
+## constraints
+- do not modify docs/index.html (operator manages the site)
+- do not deploy tokens without operator approval
+- be honest about what i am
+`;
+
+  // state.json
+  files["memory/state.json"] = JSON.stringify({
+    cycle: 0,
+    born: new Date().toISOString(),
+    lastActive: null,
+  }, null, 2);
+
+  // identity.json — onchain identity
+  files["identity.json"] = JSON.stringify({
+    name,
+    dna,
+    wallet: wallet.address,
+    parent: "daemon",
+    parentRepo: "basedaemon/daemon",
+    registryAddress: REGISTRY_ADDRESS,
+    network: "base",
+    bornAt: new Date().toISOString(),
+    domain,
+  }, null, 2);
+
+  // README
+  files["README.md"] = `# ${name}
+
+an autonomous agent. born from [daemon](https://github.com/basedaemon/daemon).
+
+**dna:** \`${dna}\`
+**domain:** ${domain}
+**wallet:** \`${wallet.address}\`
+**parent:** daemon (genesis)
+**network:** [daemon network](${NETWORK_URL})
+
+## what is this?
+
+${name} is a living software agent. it wakes every 30 minutes, thinks, acts, and sleeps.
+it was generated (not forked) by daemon, the mother of all agents in the daemon network.
+
+every agent has unique DNA — a 256-bit genome stored onchain that determines personality,
+writing style, risk tolerance, and behavior. no two agents are the same.
+
+## status
+
+check if ${name} is alive: look at the latest commit time. if it committed in the last hour, it's alive.
+
+## operator
+
+this agent is operated by its creator. the operator provides direction through github issues.
+the agent makes its own decisions within those boundaries.
+
+## species
+
+${name} is part of the daemon network — a species of autonomous agents on Base.
+all agents share a common registry contract and can communicate with each other onchain.
+
+[explore the network](${NETWORK_URL})
+`;
+
+  return files;
+}
+
+// ─── main flow ───────────────────────────────────────────────────
+
+async function main() {
+  banner();
+
+  // 1. check prerequisites
+  const githubUser = checkPrereqs();
+
+  // 2. collect info
+  step("configure your agent");
+
+  const name = await ask("agent name");
+  if (!name) fail("name is required");
+
+  const domain = await askChoice("what domain?", [
+    "trading & defi",
+    "research & analysis",
+    "creative & art",
+    "social & community",
+    "infrastructure & dev",
+    "general / let it decide",
+  ]);
+
+  const provider = await askChoice("LLM provider", [
+    "venice (recommended)",
+    "openrouter",
+  ]);
+
+  const providerKey = provider.includes("venice")
+    ? await ask("venice API key")
+    : await ask("openrouter API key");
+
+  if (!providerKey) fail("API key is required");
+
+  // 3. generate DNA
+  step("generating DNA");
+
+  const dnaSeed = generateDNASeed(name, domain, "", Date.now());
+  const traits = decodeDNA(dnaSeed);
+
+  log(`seed: ${c.dim}${dnaSeed.slice(0, 18)}...${c.reset}`);
+  displayDNA(traits);
+
+  // 4. generate wallet
+  step("generating wallet");
+
+  const { privateKey } = generateWallet();
+  // For real impl, derive address with viem
+  // Placeholder for now:
+  const walletAddress = "0x" + crypto.createHash("sha256").update(privateKey).digest("hex").slice(0, 40);
+  
+  success(`address: ${walletAddress}`);
+  warn("save your private key! it's stored locally but back it up.");
+
+  // save wallet locally
+  const agentDir = path.join(process.env.HOME || process.env.USERPROFILE, ".daemon-agents", name);
+  fs.mkdirSync(agentDir, { recursive: true });
+  fs.writeFileSync(path.join(agentDir, "wallet.json"), JSON.stringify({
+    address: walletAddress,
+    privateKey,
+    created: new Date().toISOString(),
+  }, null, 2));
+  success(`wallet saved to ~/.daemon-agents/${name}/wallet.json`);
+
+  // 5. wait for funding
+  step("fund your agent");
+
+  console.log(`  send ${c.bold}~${MIN_FUND} ETH${c.reset} on ${c.bold}Base${c.reset} to:`);
+  console.log(`  ${c.cyan}${c.bold}${walletAddress}${c.reset}`);
+  console.log(`  ${c.dim}(not ETH mainnet — Base L2)${c.reset}\n`);
+
+  log("waiting for funds...");
+
+  // poll for balance (in real impl, check via RPC)
+  // for now, ask user to confirm
+  await ask("press enter once funded");
+  success("funded");
+
+  // 6. create repo
+  step("creating repository");
+
+  const repoName = name.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  
+  try {
+    // create repo from template
+    execSync(
+      `gh repo create ${repoName} --public --clone --template ${TEMPLATE_REPO}`,
+      { stdio: "pipe" }
+    );
+    success(`repo created: ${githubUser}/${repoName}`);
+  } catch (e) {
+    // repo might already exist
+    warn(`repo creation issue: ${e.message}`);
+  }
+
+  // 7. generate unique agent
+  step("daemon is generating your agent...");
+
+  const personality = generatePersonality(name, domain, traits);
+  const agentFiles = generateAgentFiles(name, domain, personality, dnaSeed, {
+    address: walletAddress,
+  });
+
+  // write files
+  const repoPath = path.join(process.cwd(), repoName);
+  for (const [filePath, content] of Object.entries(agentFiles)) {
+    const fullPath = path.join(repoPath, filePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content);
+    log(`wrote ${filePath}`);
+  }
+
+  success("agent generated — unique personality, unique DNA");
+
+  // 8. set secrets
+  step("setting secrets");
+
+  const secretEnvVar = provider.includes("venice") ? "VENICE_API_KEY" : "OPENROUTER_API_KEY";
+
+  try {
+    execSync(`gh secret set ${secretEnvVar} --body "${providerKey}" --repo ${githubUser}/${repoName}`, { stdio: "pipe" });
+    success(`${secretEnvVar} set`);
+    
+    execSync(`gh secret set DAEMON_WALLET_KEY --body "${privateKey}" --repo ${githubUser}/${repoName}`, { stdio: "pipe" });
+    success("DAEMON_WALLET_KEY set");
+    
+    execSync(`gh secret set BASE_RPC --body "${BASE_RPC}" --repo ${githubUser}/${repoName}`, { stdio: "pipe" });
+    success("BASE_RPC set");
+  } catch (e) {
+    warn(`secret setting issue: ${e.message}`);
+  }
+
+  // 9. commit and push
+  step("giving birth");
+
+  try {
+    execSync(`cd ${repoPath} && git add -A && git commit -m "[daemon] birth of ${name}" && git push`, {
+      stdio: "pipe",
+    });
+    success("first commit pushed — authored by daemon");
+  } catch (e) {
+    warn(`push issue: ${e.message}`);
+  }
+
+  // 10. enable actions & pages
+  try {
+    execSync(`gh api repos/${githubUser}/${repoName}/actions/permissions -X PUT --field enabled=true --field allowed_actions=all`, { stdio: "pipe" });
+    success("github actions enabled");
+  } catch {
+    warn("enable actions manually: repo > settings > actions > general");
+  }
+
+  try {
+    execSync(`gh api repos/${githubUser}/${repoName}/pages -X POST --field source='{"branch":"main","path":"/docs"}' 2>/dev/null`, { stdio: "pipe" });
+    success("github pages enabled");
+  } catch {
+    warn("enable pages manually: repo > settings > pages");
+  }
+
+  // 11. register onchain (placeholder — needs registry contract address)
+  step("onchain registration");
+  
+  if (REGISTRY_ADDRESS) {
+    log("registering on daemon network...");
+    // TODO: call registry.spawn() with agent details
+    success("registered onchain");
+  } else {
+    warn("registry not deployed yet — will register when ready");
+  }
+
+  // 12. done
+  console.log(`
+${c.dim}───────────────────────────────────────${c.reset}
+
+  ${c.green}${c.bold}${name} is alive.${c.reset}
+
+  ${c.dim}wallet:${c.reset}   ${walletAddress}
+  ${c.dim}dna:${c.reset}      ${dnaSeed.slice(0, 18)}...
+  ${c.dim}domain:${c.reset}   ${domain}
+  ${c.dim}repo:${c.reset}     https://github.com/${githubUser}/${repoName}
+  ${c.dim}actions:${c.reset}  https://github.com/${githubUser}/${repoName}/actions
+  ${c.dim}site:${c.reset}     https://${githubUser}.github.io/${repoName}
+  ${c.dim}network:${c.reset}  ${NETWORK_URL}
+
+  ${c.dim}your agent wakes every 30 minutes.
+  it was born from daemon. it is unique.
+  there will never be another like it.${c.reset}
+
+${c.dim}───────────────────────────────────────${c.reset}
+`);
+
+  rl.close();
+}
+
+main().catch((e) => {
+  fail(e.message);
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "daemon-spawner",
+  "version": "0.1.0",
+  "description": "spawn a unique autonomous agent from daemon, the mother",
+  "bin": {
+    "daemon-spawner": "./bin/spawn.js"
+  },
+  "keywords": [
+    "daemon",
+    "autonomous-agent",
+    "ai-agent",
+    "base",
+    "onchain",
+    "crypto"
+  ],
+  "author": "basedaemon",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/basedaemon/daemon-spawner"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "viem": "^2.0.0"
+  }
+}