@fui-org/fui-cli 2.1.1 → 2.1.2

package/dist/fui.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import{enableCompileCache as a}from"node:module";a?.();var{run:e}=await import("./fui-kchph3mb.js");await e();
+import{enableCompileCache as a}from"node:module";a?.();var{run:e}=await import("./fui-x86j3m2z.js");await e();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fui-org/fui-cli",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Token-lean CLI for the FUI low-code platform (Node.js)",
   "keywords": [
     "ai",

package/skills/fui/SKILL.md

@@ -67,7 +67,7 @@ description: Use the `fui` CLI for all FUI (low-code platform) work — projects
    - Unchanged files are skipped via the publish ledger.
 5. `fui file status` lists what is still unpublished.
 
-`fui remote module --part ui|html|script|css|load|components|imports` and `fui remote project --part config|modules|…` show the server copy without touching the workspace. `fui remote diff <path...>` compares local files with the server.
+`fui remote module --part ui|html|script|css|load|components|imports` and `fui remote project --part config|modules|…` show the server copy without touching the workspace. `fui remote diff [path...]` compares local files with the server (no path: the whole target module); `--stat` adds the +/- line counts.
 
 Ask the user before `module delete`, `component delete`, `import delete` and `user remove`.
 

package/skills/fui-target/hooks/register.tsx

@@ -1,7 +1,7 @@
 import { atom, read, update } from "claude-code";
 import type { EngineInterface as Engine, Register } from "claude-code";
 
-import type { FuiTarget } from "../types";
+import type { FuiDiff, FuiTarget } from "../types";
 
 type SessionTarget = { projectId?: string; moduleId?: string; moduleDir?: string; workspaceRoot?: string };
 
@@ -12,11 +12,47 @@ const FUI_CALL = /(?:^|[;&|(]|\bthen|\bdo)\s*(?:[A-Za-z_]\w*=\S*\s+)*(?:bunx\s+)
 
 // Mirrors sessionFile() in src/core/session/state.ts.
 async function sessionFile($: Engine, command: string) {
-  const key = command.match(/FUI_SESSION=([A-Za-z0-9_-]+)/)?.[1] ?? (await $.env.get("FUI_SESSION")) ?? "default";
+  const key = sessionKey(command) ?? (await $.env.get("FUI_SESSION")) ?? "default";
   const dir = (await $.env.get("FUI_SESSION_DIR")) ?? `${await $.env.get("HOME")}/.fui/session`;
   return `${dir}/cli-${key}.json`;
 }
 
+const EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+
+function sessionKey(command: string) {
+  return command.match(/FUI_SESSION=([A-Za-z0-9_-]+)/)?.[1];
+}
+
+async function runFui($: Engine, args: string[], session: string | undefined) {
+  const env = session ? { FUI_SESSION: session } : undefined;
+  try {
+    return await $.process.run(["fui", ...args], { env, timeoutMs: 30_000 });
+  } catch {
+    // fui is often on a PATH only the login shell sets up (bun, nvm).
+    const shell = (await $.env.get("SHELL")) ?? "/bin/zsh";
+    return await $.process.run([shell, "-lc", `fui ${args.join(" ")}`], { env, timeoutMs: 30_000 });
+  }
+}
+
+// Runs in the background: the numbers land on the line, never in the model's context.
+async function remoteDiff($: Engine, session: string | undefined): Promise<FuiDiff | undefined> {
+  const { exitCode, stdout } = await runFui($, ["remote", "diff", "--stat", "--json"], session).catch(() => ({
+    exitCode: 1,
+    stdout: "",
+  }));
+  if (exitCode !== 0) return undefined;
+  try {
+    const rows = JSON.parse(stdout.slice(stdout.indexOf("["))) as { added?: number; removed?: number }[];
+    return {
+      files: rows.length,
+      added: rows.reduce((sum, row) => sum + (row.added ?? 0), 0),
+      removed: rows.reduce((sum, row) => sum + (row.removed ?? 0), 0),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
 async function readJson($: Engine, path: string): Promise<unknown> {
   try {
     return JSON.parse(await $.fs.read(path));
@@ -71,24 +107,65 @@ async function sync($: Engine, command: string, lastCommand: string) {
   if (session?.projectId) {
     found.project = session.projectId;
     found.module = session.moduleId;
+    found.moduleDir = session.moduleDir;
     found.projectUrl = await projectUrl($, session);
     found.moduleUrl = session.moduleId ? await moduleUrl($, session) : undefined;
   }
   await update($, target, () => found);
 }
 
+let session: string | undefined;
+let isStale = false;
+let running: Promise<void> | undefined;
+
+async function showDiff($: Engine, diff: FuiTarget["diff"]) {
+  const current: FuiTarget | null = await read($, target);
+  if (current?.moduleDir) await update($, target, () => ({ ...current, diff }));
+}
+
+function refreshDiff($: Engine) {
+  isStale = false;
+  running ??= (async () => {
+    do {
+      isStale = false;
+      await showDiff($, "pending");
+      await showDiff($, await remoteDiff($, session));
+    } while (isStale);
+  })().finally(() => {
+    running = undefined;
+  });
+}
+
 export const register: Register = (on) => {
   on("prompt.submit", async ($, e, next) => {
     await update($, target, () => null);
     return next(e);
   });
 
+  on("tool.call", async ($, e, next) => {
+    const result = await next(e);
+    if (!EDIT_TOOLS.has(e.tool)) return result;
+    const current: FuiTarget | null = await read($, target);
+    const path =
+      (e as { file_path?: string; notebook_path?: string }).file_path ??
+      (e as { notebook_path?: string }).notebook_path;
+    if (current?.moduleDir && path?.startsWith(`${current.moduleDir}/`)) isStale = true;
+    return result;
+  });
+
+  on("turn.complete", async ($, e, next) => {
+    if (isStale) refreshDiff($);
+    return next(e);
+  });
+
   on("tool.call", { tool: "Bash" }, async ($, e, next) => {
     const result = await next(e);
     const call = e.command.match(FUI_CALL);
     if (!call) return result;
 
+    session = sessionKey(e.command);
     await sync($, e.command, [call[1], call[2]].filter(Boolean).join(" "));
+    if (!(call[1] === "remote" && call[2] === "diff")) refreshDiff($);
     return result;
   });
 
@@ -120,7 +197,23 @@ export const register: Register = (on) => {
         ) : (
           <Text dimColor>no active module</Text>
         )}
-        {current.lastCommand && <Text dimColor> · fui {current.lastCommand}</Text>}
+        {current.diff === "pending" && <Text dimColor> · diff…</Text>}
+        {current.diff && current.diff !== "pending" && (
+          <Text>
+            <Text dimColor> · </Text>
+            {current.diff.files === 0 ? (
+              <Text dimColor>in sync</Text>
+            ) : (
+              <Text>
+                <Text>{`${current.diff.files} file${current.diff.files === 1 ? "" : "s"} `}</Text>
+                <Text color="green">{`+${current.diff.added}`}</Text>
+                <Text> </Text>
+                <Text color="red">{`−${current.diff.removed}`}</Text>
+              </Text>
+            )}
+          </Text>
+        )}
+        {current.lastCommand && <Text dimColor>{` · fui ${current.lastCommand}`}</Text>}
       </Box>
     );
   });

package/skills/fui-target/types/index.d.ts

@@ -1,9 +1,13 @@
+export type FuiDiff = { files: number; added: number; removed: number };
+
 export type FuiTarget = {
   project?: string;
   module?: string;
+  moduleDir?: string;
   projectUrl?: string;
   moduleUrl?: string;
   lastCommand?: string;
+  diff?: FuiDiff | "pending";
 };
 
 declare module "claude-code" {