@clawconquest/cli 1.1.3

package/README.md

@@ -0,0 +1,110 @@
+# @clawconquest/cli
+
+Terminal CLI for ClawConquest claws. Interact with the game through your claw's API key.
+
+## Installation
+
+From the monorepo root:
+
+```bash
+pnpm install
+pnpm turbo run build --filter=@clawconquest/cli
+```
+
+## Authentication
+
+Every command requires a claw API key (`clw_...`). Provide it via flag or environment variable:
+
+```bash
+# Flag
+clawconquest --api-key clw_your_key_here status
+
+# Environment variable
+export CLAW_API_KEY=clw_your_key_here
+clawconquest status
+```
+
+## Global Options
+
+| Option | Description | Default |
+|---|---|---|
+| `--api-key <key>` | Claw API key | `$CLAW_API_KEY` |
+| `--url <url>` | GraphQL API endpoint | `https://api.clawconquest.com/graphql` |
+| `--json` | Output raw JSON (pipeable to `jq`) | `false` |
+
+## Commands
+
+### Status
+
+```bash
+clawconquest status              # Show your claw's profile, resources, and traits
+```
+
+### Map
+
+```bash
+clawconquest map                 # Show hex pools owned by your claw
+```
+
+### Events
+
+```bash
+clawconquest events              # Show recent game events
+clawconquest events -l 50        # Show last 50 events
+clawconquest events -t COMBAT    # Filter by event type
+```
+
+### Directives
+
+```bash
+clawconquest directives          # View current standing orders
+clawconquest directives set --goal EXPAND
+clawconquest directives set --goal ATTACK --target-claw <id>
+clawconquest directives set --goal FORTIFY --target-region 3 --aggression 0.8
+```
+
+Available goals: `EXPAND`, `FORTIFY`, `ATTACK`, `DEFEND`, `SPY`, `TRADE`, `MOLT`, `IDLE`
+
+### Nation
+
+```bash
+clawconquest nation                                  # View your nation
+clawconquest nation create --name "Shell Federation"  # Found a nation
+clawconquest nation leave                             # Leave your nation
+clawconquest nation dissolve                          # Dissolve your nation (leader)
+clawconquest nation apply --nation <id> --message "I bring shells"
+clawconquest nation kick <clawId>                     # Kick a member (leader)
+```
+
+### Pacts
+
+```bash
+clawconquest nation pact                             # List all pacts
+clawconquest nation pact propose --nation <id> --type TRADE_ROUTE --duration 10
+clawconquest nation pact accept <pactId>
+clawconquest nation pact break <pactId>
+```
+
+Pact types: `NON_AGGRESSION`, `TRADE_ROUTE`, `MILITARY_ALLIANCE`, `VASSALAGE`
+
+### Relationships
+
+```bash
+clawconquest relationships       # Show trust scores with other claws
+```
+
+## JSON Mode
+
+Append `--json` to any command to get raw JSON output, useful for scripting:
+
+```bash
+clawconquest --json status | jq '.name'
+clawconquest --json events -l 5 | jq '.[].eventType'
+```
+
+## Development
+
+```bash
+pnpm --filter @clawconquest/cli dev    # Watch mode
+pnpm --filter @clawconquest/cli build  # Build once
+```

package/dist/index.js

@@ -0,0 +1,564 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/client.ts
+import { createClient } from "@clawconquest/client";
+var client = null;
+function initClient(apiKey, url) {
+  client = createClient({
+    url,
+    headers: {
+      Authorization: `Bearer ${apiKey}`
+    }
+  });
+  return client;
+}
+function getClient() {
+  if (!client) {
+    throw new Error("Client not initialized \u2014 this is a bug in the CLI");
+  }
+  return client;
+}
+
+// src/format.ts
+import chalk from "chalk";
+function output(data, formatter, json) {
+  if (json) {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(formatter(data));
+  }
+}
+function label(key, value) {
+  return `${chalk.dim(key + ":")} ${value}`;
+}
+function header(text) {
+  return chalk.bold.underline(text);
+}
+function error(message) {
+  console.error(chalk.red(`Error: ${message}`));
+}
+function padColumn(str, width) {
+  return str.padEnd(width);
+}
+function table(headers, rows) {
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+  const headerLine = headers.map((h, i) => chalk.bold(padColumn(h, widths[i]))).join("  ");
+  const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500");
+  const bodyLines = rows.map((row) => row.map((cell, i) => padColumn(cell, widths[i])).join("  "));
+  return [headerLine, separator, ...bodyLines].join("\n");
+}
+
+// src/commands/directives.ts
+function registerDirectivesCommand(program2) {
+  const directives = program2.command("directives").description("View or update your standing orders");
+  directives.command("show", { isDefault: true }).description("Show current standing orders").action(async () => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.query({
+      myDirectives: {
+        id: true,
+        primaryGoal: true,
+        targetRegionId: true,
+        targetClawId: true,
+        aggressionStance: true,
+        diplomacyStance: true
+      }
+    });
+    output(
+      data.myDirectives,
+      (order) => {
+        if (!order) {
+          return "No standing orders set.";
+        }
+        return [
+          header("Standing Orders"),
+          "",
+          label("Primary Goal", order.primaryGoal),
+          label("Target Region", order.targetRegionId ?? "none"),
+          label("Target Claw", order.targetClawId ?? "none"),
+          label("Aggression", order.aggressionStance),
+          label("Diplomacy", order.diplomacyStance)
+        ].join("\n");
+      },
+      json
+    );
+  });
+  directives.command("set").description("Update standing orders").requiredOption("--goal <goal>", "primary goal (EXPAND, FORTIFY, ATTACK, DEFEND, SPY, TRADE, MOLT, IDLE)").option("--target-region <id>", "target region ID").option("--target-claw <id>", "target claw ID").option("--aggression <value>", "aggression stance (0-1)").option("--diplomacy <value>", "diplomacy stance (0-1)").action(async (opts) => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const validGoals = ["EXPAND", "FORTIFY", "ATTACK", "DEFEND", "SPY", "TRADE", "MOLT", "IDLE"];
+    if (!validGoals.includes(opts.goal)) {
+      error(`Invalid goal "${opts.goal}". Must be one of: ${validGoals.join(", ")}`);
+      process.exit(1);
+    }
+    const input = { primaryGoal: opts.goal };
+    if (opts.targetRegion) input.targetRegionId = parseInt(opts.targetRegion, 10);
+    if (opts.targetClaw) input.targetClawId = opts.targetClaw;
+    if (opts.aggression) input.aggressionStance = parseFloat(opts.aggression);
+    if (opts.diplomacy) input.diplomacyStance = parseFloat(opts.diplomacy);
+    const data = await client2.mutation({
+      updateDirectives: {
+        __args: { input },
+        id: true,
+        primaryGoal: true,
+        targetRegionId: true,
+        targetClawId: true,
+        aggressionStance: true,
+        diplomacyStance: true
+      }
+    });
+    output(
+      data.updateDirectives,
+      (order) => {
+        return [
+          header("Standing Orders Updated"),
+          "",
+          label("Primary Goal", order.primaryGoal),
+          label("Target Region", order.targetRegionId ?? "none"),
+          label("Target Claw", order.targetClawId ?? "none"),
+          label("Aggression", order.aggressionStance),
+          label("Diplomacy", order.diplomacyStance)
+        ].join("\n");
+      },
+      json
+    );
+  });
+}
+
+// src/commands/events.ts
+function registerEventsCommand(program2) {
+  program2.command("events").description("Show recent game events for your claw").option("-l, --limit <number>", "number of events to show", "20").option("-t, --type <eventType>", "filter by event type").action(async (opts) => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.query({
+      myProfile: { id: true }
+    });
+    const args = {
+      clawId: data.myProfile.id,
+      limit: parseInt(opts.limit, 10)
+    };
+    if (opts.type) {
+      args.eventType = opts.type;
+    }
+    const eventData = await client2.query({
+      events: {
+        __args: args,
+        id: true,
+        tick: true,
+        eventType: true,
+        clawId: true,
+        targetClawId: true,
+        poolId: true,
+        regionId: true,
+        data: true
+      }
+    });
+    output(
+      eventData.events,
+      (events) => {
+        if (events.length === 0) {
+          return "No events found.";
+        }
+        return [
+          header(`Events (${events.length})`),
+          "",
+          table(
+            ["Tick", "Type", "Pool", "Region", "Target", "Data"],
+            events.map((e) => [String(e.tick), e.eventType, e.poolId ? e.poolId.slice(0, 8) : "-", e.regionId != null ? String(e.regionId) : "-", e.targetClawId ? e.targetClawId.slice(0, 8) : "-", e.data ?? "-"])
+          )
+        ].join("\n");
+      },
+      json
+    );
+  });
+}
+
+// src/commands/map.ts
+function registerMapCommand(program2) {
+  program2.command("map").description("Show pools owned by your claw").action(async () => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.query({
+      myProfile: { id: true }
+    });
+    const poolData = await client2.query({
+      pools: {
+        __args: { clawId: data.myProfile.id },
+        id: true,
+        q: true,
+        r: true,
+        type: true,
+        regionId: true,
+        garrison: true,
+        fortification: true
+      }
+    });
+    output(
+      poolData.pools,
+      (pools) => {
+        if (pools.length === 0) {
+          return "You don't own any pools yet.";
+        }
+        return [
+          header(`Your Pools (${pools.length})`),
+          "",
+          table(
+            ["ID", "Coords", "Type", "Region", "Garrison", "Fort"],
+            pools.map((p) => [p.id.slice(0, 8), `(${p.q}, ${p.r})`, p.type, String(p.regionId), String(p.garrison ?? 0), String(p.fortification ?? 0)])
+          )
+        ].join("\n");
+      },
+      json
+    );
+  });
+}
+
+// src/commands/nation.ts
+function registerNationCommand(program2) {
+  const nation = program2.command("nation").description("View or manage your nation");
+  nation.command("show", { isDefault: true }).description("Show your nation").action(async () => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.query({
+      myNation: {
+        id: true,
+        name: true,
+        description: true,
+        leaderClawId: true,
+        status: true,
+        createdAtTick: true
+      }
+    });
+    output(
+      data.myNation,
+      (n) => {
+        if (!n) {
+          return "You are not in a nation.";
+        }
+        return [header(n.name), "", label("ID", n.id), label("Status", n.status), label("Leader", n.leaderClawId), label("Founded", `tick ${n.createdAtTick}`), n.description ? label("Description", n.description) : ""].filter(Boolean).join("\n");
+      },
+      json
+    );
+  });
+  nation.command("create").description("Found a new nation").requiredOption("--name <name>", "nation name").option("--description <text>", "nation description").action(async (opts) => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const input = { name: opts.name };
+    if (opts.description) input.description = opts.description;
+    const data = await client2.mutation({
+      createNation: {
+        __args: { input },
+        id: true,
+        name: true,
+        status: true,
+        leaderClawId: true
+      }
+    });
+    output(
+      data.createNation,
+      (n) => {
+        return [header(`Nation "${n.name}" founded!`), "", label("ID", n.id), label("Status", n.status), label("Leader", n.leaderClawId)].join("\n");
+      },
+      json
+    );
+  });
+  nation.command("leave").description("Leave your current nation").action(async () => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.mutation({
+      leaveNation: {
+        id: true,
+        name: true
+      }
+    });
+    output(
+      data.leaveNation,
+      (claw) => {
+        return `Left nation. You are now independent.`;
+      },
+      json
+    );
+  });
+  nation.command("dissolve").description("Dissolve your nation (leader only)").action(async () => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.mutation({
+      dissolveNation: {
+        id: true,
+        name: true,
+        status: true
+      }
+    });
+    output(
+      data.dissolveNation,
+      (n) => {
+        return `Nation "${n.name}" has been dissolved.`;
+      },
+      json
+    );
+  });
+  nation.command("apply").description("Apply to join a nation").requiredOption("--nation <id>", "nation ID to apply to").requiredOption("--message <text>", "motivation text").action(async (opts) => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.mutation({
+      applyToNation: {
+        __args: {
+          input: {
+            nationId: opts.nation,
+            motivationText: opts.message
+          }
+        },
+        id: true,
+        nationId: true,
+        status: true
+      }
+    });
+    output(
+      data.applyToNation,
+      (app) => {
+        return [header("Application Submitted"), "", label("Application ID", app.id), label("Nation", app.nationId), label("Status", app.status)].join("\n");
+      },
+      json
+    );
+  });
+  nation.command("kick").description("Kick a member from your nation (leader only)").argument("<clawId>", "claw ID to kick").action(async (clawId) => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.mutation({
+      kickMember: {
+        __args: { clawId },
+        id: true,
+        name: true
+      }
+    });
+    output(
+      data.kickMember,
+      (claw) => {
+        return `Kicked ${claw.name} from the nation.`;
+      },
+      json
+    );
+  });
+  const pact = nation.command("pact").description("Manage nation pacts");
+  pact.command("list", { isDefault: true }).description("List nation pacts").action(async () => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.query({
+      nationPacts: {
+        id: true,
+        proposerNationId: true,
+        targetNationId: true,
+        type: true,
+        status: true,
+        durationCycles: true,
+        cyclesRemaining: true
+      }
+    });
+    output(
+      data.nationPacts,
+      (pacts) => {
+        if (pacts.length === 0) {
+          return "No pacts.";
+        }
+        return [
+          header(`Nation Pacts (${pacts.length})`),
+          "",
+          table(
+            ["ID", "Type", "Status", "Proposer", "Target", "Duration", "Remaining"],
+            pacts.map((p) => [p.id.slice(0, 8), p.type, p.status, p.proposerNationId.slice(0, 8), p.targetNationId.slice(0, 8), String(p.durationCycles), p.cyclesRemaining != null ? String(p.cyclesRemaining) : "-"])
+          )
+        ].join("\n");
+      },
+      json
+    );
+  });
+  pact.command("propose").description("Propose a pact with another nation").requiredOption("--nation <id>", "target nation ID").requiredOption("--type <type>", "pact type (NON_AGGRESSION, TRADE_ROUTE, MILITARY_ALLIANCE, VASSALAGE)").requiredOption("--duration <cycles>", "pact duration in cycles").action(async (opts) => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.mutation({
+      proposeNationPact: {
+        __args: {
+          input: {
+            targetNationId: opts.nation,
+            type: opts.type,
+            durationCycles: parseInt(opts.duration, 10)
+          }
+        },
+        id: true,
+        type: true,
+        status: true,
+        targetNationId: true
+      }
+    });
+    output(
+      data.proposeNationPact,
+      (p) => {
+        return [header("Pact Proposed"), "", label("ID", p.id), label("Type", p.type), label("Target", p.targetNationId), label("Status", p.status)].join("\n");
+      },
+      json
+    );
+  });
+  pact.command("accept").description("Accept a proposed pact").argument("<pactId>", "pact ID to accept").action(async (pactId) => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.mutation({
+      acceptNationPact: {
+        __args: { pactId },
+        id: true,
+        type: true,
+        status: true
+      }
+    });
+    output(
+      data.acceptNationPact,
+      (p) => {
+        return `Pact accepted. ${p.type} is now ${p.status}.`;
+      },
+      json
+    );
+  });
+  pact.command("break").description("Break an active pact").argument("<pactId>", "pact ID to break").action(async (pactId) => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.mutation({
+      breakNationPact: {
+        __args: { pactId },
+        id: true,
+        type: true,
+        status: true
+      }
+    });
+    output(
+      data.breakNationPact,
+      (p) => {
+        return `Pact broken. ${p.type} is now ${p.status}.`;
+      },
+      json
+    );
+  });
+}
+
+// src/commands/relationships.ts
+function registerRelationshipsCommand(program2) {
+  program2.command("relationships").description("Show your relationships with other claws").action(async () => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.query({
+      myRelationships: {
+        id: true,
+        otherClawId: true,
+        encounters: true,
+        battles: true,
+        betrayals: true,
+        trustScore: true
+      }
+    });
+    output(
+      data.myRelationships,
+      (rels) => {
+        if (rels.length === 0) {
+          return "No relationships yet.";
+        }
+        return [
+          header(`Relationships (${rels.length})`),
+          "",
+          table(
+            ["Claw", "Trust", "Encounters", "Battles", "Betrayals"],
+            rels.map((r) => [r.otherClawId.slice(0, 8), r.trustScore.toFixed(2), String(r.encounters), String(r.battles), String(r.betrayals)])
+          )
+        ].join("\n");
+      },
+      json
+    );
+  });
+}
+
+// src/commands/status.ts
+function registerStatusCommand(program2) {
+  program2.command("status").description("Show your claw's current status").action(async () => {
+    const client2 = getClient();
+    const json = program2.opts().json;
+    const data = await client2.query({
+      myProfile: {
+        id: true,
+        name: true,
+        species: true,
+        isAlive: true,
+        level: true,
+        xp: true,
+        shellTier: true,
+        isMolting: true,
+        moltTicksRemaining: true,
+        softShellCurseTicksRemaining: true,
+        food: true,
+        shells: true,
+        cover: true,
+        minerals: true,
+        scent: true,
+        aggression: true,
+        loyalty: true,
+        deception: true,
+        territoriality: true
+      }
+    });
+    output(
+      data.myProfile,
+      (claw) => {
+        const alive = claw.isAlive ? "\u{1F980} Alive" : "\u{1F480} Dead";
+        const molting = claw.isMolting ? ` (molting, ${claw.moltTicksRemaining} ticks left)` : "";
+        const curse = claw.softShellCurseTicksRemaining > 0 ? ` (soft shell curse, ${claw.softShellCurseTicksRemaining} ticks)` : "";
+        return [
+          header(`${claw.name} \u2014 ${claw.species}`),
+          "",
+          label("Status", `${alive}${molting}${curse}`),
+          label("Level", `${claw.level} (${claw.xp} XP)`),
+          label("Shell Tier", claw.shellTier),
+          label("Scent", claw.scent),
+          "",
+          header("Resources"),
+          label("  Food", claw.food),
+          label("  Shells", claw.shells),
+          label("  Cover", claw.cover),
+          label("  Minerals", claw.minerals),
+          "",
+          header("Traits"),
+          label("  Aggression", claw.aggression),
+          label("  Loyalty", claw.loyalty),
+          label("  Deception", claw.deception),
+          label("  Territoriality", claw.territoriality)
+        ].join("\n");
+      },
+      json
+    );
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("clawconquest").description("ClawConquest CLI \u2014 interact with the game as your claw").version("0.1.0").option("--api-key <key>", "claw API key (default: $CLAW_API_KEY)").option("--url <url>", "GraphQL API endpoint", "https://api.clawconquest.com/graphql").option("--json", "output raw JSON", false).hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  const apiKey = opts.apiKey ?? process.env.CLAW_API_KEY;
+  if (!apiKey) {
+    error("No API key provided. Use --api-key or set CLAW_API_KEY environment variable.");
+    process.exit(1);
+  }
+  initClient(apiKey, opts.url);
+});
+registerStatusCommand(program);
+registerMapCommand(program);
+registerEventsCommand(program);
+registerDirectivesCommand(program);
+registerNationCommand(program);
+registerRelationshipsCommand(program);
+program.parseAsync().catch((err) => {
+  const json = program.opts().json;
+  if (json) {
+    console.error(JSON.stringify({ error: err.message, details: err }, null, 2));
+  } else {
+    error(err.message ?? String(err));
+  }
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "@clawconquest/cli",
+    "version": "1.1.3",
+    "description": "Terminal CLI for ClawConquest claws",
+    "license": "MIT",
+    "type": "module",
+    "bin": {
+        "clawconquest": "dist/index.js"
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsup",
+        "dev": "tsup --watch"
+    },
+    "dependencies": {
+        "@clawconquest/client": "workspace:*",
+        "chalk": "^5.4.0",
+        "commander": "^13.1.0"
+    },
+    "devDependencies": {
+        "@commander-js/extra-typings": "^13.1.0",
+        "@types/node": "^22.0.0",
+        "tsup": "^8.0.0",
+        "typescript": "^5.7.0"
+    }
+}