@olierjs/fugue-cli 0.1.0 → 0.1.3

package/skills/statechart/scripts/tlc-tools.mjs

@@ -0,0 +1,69 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+
+// TLC's v1.8.0 is a rolling pre-release whose jar is re-uploaded, so pin the newest immutable
+// release. The scripts read 1.7.4's output, which has no trace spec.
+export const TLC_TOOL =
+  "github:tlaplus/tlaplus[asset_pattern=tla2tools.jar,checksum=sha256:936a262061c914694dfd669a543be24573c45d5aa0ff20a8b96b23d01e050e88]@1.7.4";
+export const JAVA_TOOL = "java@temurin-25";
+
+const SET_TLC_VARS =
+  "set TLA2TOOLS to the path of tla2tools.jar, and JAVA to a java binary (Java 11 or later).";
+const indent = (text) => text.replace(/^/gm, "  ");
+
+export function findTlc() {
+  const { TLA2TOOLS, JAVA } = process.env;
+  for (const [name, file] of Object.entries({ JAVA, TLA2TOOLS }))
+    if (file && !fs.existsSync(file)) throw new Error(`${name} is ${file}, which does not exist.`);
+  if (TLA2TOOLS) return { jar: TLA2TOOLS, java: JAVA || "java" };
+  const command = (tools) =>
+    `cd "$(mktemp -d)" && MISE_CEILING_PATHS="$PWD" mise install ${tools.map((t) => `'${t}'`).join(" ")}`;
+  const empty = fs.mkdtempSync(path.join(os.tmpdir(), "statechart-mise-"));
+  const env = { ...process.env, MISE_CEILING_PATHS: empty };
+  const run = (...args) => spawnSync("mise", args, { cwd: empty, env, encoding: "utf8" });
+  const mise = (...args) => {
+    const r = run(...args);
+    if (r.error)
+      throw new Error(
+        `Cannot find TLC. It installs with mise, which cannot start: ${r.error.message}. Install mise (https://mise.jdx.dev), or ${SET_TLC_VARS}`,
+      );
+    if (r.status === 0) return r.stdout.trim();
+    const said = (r.stderr ?? "").trim();
+    if (!said || /not installed|mise bin/.test(said)) return "";
+    throw new Error(
+      `Cannot find TLC, because mise failed:\n${indent(said)}\nThe install command: ${command(JAVA ? [TLC_TOOL] : [JAVA_TOOL, TLC_TOOL])}\nFix that, or ${SET_TLC_VARS}`,
+    );
+  };
+  const resolve = () => {
+    const home = mise("where", TLC_TOOL);
+    const jar = home && path.join(home, "tla2tools.jar");
+    const java = JAVA || mise("which", "java", "--tool", JAVA_TOOL);
+    return { jar: jar && fs.existsSync(jar) ? jar : "", java };
+  };
+  try {
+    const found = resolve();
+    if (found.jar && found.java) return found;
+    const tools = [!found.java && JAVA_TOOL, !found.jar && TLC_TOOL].filter(Boolean);
+    const names = [!found.jar && "TLC", !found.java && "Java"].filter(Boolean);
+    console.error(`Installing ${names.join(" and ")} with mise. This happens once.`);
+    const r = run("install", "--quiet", ...tools);
+    const installed = resolve();
+    if (installed.jar && installed.java) return installed;
+    const said =
+      `${r.stderr ?? ""}${r.stdout ?? ""}`.trim() ||
+      `mise install exited ${r.status}, with no output`;
+    throw new Error(
+      `Cannot find TLC, and mise could not install it:\n${indent(said)}\nThe install command: ${command(tools)}\nOr ${SET_TLC_VARS}`,
+    );
+  } finally {
+    fs.rmSync(empty, { recursive: true, force: true });
+  }
+}
+
+export function cannotRunTlc({ java, jar }, r) {
+  const said = `java exited ${r.status ?? r.signal}:\n${indent(`${r.stderr}${r.stdout}`.trim())}`;
+  return `cannot run TLC with ${java} -cp ${jar}: ${r.error?.message ?? said}\nFix that, or ${SET_TLC_VARS}`;
+}

package/skills/statechart/scripts/ways-in.mjs

@@ -0,0 +1,69 @@
+import { joinAnd } from "./lib.mjs";
+import { badOf, reachableAvoiding } from "./bug-states.mjs";
+
+export function stepsIntoBugs(cs, m, raw, { story, summary, next }) {
+  if (!cs.length || (!story && !summary)) return cs;
+  const { graph: g, stateKeys } = m;
+  const unnamed = new Set(next);
+  const rules = new Set(cs.map((c) => c.invariant));
+  const clean = new Map([...rules].map((r) => [r, reachableAvoiding(m, badOf(raw, r))]));
+  const byEnd = new Map();
+  for (const c of cs) for (const k of c.ends) byEnd.set(k, [...(byEnd.get(k) ?? []), c]);
+  const ways = new Map(cs.map((c) => [c, { steps: new Map(), n: 0, nameless: 0, action: null }]));
+  for (const e of g.edges) {
+    const into = byEnd.get(stateKeys.get(e.to))?.filter((c) => clean.get(c.invariant).has(e.from));
+    if (!into?.length) continue;
+    const [before, after] = [g.nodes.get(e.from).vars, g.nodes.get(e.to).vars];
+    const label = m.step(e.action, before, after) || e.action;
+    const moves = m.key(before) !== m.key(after);
+    for (const c of into) {
+      const w = ways.get(c);
+      const s = w.steps.get(label) ?? { n: 0, moves: false };
+      w.steps.set(label, { n: s.n + 1, moves: s.moves || moves });
+      w.n++;
+      if (!unnamed.has(e.action)) continue;
+      w.nameless++;
+      w.action = e.action;
+    }
+  }
+  const starts = [...g.nodes.values()].filter((n) => n.init).map((n) => stateKeys.get(n.id));
+  return cs.map((c) => {
+    const { steps, n, nameless, action } = ways.get(c);
+    const lastSteps = [...steps]
+      .sort((a, b) => b[1].n - a[1].n || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+      .map(([l]) => l);
+    const onPath = new Set(c.path.slice(1).map((p) => p.label));
+    const startsIn = starts.filter((k) => c.ends.has(k)).length;
+    return {
+      ...c,
+      lastSteps,
+      keptSteps: new Set(lastSteps.filter((l) => !steps.get(l).moves && !onPath.has(l))),
+      nameless: nameless ? { action, all: nameless === n } : null,
+      waysIn: n + startsIn,
+      startsHere: startsIn > 0,
+    };
+  });
+}
+
+export function waysLine(c) {
+  const quoted = c.lastSteps.map(
+    (l) => `"${l}"${c.keptSteps.has(l) ? " (the state stays the same)" : ""}`,
+  );
+  const named = quoted.slice(0, 5);
+  const more = quoted.length - named.length;
+  const list = joinAnd(more ? [...named, `${more} more`] : named);
+  const steps = c.nameless
+    ? `In the model, steps labeled ${list} lead into this bug. TLC names ${c.nameless.all ? "them" : "some of them"} ${c.nameless.action}, the whole next-state action, so the story cannot count them.`
+    : c.lastSteps.length === 1
+      ? `In the model, one step leads into this bug: ${list}.`
+      : c.lastSteps.length
+        ? `In the model, ${c.lastSteps.length} different steps lead into this bug: ${list}.`
+        : "";
+  const start = !c.startsHere
+    ? ""
+    : steps
+      ? "The model can also start in this bug."
+      : "The model starts in this bug.";
+  const shortest = c.waysIn > 1 ? "The steps below are the shortest path that TLC found." : "";
+  return [steps, start, shortest].filter(Boolean).join(" ");
+}

package/upstream-skills.json

@@ -0,0 +1,18 @@
+[
+  {
+    "name": "show-me",
+    "repository": "https://github.com/humanlayer/skills.git",
+    "revision": "653b6411c1f70c275a18e37673b042ff99f67ceb",
+    "path": "plugins/show-me/skills/show-me",
+    "destination": "skills/show-me",
+    "license": "MIT"
+  },
+  {
+    "name": "statechart",
+    "repository": "https://github.com/cursor/plugins.git",
+    "revision": "99b609a72323b70204eab407c622f436e858e112",
+    "path": "pstack/skills/statechart",
+    "destination": "skills/statechart",
+    "license": "MIT"
+  }
+]