moshcode 0.41.0 → 0.43.0

package/README.md

@@ -50,13 +50,15 @@ or miss one that does. A test fails the build when it drifts.
 | `moshcode doh` | hosting | run the DNS-over-HTTPS resolver |
 | `moshcode site` <br>`serve` | hosting | install web-server config for a Moshpit name |
 | `moshcode template` <br>`templates` | hosting | scaffold a stack for a Moshpit-hosted service |
-| `moshcode games` <br>`game` `arcade` | arcade | the moshcode arcade — six games, no menus |
+| `moshcode games` <br>`game` `arcade` | arcade | the moshcode arcade — twenty-two games, no menus |
 | `moshcode pwd` <br>`where` | system | show the current directory and git context |
 | `moshcode engines` | engines | list engines and installation status |
 | `moshcode tools` | tools | list workflow tools and installation status |
 | `moshcode trade` | tools | look up markets and trade through Alpaca |
 | `moshcode stocks` <br>`advisor` | tools | equity research from advis0r.com |
 | `moshcode crypto` <br>`coins` | tools | crypto market data from advis0r.com |
+| `moshcode news` | tools | headlines from your feeds, or a search |
+| `moshcode rss` | tools | read the same headlines in a full-screen reader |
 | `moshcode plugin` <br>`plugins` | extend | install moshcode's slash commands into Claude Code |
 | `moshcode commands` | script | list built-in moshscript commands |
 | `moshcode completion` | extend | print a shell completion script |
@@ -584,7 +586,7 @@ the composer URL instead.
 
 ## The arcade (`/games`)
 
-Six games, in the pit or straight from a shell. There are no menus, no options
+Twenty-two games, in the pit or straight from a shell. There are no menus, no options
 screens and no difficulty prompts — `/games tetris` is already playing.
 
 ```sh
@@ -611,7 +613,23 @@ moshcode games --json         # the roster, for a machine
 | `tetris` | stack the bricks, clear the lines, outrun gravity |
 | `snake` | eat, grow, and try not to eat yourself |
 | `pacman` | eat the dots, dodge the ghosts, `✳` makes them edible |
+| `invaders` | forty of them, and the last one moves fastest |
+| `centipede` | shoot it in the middle and now there are two of them |
+| `asteroids` | turn, thrust, shoot — every rock you break becomes two |
+| `breakout` | dig a channel up the side and let the ball do the rest |
+| `pong` | first to seven, and the angle is all in where you hit it |
+| `tank` | two tanks, one yard, five hits — line it up and let go |
+| `digdug` | dig the tunnels, pump the monsters, drop rocks on the rest |
+| `frogger` | the road kills what it touches, the river kills what it doesn't |
+| `kong` | five girders, four ladders, and a barrel with your name on it |
+| `pitfall` | jump the logs, swing the pits, and get the gold before dark |
+| `choplifter` | fly out, land, fill the back, and get them home |
+| `spyhunter` | keep it on the tarmac, shoot the ones shooting back |
+| `outrun` | a road that bends, traffic that doesn't, and a clock that always wins |
+| `excitebike` | turbo until it cooks, and land the way you took off |
+| `stagedive` | run the barricade, hop the gear, duck the crowd, take the picks |
 | `tictactoe` | three in a row against an opponent that cannot be beaten |
+| `blackjack` | hit, stand, double, split — dealer stands on 17, and pays 3:2 |
 | `chess` | full rules — castling, en passant, promotion — and it plays back |
 | `hangman` | six wrong letters and you are done for |
 
@@ -620,6 +638,10 @@ another, and the controls are written along the bottom of the game itself. Each
 draws in place rather than on the alternate screen, so the board you finished on
 stays in your scrollback.
 
+The two games that read letters — `blackjack`, where `h` is hit, and `hangman`,
+where it is a guess — keep their letters: `h j k l` are not arrows there, and `r`
+only starts another once the game is over.
+
 Playing needs a real terminal, because they read single keypresses — `moshcode
 games` on its own lists them anywhere, including a pipe.
 

package/bin/moshcode.mjs

@@ -394,6 +394,22 @@ async function main() {
     if (code) process.exitCode = code;
     return;
   }
+  if (cmd === "news") {
+    const { newsCommand } = await import("../src/news.mjs");
+    const code = await newsCommand(rest, {
+      openUrl: (url) => canOpenBrowser() && openBrowser(url),
+    });
+    if (code) process.exitCode = code;
+    return;
+  }
+  if (cmd === "rss") {
+    const { rssUi } = await import("../src/rss-ui.mjs");
+    const code = await rssUi(rest, {
+      openUrl: (url) => canOpenBrowser() && openBrowser(url),
+    });
+    if (code) process.exitCode = code;
+    return;
+  }
   if (cmd === "plugin" || cmd === "plugins") {
     const code = await pluginCommand(rest);
     if (code) process.exitCode = code;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moshcode",
-  "version": "0.41.0",
+  "version": "0.43.0",
   "type": "module",
   "description": "moshcode — a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
   "repository": {

package/src/cli-schema.mjs

@@ -396,7 +396,7 @@ export const CORE_CLI_COMMANDS = [
   {
     name: "games",
     group: "arcade",
-    description: "the moshcode arcade — six games, no menus",
+    description: "the moshcode arcade — twenty-two games, no menus",
     synopsis: [
       ["moshcode games", "the cabinet, and what each one is"],
       ["moshcode games <game>", "play it, right here in the terminal"],
@@ -407,6 +407,10 @@ export const CORE_CLI_COMMANDS = [
       ["moshcode games tetris", ""],
       ["moshcode games chess", "real rules, and it plays back"],
       ["moshcode games pacman", "dots, ghosts, three lives"],
+      ["moshcode games asteroids", "turn, thrust, shoot"],
+      ["moshcode games 21", "blackjack, 100 chips, 3:2"],
+      ["moshcode games invaders", "forty of them, coming down"],
+      ["moshcode games stagedive", "jump the gear, take the picks"],
     ],
     seeAlso: ["help"],
     note: "every game works the same way: arrows move, q quits, r starts another. "
@@ -511,6 +515,50 @@ export const CORE_CLI_COMMANDS = [
     note: "research aid, not advice — prices are Alpaca's US crypto venue alone and can differ materially from other exchanges. Crypto trades 24/7 with no circuit breakers. Set MOSHCODE_ADVISOR_URL to point at another instance.",
   },
   { name: "coins", aliasOf: "crypto", description: "alias for crypto" },
+  {
+    name: "news",
+    group: "tools",
+    description: "headlines from your feeds, or a search",
+    synopsis: [
+      ["moshcode news", "latest headlines across every subscribed feed"],
+      ["moshcode news <keyword…>", "search the news"],
+      ["moshcode news <verb> [args…]", ""],
+    ],
+    verbs: "NEWS_VERBS",
+    flags: [
+      ["--json", "structured output instead of headlines", ""],
+      ["--limit <n>", "how many headlines to show", "20"],
+      ["--feed <name>", "only this feed", "all of them"],
+      ["--timeout <sec>", "per-feed fetch timeout", "10"],
+    ],
+    examples: [
+      ["moshcode news", "everything you subscribe to, newest first"],
+      ["moshcode news openai earnings", "search Google News and Bing News"],
+      ["moshcode news https://example.com/feed.xml", "read one feed without subscribing"],
+      ["moshcode news add journalists", "pull in a public OPML bundle"],
+      ["moshcode news export > feeds.opml", "take the list to another reader"],
+    ],
+    seeAlso: ["rss", "stocks", "crypto"],
+    note: "subscriptions live in ~/.moshcode/news.opml (override with MOSHCODE_NEWS_OPML). "
+      + "With none, a default set is read instead — `moshcode news sources` lists it. "
+      + "The defaults and the search are the same sources brisk.news and advis0r.com use.",
+  },
+  {
+    name: "rss",
+    group: "tools",
+    description: "read the same headlines in a full-screen reader",
+    synopsis: [
+      ["moshcode rss", "open the reader on your feeds"],
+      ["moshcode rss <keyword…>", "open it on a search"],
+    ],
+    examples: [
+      ["moshcode rss", "feeds on the left, headlines in the middle"],
+      ["moshcode rss tariffs", "open straight into a search"],
+    ],
+    seeAlso: ["news"],
+    note: "needs an interactive terminal. ↑↓/jk move · ⏎ read · o open in a browser · "
+      + "tab the feed list · / search · r refresh · q quit.",
+  },
   {
     name: "plugin",
     group: "extend",
@@ -736,6 +784,31 @@ export const STOCKS_VERBS = [
   { name: "open", description: "open the shareable report page in a browser", synopsis: [["moshcode stocks open <symbol>", ""]] },
 ];
 
+/**
+ * `news`'s verbs.
+ *
+ * `latest` earns its place the way crypto's `report` does: a bare argument is
+ * the shortcut — `moshcode news tariffs` searches — so the plain listing needs
+ * a spelling that a keyword cannot be mistaken for. src/news.mjs owns the
+ * parser and test/news.test.mjs fails when the two lists disagree.
+ */
+export const NEWS_VERBS = [
+  { name: "latest", description: "headlines across every subscribed feed", synopsis: [["moshcode news latest", "same as `moshcode news`"]] },
+  {
+    name: "search", description: "search the news for a word or phrase",
+    synopsis: [["moshcode news search <keyword…>", "same as `moshcode news <keyword…>`"]],
+  },
+  { name: "list", description: "the feeds you are subscribed to", synopsis: [["moshcode news list [--json]", ""]] },
+  {
+    name: "add", description: "subscribe to a feed, an OPML list, or a bundle",
+    synopsis: [["moshcode news add <url|file|bundle>", "an RSS/Atom link, an OPML list, or journalists|web3|blockchain"]],
+  },
+  { name: "rm", description: "unsubscribe", synopsis: [["moshcode news rm <name|url>", ""]] },
+  { name: "open", description: "open a headline from the last listing", synopsis: [["moshcode news open <n>", ""]] },
+  { name: "sources", description: "the default feeds and the bundles on offer", synopsis: [["moshcode news sources", ""]] },
+  { name: "export", description: "print the subscription list as OPML", synopsis: [["moshcode news export > feeds.opml", ""]] },
+];
+
 /**
  * `crypto`'s verbs.
  *
@@ -884,6 +957,7 @@ export const VERB_TABLES = {
   TRADE_VERBS,
   STOCKS_VERBS,
   CRYPTO_VERBS,
+  NEWS_VERBS,
   PLUGIN_VERBS,
 };
 
@@ -927,10 +1001,14 @@ export const PIT_COMMANDS = [
     description: "equity research from advis0r.com" },
   { name: "crypto", aliases: ["coins"], args: "<pair|verb> [args…]", cli: "crypto",
     description: "crypto market data from advis0r.com" },
+  { name: "news", args: "[keyword…|verb] [args…]", cli: "news",
+    description: "headlines from your feeds, or a search" },
+  { name: "rss", aliases: ["reader"], cli: "rss",
+    description: "read the same headlines in a full-screen reader" },
   { name: "plugin", aliases: ["plugins"], args: "<verb> [name]", cli: "plugin",
     description: "install moshcode's slash commands into Claude Code" },
   { name: "games", aliases: ["game", "arcade", "play"], args: "[game]", cli: "games",
-    description: "the arcade — tetris, snake, pac-man, tic-tac-toe, chess, hangman" },
+    description: "the arcade — tetris, invaders, pac-man, frogger, kong, outrun, chess and more" },
   { name: "socials", aliases: ["social"], pitOnly: true,
     description: "list social networks available for posting" },
   { name: "post", args: '<social> "message"', pitOnly: true,

package/src/games-asteroids.mjs

@@ -0,0 +1,265 @@
+// Asteroids. Turn, thrust, shoot, and watch the rocks you shot become two
+// smaller rocks that are somehow worse.
+//
+// The one thing the 1979 cabinet did not have to worry about: a terminal cell is
+// about twice as tall as it is wide. Everything here measures distance in
+// columns, so a row counts double (see `span`) — without that, every rock is an
+// egg and the collisions land in places the screen never showed you.
+import { acid, amber, ash, bone, danger, dim, rgb } from "./ui.mjs";
+
+export const WIDTH = 44;
+export const HEIGHT = 18;
+
+/** A row is worth this many columns. Half of everything vertical follows. */
+export const ASPECT = 0.5;
+
+const TURN = Math.PI / 8;      // 16 headings, which is as many as 8 glyphs can tell apart
+const THRUST = 0.14;
+const DRAG = 0.97;             // space has none; a 55ms terminal very much needs some
+const MAX_SPEED = 1.15;
+const BULLET_SPEED = 1.6;
+const BULLET_LIFE = 22;
+const BULLETS = 4;             // in flight at once — the arcade limit, and it is the game
+const COOLDOWN = 2;
+const INVULN = 30;             // ticks of blinking after a life is lost
+const LIVES = 3;
+
+/** Radius in columns, and what a hit is worth. Small ones pay most. */
+export const ROCKS = {
+  3: { r: 3.2, glyph: "█", points: 20, speed: 0.16 },
+  2: { r: 2.1, glyph: "▓", points: 50, speed: 0.24 },
+  1: { r: 1.1, glyph: "▒", points: 100, speed: 0.34 },
+};
+
+const HEADINGS = ["→", "↘", "↓", "↙", "←", "↖", "↑", "↗"];
+const FLAME = ["◄", "◤", "▲", "◥", "►", "◢", "▼", "◣"];
+
+export const wrap = (v, max) => ((v % max) + max) % max;
+
+/**
+ * The starfield: fixed, scattered, and free. Hashed from the coordinates rather
+ * than stored or rolled, so the sky is the same on every repaint — and hashed
+ * rather than `(x * 7 + y * 23) % 37`, which is a diagonal line, not a sky.
+ */
+export const star = (x, y) => ((((x * 73856093) ^ (y * 19349663)) >>> 4) % 53) === 0;
+
+/** The shorter way round a wrapping axis — the screen has no edges. */
+const delta = (a, b, max) => {
+  const d = a - b;
+  return d > max / 2 ? d - max : d < -max / 2 ? d + max : d;
+};
+
+/** Distance between two things, in columns, the short way round. */
+export function span(a, b) {
+  const dx = delta(a.x, b.x, WIDTH);
+  const dy = delta(a.y, b.y, HEIGHT) / ASPECT;
+  return Math.hypot(dx, dy);
+}
+
+const drift = (thing) => {
+  thing.x = wrap(thing.x + thing.vx, WIDTH);
+  thing.y = wrap(thing.y + thing.vy, HEIGHT);
+};
+
+/** A rock of `size`, moving somewhere, starting where it is put. */
+export function rock(size, x, y, rng) {
+  const angle = rng() * Math.PI * 2;
+  const speed = ROCKS[size].speed * (0.7 + rng() * 0.6);
+  return {
+    size, x, y,
+    vx: Math.cos(angle) * speed,
+    vy: Math.sin(angle) * speed * ASPECT,
+  };
+}
+
+/**
+ * A wave. Rocks arrive at the edges of the screen and never on top of the ship —
+ * spawning one on the ship is the cheapest way to make a game feel broken.
+ */
+export function spawnWave(wave, ship, rng) {
+  const rocks = [];
+  for (let i = 0; i < 3 + wave; i++) {
+    let x = 0;
+    let y = 0;
+    let tries = 0;
+    do {
+      x = rng() * WIDTH;
+      y = rng() * HEIGHT;
+      tries++;
+    } while (span({ x, y }, ship) < 14 && tries < 60);
+    rocks.push(rock(3, x, y, rng));
+  }
+  return rocks;
+}
+
+const newShip = () => ({ x: WIDTH / 2, y: HEIGHT / 2, vx: 0, vy: 0, angle: -Math.PI / 2 });
+
+/**
+ * One tick: everything moves, then everything that touched something else
+ * finds out. Exported so a test can fly a whole game without a clock.
+ */
+export function step(state) {
+  const { rng } = state;
+  const ship = state.ship;
+
+  ship.vx *= DRAG;
+  ship.vy *= DRAG;
+  const speed = Math.hypot(ship.vx, ship.vy / ASPECT);
+  if (speed > MAX_SPEED) {
+    ship.vx *= MAX_SPEED / speed;
+    ship.vy *= MAX_SPEED / speed;
+  }
+  drift(ship);
+
+  for (const bullet of state.bullets) { drift(bullet); bullet.life--; }
+  state.bullets = state.bullets.filter((b) => b.life > 0);
+  for (const r of state.rocks) drift(r);
+
+  if (state.cooldown > 0) state.cooldown--;
+  if (state.thrusting > 0) state.thrusting--;
+  if (state.invuln > 0) state.invuln--;
+
+  // Bullets first: a rock shot on the same tick it reaches you does not also
+  // get to take a life.
+  for (const bullet of [...state.bullets]) {
+    const hit = state.rocks.find((r) => span(bullet, r) <= ROCKS[r.size].r + 0.4);
+    if (!hit) continue;
+    state.bullets = state.bullets.filter((b) => b !== bullet);
+    state.rocks = state.rocks.filter((r) => r !== hit);
+    state.score += ROCKS[hit.size].points;
+    if (hit.size > 1) {
+      state.rocks.push(rock(hit.size - 1, hit.x, hit.y, rng), rock(hit.size - 1, hit.x, hit.y, rng));
+    }
+  }
+
+  if (!state.invuln) {
+    const struck = state.rocks.find((r) => span(ship, r) <= ROCKS[r.size].r + 0.9);
+    if (struck) {
+      state.lives--;
+      if (state.lives <= 0) {
+        state.lives = 0;
+        state.over = `wrecked on wave ${state.wave}`;
+        return state;
+      }
+      state.ship = newShip();
+      state.bullets = [];
+      state.invuln = INVULN;
+      // The rock that got you is pushed clear rather than deleted, so the
+      // respawn is not immediately fatal a second time.
+      struck.x = wrap(struck.x + WIDTH / 2, WIDTH);
+      struck.y = wrap(struck.y + HEIGHT / 2, HEIGHT);
+    }
+  }
+
+  if (!state.rocks.length) {
+    state.wave++;
+    state.rocks = spawnWave(state.wave, state.ship, rng);
+    state.invuln = Math.max(state.invuln, 12);
+  }
+  return state;
+}
+
+export const ASTEROIDS = {
+  key: "asteroids",
+  aliases: ["rocks", "asteroid"],
+  title: "ASTEROIDS",
+  blurb: "turn, thrust, shoot — every rock you break becomes two",
+  keys: "← → turn · ↑ thrust · ↓ retro · space fire · q quit",
+  tickMs: 55,
+
+  create({ rng = Math.random } = {}) {
+    const ship = newShip();
+    return {
+      ship,
+      bullets: [],
+      rocks: spawnWave(1, ship, rng),
+      score: 0,
+      lives: LIVES,
+      wave: 1,
+      cooldown: 0,
+      thrusting: 0,
+      invuln: INVULN,
+      over: null,
+      rng,
+    };
+  },
+
+  tick: step,
+
+  onKey(state, key) {
+    const ship = state.ship;
+    if (key === "left") ship.angle -= TURN;
+    else if (key === "right") ship.angle += TURN;
+    else if (key === "up" || key === "down") {
+      // Retro is half power, because a reverse as strong as the throttle turns
+      // the ship into something that cannot drift, and drifting is the game.
+      const push = key === "up" ? THRUST : -THRUST / 2;
+      ship.vx += Math.cos(ship.angle) * push;
+      ship.vy += Math.sin(ship.angle) * push * ASPECT;
+      if (key === "up") state.thrusting = 3;
+    } else if (key === "space" || key === "enter") {
+      if (state.cooldown > 0 || state.bullets.length >= BULLETS) return state;
+      state.bullets.push({
+        // Out of the nose, not the middle, or the ship shoots itself in the face
+        // at close range and the muzzle flash lands inside the hull.
+        x: wrap(ship.x + Math.cos(ship.angle) * 1.6, WIDTH),
+        y: wrap(ship.y + Math.sin(ship.angle) * 1.6 * ASPECT, HEIGHT),
+        vx: ship.vx + Math.cos(ship.angle) * BULLET_SPEED,
+        vy: ship.vy + Math.sin(ship.angle) * BULLET_SPEED * ASPECT,
+        life: BULLET_LIFE,
+      });
+      state.cooldown = COOLDOWN;
+    }
+    return state;
+  },
+
+  status(state) {
+    return state.over
+      ? `${state.over} · ${state.score} points`
+      : `score ${state.score} · wave ${state.wave} · ${"▲".repeat(state.lives)}`;
+  },
+
+  render(state) {
+    const grid = Array.from({ length: HEIGHT }, () => Array.from({ length: WIDTH }, () => null));
+    const put = (x, y, glyph) => {
+      const col = wrap(Math.round(x), WIDTH);
+      const row = wrap(Math.round(y), HEIGHT);
+      grid[row][col] = glyph;
+    };
+
+    for (const r of state.rocks) {
+      const { r: radius, glyph } = ROCKS[r.size];
+      const paint = r.size === 3 ? ash : r.size === 2 ? rgb(150, 158, 150) : rgb(190, 196, 188);
+      // A disc, measured in columns — hence the row doubling, which is the only
+      // reason these come out round instead of squashed.
+      for (let dy = -Math.ceil(radius * ASPECT); dy <= Math.ceil(radius * ASPECT); dy++) {
+        for (let dx = -Math.ceil(radius); dx <= Math.ceil(radius); dx++) {
+          if (Math.hypot(dx, dy / ASPECT) > radius) continue;
+          put(r.x + dx, r.y + dy, paint(glyph));
+        }
+      }
+    }
+
+    for (const bullet of state.bullets) put(bullet.x, bullet.y, amber("•"));
+
+    const heading = ((Math.round(state.ship.angle / (Math.PI / 4)) % 8) + 8) % 8;
+    if (state.thrusting) {
+      put(
+        state.ship.x - Math.cos(state.ship.angle) * 1.4,
+        state.ship.y - Math.sin(state.ship.angle) * 1.4 * ASPECT,
+        danger(FLAME[heading]),
+      );
+    }
+    if (!state.over) {
+      // Blinking is the only tell that the ship cannot be hit yet.
+      const shield = state.invuln && state.invuln % 6 < 3;
+      put(state.ship.x, state.ship.y, (shield ? bone : acid)(HEADINGS[heading]));
+    } else {
+      put(state.ship.x, state.ship.y, danger("✷"));
+    }
+
+    return grid.map((row, y) => row.map((cell, x) => (
+      cell ?? (star(x, y) ? dim("·") : " ")
+    )).join(""));
+  },
+};