@imfusion/web-ui 0.6.4-dev.8.g41d03f2f → 0.6.4-dev.84.gbfc0d437

package/bin/install.js

@@ -1,446 +0,0 @@
-#!/usr/bin/env node
-
-// Installs this package's agent tooling into the consumer project: the
-// skill family (../src/llms/skills/imf-web-ui*/) and the agent lifecycle
-// hooks in the installer-owned template home. Runs in the
-// CONSUMER's environment, so it may only use this package's real runtime
-// dependencies (@clack/prompts). Never wire this into a postinstall hook:
-// ambient script execution on `npm install` is a live supply-chain attack
-// vector — install stays an explicit, user-run command.
-//
-// The skills cross-reference each other, so they install as one bundle.
-// When both targets are selected, .agents/skills/ holds the real copy and
-// .claude/skills/ symlinks it (this repo's own convention) so the two
-// can't drift apart.
-//
-// Flags: bare = help; --hooks adds the agent lifecycle hooks after the consumer
-// checks the repo's existing hooks and still installs the skills.
-// --target claude|agents|all (repeatable) selects scripted install targets,
-// --reconfigure to re-open the target prompt on an existing install.
-
-import {
-  chmodSync,
-  cpSync,
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  symlinkSync,
-  writeFileSync
-} from "node:fs";
-import { spawnSync } from "node:child_process";
-import { dirname, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import * as p from "@clack/prompts";
-
-const SKILL_PREFIX = "imf-web-ui";
-const VERSION_MARKER = ".imf-web-ui-skill-version.json";
-
-const here = dirname(fileURLToPath(import.meta.url));
-// Source is relative to THIS SCRIPT's location (inside node_modules), not
-// the consumer's cwd — the script is invoked from the consumer's project
-// root, but the skills it copies ship alongside this file in the package.
-const skillsRoot = resolve(here, "..", "src", "llms", "skills");
-const packageJson = JSON.parse(readFileSync(resolve(here, "..", "package.json"), "utf-8"));
-const currentVersion = packageJson.version;
-
-// Destination is relative to the consumer's project root (cwd), since
-// that's where their `.claude/` or `.agents/` directory lives.
-const projectRoot = process.cwd();
-
-const TARGETS = {
-  claude: { label: "Claude Code", root: resolve(projectRoot, ".claude", "skills") },
-  agents: { label: "Vendor-neutral (.agents/)", root: resolve(projectRoot, ".agents", "skills") }
-};
-
-function discoverSkills() {
-  if (!existsSync(skillsRoot)) return [];
-  return readdirSync(skillsRoot, { withFileTypes: true })
-    .filter(entry => entry.isDirectory() && entry.name.startsWith(SKILL_PREFIX))
-    .map(entry => entry.name)
-    .sort();
-}
-
-function displayPath(absPath) {
-  return `./${relative(projectRoot, absPath)}`;
-}
-
-function readInstalledVersion(dir) {
-  const markerPath = resolve(dir, VERSION_MARKER);
-  if (!existsSync(markerPath)) return null;
-  try {
-    return JSON.parse(readFileSync(markerPath, "utf-8")).version ?? null;
-  } catch {
-    return null;
-  }
-}
-
-function writeRealCopy(sourceDir, destDir) {
-  mkdirSync(dirname(destDir), { recursive: true });
-  // force: true makes re-running after a version bump overwrite cleanly.
-  cpSync(sourceDir, destDir, { recursive: true, force: true });
-  writeFileSync(resolve(destDir, VERSION_MARKER), JSON.stringify({ version: currentVersion }, null, 2) + "\n");
-}
-
-function writeSymlink(linkPath, targetPath) {
-  mkdirSync(dirname(linkPath), { recursive: true });
-  // lstat (not existsSync, which follows symlinks) catches a broken/stale
-  // symlink left over from a prior run, not just a real file or directory.
-  if (lstatSync(linkPath, { throwIfNoEntry: false })) {
-    rmSync(linkPath, { recursive: true, force: true });
-  }
-  symlinkSync(relative(dirname(linkPath), targetPath), linkPath);
-}
-
-function removeOrphanedSkills(selected, skills, both) {
-  const bundledSkills = new Set(skills);
-  const selectedTargets = both ? ["agents", "claude"] : selected;
-
-  for (const key of selectedTargets) {
-    const { root } = TARGETS[key];
-    if (!existsSync(root)) continue;
-
-    const orphanedSkills = readdirSync(root).filter(name => name.startsWith(`${SKILL_PREFIX}-`) && !bundledSkills.has(name));
-    for (const name of orphanedSkills) {
-      rmSync(resolve(root, name), { recursive: true, force: true });
-      // In the two-target layout, .claude/ is a symlinked view of the
-      // canonical .agents/ copy. Remove its matching link along with the
-      // orphaned canonical skill.
-      if (both && key === "agents") {
-        rmSync(resolve(TARGETS.claude.root, name), { recursive: true, force: true });
-      }
-      p.log.info(`Removed orphaned skill: ${name} (no longer in this bundle)`);
-    }
-  }
-}
-
-// A prior install is recoverable from the filesystem, so a re-run doesn't
-// re-ask: a target counts as chosen when any bundled skill is present under
-// it. Symlinks count — they're how the both-targets layout represents
-// .claude/, and lstat avoids following them into the real copy.
-function detectInstalledTargets(skills) {
-  return Object.keys(TARGETS).filter(key =>
-    skills.some(name => lstatSync(resolve(TARGETS[key].root, name), { throwIfNoEntry: false }))
-  );
-}
-
-// Hook templates are installer-owned; the installer copies the scripts into the
-// consumer's .agents/hooks/ and merges the registrations into the host
-// registration files: .claude/settings.json from settings.json, .codex/hooks.json
-// from codex-hooks.json. One pristine template per host, merged verbatim.
-const installTemplatesRoot = resolve(here, "..", "src", "llms", "install-templates");
-const hooksSourceDir = resolve(installTemplatesRoot, "hooks");
-const hooksSettingsTemplate = resolve(installTemplatesRoot, "settings.json");
-const codexHooksTemplate = resolve(installTemplatesRoot, "codex-hooks.json");
-// Installer-owned subdirectory: refreshed wholesale on every run, so a repo's
-// own hooks in .agents/hooks/ are never touched.
-const hooksDestDir = resolve(projectRoot, ".agents", "hooks", "imf-web-ui");
-const settingsPath = resolve(projectRoot, ".claude", "settings.json");
-const codexHooksPath = resolve(projectRoot, ".codex", "hooks.json");
-
-// Serializing the file reflows entries this installer doesn't own; the
-// consumer's own Prettier puts them back. Best-effort: absent, or the path is
-// .prettierignore'd, nothing happens.
-function formatSettings(path) {
-  let toolRoot = projectRoot;
-  while (toolRoot !== dirname(toolRoot) && !existsSync(resolve(toolRoot, "node_modules", ".bin"))) {
-    toolRoot = dirname(toolRoot);
-  }
-  const prettier = resolve(toolRoot, "node_modules", ".bin", "prettier");
-  if (!existsSync(prettier)) return;
-  spawnSync(prettier, ["--write", path], { cwd: projectRoot, stdio: "ignore" });
-}
-
-function installHookScripts() {
-  const scripts = readdirSync(hooksSourceDir).filter(name => name.endsWith(".sh"));
-  mkdirSync(hooksDestDir, { recursive: true });
-  for (const name of scripts) {
-    const dest = resolve(hooksDestDir, name);
-    cpSync(resolve(hooksSourceDir, name), dest, { force: true });
-    chmodSync(dest, 0o755);
-  }
-  // The directory is installer-owned: a script dropped from the template is
-  // removed on refresh, so a stale hook can't keep running after an upgrade.
-  const removed = readdirSync(hooksDestDir).filter(name => name.endsWith(".sh") && !scripts.includes(name));
-  for (const name of removed) {
-    rmSync(resolve(hooksDestDir, name), { force: true });
-  }
-  return { installed: scripts, removed };
-}
-
-// A registration is identified by the script it runs, not the command string:
-// "$VAR/..." and "${VAR}/..." are the same hook.
-const HOOKS_DIR_SEGMENT = ".agents/hooks/imf-web-ui/";
-
-function hookScriptId(command) {
-  if (typeof command !== "string") return null;
-  const at = command.lastIndexOf(HOOKS_DIR_SEGMENT);
-  if (at === -1) return null;
-  // Only a bare script name (plus an optional closing quote) identifies a
-  // registration as installer-owned. Trailing arguments or redirection mean
-  // the consumer customized the command; that counts as foreign, so the
-  // stale-prune below can never delete it.
-  const match = command.slice(at + HOOKS_DIR_SEGMENT.length).match(/^([\w.-]+)["']?$/);
-  return match ? match[1] : null;
-}
-
-function entryScriptIds(entry) {
-  return (entry.hooks ?? []).map(hook => hookScriptId(hook.command)).filter(Boolean);
-}
-
-// Merge, never clobber: a registration is added only when no existing entry
-// for that event already runs the same script, so re-runs are idempotent and
-// hand-written settings survive. The one exception is entries that only run
-// scripts from the installer-owned directory that are no longer shipped —
-// those are pruned, or they would point at a script the refresh just removed.
-// A run that changes nothing writes nothing.
-function mergeHookRegistrations(targetPath, templateHooks, shippedScripts) {
-  let settings = {};
-  if (existsSync(targetPath)) {
-    try {
-      settings = JSON.parse(readFileSync(targetPath, "utf-8"));
-    } catch {
-      return null;
-    }
-  }
-  settings.hooks ??= {};
-  let added = 0;
-  let removed = 0;
-  // Pruning is per hook, not per entry: only an individual hook that
-  // unambiguously runs a no-longer-shipped installer-owned script goes;
-  // consumer hooks sharing the same entry stay.
-  const emptiedEvents = [];
-  for (const [event, entries] of Object.entries(settings.hooks)) {
-    if (!Array.isArray(entries)) continue;
-    let pruned = 0;
-    const kept = entries
-      .map(entry => {
-        if (!Array.isArray(entry.hooks)) return entry;
-        const hooks = entry.hooks.filter(hook => {
-          const script = hookScriptId(hook.command);
-          return script === null || shippedScripts.includes(script);
-        });
-        pruned += entry.hooks.length - hooks.length;
-        return hooks.length === entry.hooks.length ? entry : { ...entry, hooks };
-      })
-      .filter(entry => !Array.isArray(entry.hooks) || entry.hooks.length > 0);
-    if (pruned === 0) continue;
-    removed += pruned;
-    if (kept.length === 0 && !(event in templateHooks)) emptiedEvents.push(event);
-    else settings.hooks[event] = kept;
-  }
-  // An event whose entries were all pruned disappears instead of lingering as [].
-  if (emptiedEvents.length > 0) {
-    settings.hooks = Object.fromEntries(Object.entries(settings.hooks).filter(([event]) => !emptiedEvents.includes(event)));
-  }
-  for (const [event, entries] of Object.entries(templateHooks)) {
-    settings.hooks[event] ??= [];
-    for (const entry of entries) {
-      const scripts = entryScriptIds(entry);
-      const present = settings.hooks[event].some(existing =>
-        entryScriptIds(existing).some(script => scripts.includes(script))
-      );
-      if (!present) {
-        settings.hooks[event].push(entry);
-        added++;
-      }
-    }
-  }
-  if (added === 0 && removed === 0) return { added, removed };
-  mkdirSync(dirname(targetPath), { recursive: true });
-  writeFileSync(targetPath, JSON.stringify(settings, null, 2) + "\n");
-  formatSettings(targetPath);
-  return { added, removed };
-}
-
-// The AGENTS.md baseline note lives inside a fenced block owned by this
-// installer. The template between the markers is the source of truth; an
-// existing AGENTS.md gets the block replaced in place (or appended when
-// absent), everything outside the fence is untouched. No AGENTS.md at all
-// is left alone — scaffolding one is the setup skill's job.
-const AGENTS_BLOCK_BEGIN = "<!-- imf-web-ui:begin";
-const AGENTS_BLOCK_END = "<!-- imf-web-ui:end -->";
-const agentsTemplatePath = resolve(installTemplatesRoot, "AGENTS.md");
-const agentsPath = resolve(projectRoot, "AGENTS.md");
-
-function extractAgentsBlock(content) {
-  const begin = content.indexOf(AGENTS_BLOCK_BEGIN);
-  const end = content.indexOf(AGENTS_BLOCK_END);
-  if (begin === -1 || end === -1) return null;
-  return content.slice(begin, end + AGENTS_BLOCK_END.length);
-}
-
-function upsertAgentsBlock() {
-  if (!existsSync(agentsPath)) return "absent";
-  const block = extractAgentsBlock(readFileSync(agentsTemplatePath, "utf-8"));
-  if (!block) return "absent";
-  const current = readFileSync(agentsPath, "utf-8");
-  const existing = extractAgentsBlock(current);
-  const next = existing ? current.replace(existing, block) : `${current.trimEnd()}\n\n${block}\n`;
-  if (next === current) return "unchanged";
-  writeFileSync(agentsPath, next);
-  return existing ? "updated" : "added";
-}
-
-// --target claude|agents|all (repeatable) selects targets without the
-// interactive prompt — for CI and scripted installs.
-function parseTargetFlags(argv) {
-  const targets = [];
-  for (let i = 0; i < argv.length; i++) {
-    if (argv[i] !== "--target") continue;
-    const value = argv[i + 1];
-    if (!value || (value !== "all" && !(value in TARGETS))) {
-      console.error(`--target expects one of: ${Object.keys(TARGETS).join(", ")}, all`);
-      process.exit(1);
-    }
-    targets.push(...(value === "all" ? ["agents", "claude"] : [value]));
-    i++;
-  }
-  return [...new Set(targets)];
-}
-
-function printHelp() {
-  console.log(`Usage: web-ui-install [options]
-
-Install @imfusion/web-ui agent skills into a consumer project.
-
-Options:
-  --target agents|claude|all  Install into selected skill target(s).
-                              Repeat --target to select multiple targets.
-  --hooks                     Install agent lifecycle hooks.
-  --reconfigure               Re-open target selection prompt.
-  -h, --help                  Show this help.
-`);
-}
-
-async function main() {
-  const argv = process.argv.slice(2);
-  if (argv.length === 0 || argv.includes("-h") || argv.includes("--help")) {
-    printHelp();
-    return;
-  }
-
-  const skills = discoverSkills();
-  const flagTargets = parseTargetFlags(argv);
-  const reconfigure = argv.includes("--reconfigure");
-  // Every install includes the skill bundle. Hooks are opt-in via --hooks —
-  // the consumer's setup workflow drives that after checking what the repo
-  // already registers, but hooks without their companion skills are invalid.
-  const wantHooks = argv.includes("--hooks");
-  const wantSkills = true;
-
-  const components = [wantSkills && `${skills.length} skills`, wantHooks && "agent hooks"].filter(Boolean);
-  p.intro(`@imfusion/web-ui install — ${components.join(" + ")}`);
-
-  if (wantSkills && skills.length === 0) {
-    p.log.error(`No skills found at ${skillsRoot}. Reinstall @imfusion/web-ui and try again.`);
-    p.outro("Nothing installed.");
-    process.exitCode = 1;
-    return;
-  }
-
-  if (wantHooks) {
-    const { installed, removed } = installHookScripts();
-    p.log.success(`Agent hooks -> ${displayPath(hooksDestDir)} (${installed.length} scripts)`);
-    if (removed.length > 0) {
-      p.log.info(`Removed stale hook script(s): ${removed.join(", ")} (no longer shipped)`);
-    }
-    const registrations = [
-      [settingsPath, JSON.parse(readFileSync(hooksSettingsTemplate, "utf-8")).hooks],
-      [codexHooksPath, JSON.parse(readFileSync(codexHooksTemplate, "utf-8")).hooks]
-    ];
-    for (const [path, hooks] of registrations) {
-      const result = mergeHookRegistrations(path, hooks, installed);
-      if (result === null) {
-        p.log.warn(`${displayPath(path)} is not valid JSON — registrations not merged, fix it and re-run.`);
-      } else if (result.added > 0 || result.removed > 0) {
-        const changes = [
-          result.added > 0 && `registered ${result.added}`,
-          result.removed > 0 && `removed ${result.removed} stale`
-        ].filter(Boolean);
-        p.log.success(`${changes.join(", ")} hook registration(s) in ${displayPath(path)}`);
-      } else {
-        p.log.info(`Hook registrations already present in ${displayPath(path)}`);
-      }
-    }
-  }
-
-  const installedTargets = detectInstalledTargets(skills);
-
-  const existingVersions = Object.values(TARGETS)
-    .flatMap(({ root }) => skills.map(name => readInstalledVersion(resolve(root, name))))
-    .filter(Boolean);
-  if (existingVersions.length > 0 && existingVersions.every(v => v === currentVersion)) {
-    p.log.info(`Already up to date (v${currentVersion}). Re-running will overwrite with the same content.`);
-  } else if (existingVersions.some(v => v !== currentVersion)) {
-    const from = existingVersions.find(v => v !== currentVersion);
-    p.log.info(`Updating installed skills from v${from} to v${currentVersion}.`);
-  }
-
-  p.log.message(`Skills in this bundle:\n${skills.map(name => `  - ${name}`).join("\n")}`);
-
-  let selected;
-  if (flagTargets.length > 0) {
-    selected = flagTargets;
-    p.log.info(`Targets from --target flags: ${selected.join(", ")}`);
-  } else if (installedTargets.length > 0 && !reconfigure) {
-    selected = installedTargets;
-    p.log.info(
-      `Refreshing the existing install: ${selected.map(key => displayPath(TARGETS[key].root)).join(", ")}` +
-        ` — pass --reconfigure to choose different targets.`
-    );
-  } else {
-    selected = await p.multiselect({
-      message: "Install into which skill directory (or directories)?",
-      options: Object.entries(TARGETS).map(([key, { label, root }]) => ({
-        value: key,
-        label,
-        hint: displayPath(root)
-      })),
-      required: true
-    });
-
-    if (p.isCancel(selected)) {
-      p.cancel("Cancelled — nothing installed.");
-      return;
-    }
-  }
-
-  const both = selected.includes("claude") && selected.includes("agents");
-
-  for (const name of skills) {
-    const sourceDir = resolve(skillsRoot, name);
-    if (both) {
-      // .agents/ is the canonical real copy; .claude/ aliases it via symlink.
-      const realDir = resolve(TARGETS.agents.root, name);
-      writeRealCopy(sourceDir, realDir);
-      writeSymlink(resolve(TARGETS.claude.root, name), realDir);
-    } else {
-      for (const key of selected) {
-        writeRealCopy(sourceDir, resolve(TARGETS[key].root, name));
-      }
-    }
-  }
-
-  removeOrphanedSkills(selected, skills, both);
-
-  if (both) {
-    p.log.success(`Vendor-neutral (.agents/) -> ${displayPath(TARGETS.agents.root)}/${SKILL_PREFIX}*`);
-    p.log.success(`Claude Code -> ${displayPath(TARGETS.claude.root)}/${SKILL_PREFIX}* (symlinks -> .agents/)`);
-  } else {
-    for (const key of selected) {
-      p.log.success(`${TARGETS[key].label} -> ${displayPath(TARGETS[key].root)}/${SKILL_PREFIX}*`);
-    }
-  }
-
-  const agentsResult = upsertAgentsBlock();
-  if (agentsResult === "updated" || agentsResult === "added") {
-    p.log.success(`Refreshed the imf-web-ui block in ${displayPath(agentsPath)}`);
-  }
-
-  p.outro(`Done — ${skills.length} skills installed${wantHooks ? " + agent hooks" : ""}.`);
-}
-
-await main();

package/dist/build/vite-css-module-names/index.d.ts

@@ -1,20 +0,0 @@
-import { Plugin } from 'vite';
-export interface ReadableCssModuleNamesOptions {
-    /** Namespace for every generated class name. Short, stable, app-scoped (`imf-ui`, `acme`). */
-    prefix: string;
-}
-/**
- * Generates readable CSS Module class names instead of the default hash, so the DOM
- * stays legible in devtools and browser automation. `button.module.css` yields
- * `{prefix}-button-module-root` — `[name]` is the filename, which keeps its `.module`
- * suffix.
- *
- * Register it in every tool that compiles the CSS (the app build AND Storybook). A
- * compiler left out generates different class names for the same source file and its
- * styles silently don't apply.
- *
- * Defaults to opting into Lightning CSS, which drops `css.modules` options it has no
- * equivalent for (`localsConvention`). Set `css.transformer: "postcss"` to stay on
- * the PostCSS pipeline.
- */
-export declare function readableCssModuleNames({ prefix }: ReadableCssModuleNamesOptions): Plugin;

package/dist/build/vite-css-module-names.js

@@ -1,17 +0,0 @@
-//#region src/build/vite-css-module-names/index.ts
-function e(e, t) {
-	let { lightningcss: n, modules: r, transformer: i } = e.css ?? {}, a = n?.cssModules;
-	if (!(typeof a == "boolean" || r === !1) && !a?.pattern && !(typeof r == "object" && r.generateScopedName)) return i === "postcss" ? { css: { modules: { generateScopedName: t } } } : { css: {
-		transformer: "lightningcss",
-		lightningcss: { cssModules: { pattern: t } }
-	} };
-}
-function t({ prefix: t }) {
-	let n = `${t}-[name]-[local]`;
-	return {
-		name: "imf-ui:readable-css-module-names",
-		config: (t) => e(t, n)
-	};
-}
-//#endregion
-export { t as readableCssModuleNames };

package/dist/components/spinner/spinner.geometry.d.ts

@@ -1,37 +0,0 @@
-/**
- * Spinner geometry — the animated ImFusion glyph.
- *
- * The mark is two filled bands separated by an empty diagonal channel (see
- * `logo/imfusion/imfusion.tsx`). This module reproduces that structure as a
- * *morphing* shape: the channel rotates, breathes (its width pulses, never
- * closing), and its interior nodes sway — so the loader reads as the mark
- * alive, not a generic ring.
- *
- * The motion is a live per-frame morph: a single `requestAnimationFrame` loop
- * in the component (spinner.tsx) calls {@link frameGeometry} each frame and
- * writes the two returned path `d` strings straight onto the SVG paths — no
- * React re-render per frame, no SMIL. (SMIL/CSS `d` morphing was tried and
- * dropped: neither is GPU-composited, and CSS `d` isn't supported in Safari.)
- *
- * Everything is tunable from the {@link KNOBS} block. The values there were
- * dialled in against rendered evidence at 16/20/24/96px; the shape is a
- * balance — extreme values pinch the channel shut or spike the bands, so nudge
- * rather than leap. `frameGeometry(t)` is pure and deterministic: feed it a
- * time in ms and it returns the two band path `d`s for that instant.
- */
-/** Design-space edge length; the SVG viewBox is `0 0 D D`. */
-export declare const D = 100;
-/**
- * The two band path `d` strings at time `tms` (ms) — the shape at any instant
- * of the loop, as `[topBand, bottomBand]`. Pure and deterministic; the rAF loop
- * in the component calls this each frame and writes the results to the paths.
- */
-export declare function frameGeometry(tms: number): [string, string];
-/**
- * The period over which the whole composition returns to its start pose — the
- * least-common-multiple-ish window of rotation, breathe, and sway. Rotation is
- * `ROT_S`; breathe/sway are shorter and phase-relative. We loop over the
- * rotation period and let breathe/sway ride within it; `SWAY_RATIO` is chosen
- * so the combined motion reads continuous rather than obviously repeating.
- */
-export declare const LOOP_MS: number;

package/dist/integrations/code-highlight/languages/cmake.d.ts

@@ -1 +0,0 @@
-export declare const cmake: import('@tanstack/highlight/core').LanguageDefinition<"cmake">;

package/dist/integrations/code-highlight/languages/cpp.d.ts

@@ -1 +0,0 @@
-export declare const cpp: import('@tanstack/highlight/core').LanguageDefinition<"cpp">;