@fui-org/fui-cli 2.1.1 → 2.1.3

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-hk5frcn2.js");await e();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fui-org/fui-cli",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "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,49 @@ 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, current: FuiTarget): Promise<FuiDiff | undefined> {
+  const args = ["remote", "diff", "--stat", "--json"];
+  if (current.project && current.module) args.push("-p", current.project, "-m", current.module);
+  const { exitCode, stdout } = await runFui($, args, 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));
@@ -64,22 +102,96 @@ async function projectUrl($: Engine, session: SessionTarget) {
   return httpsUrl(firstDomain(info?.pDomain));
 }
 
-async function sync($: Engine, command: string, lastCommand: string) {
-  const state = (await readJson($, await sessionFile($, command))) as { target?: SessionTarget } | undefined;
-  const session = state?.target;
+async function describe($: Engine, session: SessionTarget | undefined, lastCommand?: string): Promise<FuiTarget> {
   const found: FuiTarget = { lastCommand };
   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);
+  return found;
+}
+
+async function readSessionTarget($: Engine, command: string) {
+  const state = (await readJson($, await sessionFile($, command))) as { target?: SessionTarget } | undefined;
+  return state?.target;
+}
+
+// A folder holding _db or _projectInfo.json is a fui project; <project>/modules/<module> inside it is a module.
+async function folderTarget($: Engine, cwd: string): Promise<SessionTarget | undefined> {
+  const parts = cwd.replace(/\/+$/, "").split("/");
+  for (let end = parts.length; end > 1; end--) {
+    const projectDir = parts.slice(0, end).join("/");
+    if (!(await $.fs.exists(`${projectDir}/_db`)) && !(await $.fs.exists(`${projectDir}/_projectInfo.json`))) continue;
+    const info = (await readJson($, `${projectDir}/_projectInfo.json`)) as { ProjectID?: unknown } | undefined;
+    const projectId = typeof info?.ProjectID === "string" ? info.ProjectID : parts[end - 1];
+    const workspaceRoot = parts.slice(0, end - 1).join("/");
+    const moduleId = parts[end] === "modules" ? parts[end + 1] : undefined;
+    if (moduleId) return { projectId, moduleId, moduleDir: `${projectDir}/modules/${moduleId}`, workspaceRoot };
+    const active = await readSessionTarget($, "");
+    return active?.projectId === projectId ? active : { projectId, workspaceRoot };
+  }
+  return undefined;
+}
+
+let session: string | undefined;
+let isPinned = false;
+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");
+      const current: FuiTarget | null = await read($, target);
+      if (current?.moduleDir) await showDiff($, await remoteDiff($, current));
+    } while (isStale);
+  })().finally(() => {
+    running = undefined;
+  });
 }
 
 export const register: Register = (on) => {
+  on("session.start", async ($, e, next) => {
+    const started = await next(e);
+    const folder = await folderTarget($, e.cwd);
+    isPinned = folder !== undefined;
+    if (folder) {
+      await update($, target, () => null);
+      const found = await describe($, folder);
+      await update($, target, () => found);
+      refreshDiff($);
+    }
+    return started;
+  });
+
   on("prompt.submit", async ($, e, next) => {
-    await update($, target, () => null);
+    if (!isPinned) 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);
   });
 
@@ -88,7 +200,14 @@ export const register: Register = (on) => {
     const call = e.command.match(FUI_CALL);
     if (!call) return result;
 
-    await sync($, e.command, [call[1], call[2]].filter(Boolean).join(" "));
+    session = sessionKey(e.command);
+    const found = await describe(
+      $,
+      await readSessionTarget($, e.command),
+      [call[1], call[2]].filter(Boolean).join(" "),
+    );
+    await update($, target, () => found);
+    if (!(call[1] === "remote" && call[2] === "diff")) refreshDiff($);
     return result;
   });
 
@@ -120,7 +239,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" {