@fui-org/fui-cli 2.1.0 → 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-cx180e19.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.0",
+  "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,43 +1,171 @@
 import { atom, read, update } from "claude-code";
-import type { Engine, Register } 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 };
 
 const target = atom({ plugin: "fui-target", key: "target" } as const, null);
 
-const FUI_CALL = /(?:^|[\s;&|(])fui\s+([a-z-]+)(?:\s+([a-z-]+))?/;
+// fui must be the program a shell segment runs, so `grep fui src` or `cd fui-cli` never count.
+const FUI_CALL = /(?:^|[;&|(]|\bthen|\bdo)\s*(?:[A-Za-z_]\w*=\S*\s+)*(?:bunx\s+)?fui\s+([a-z-]+)(?:\s+([a-z-]+))?/m;
 
 // 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 dir =
-    (await $.env.get("FUI_SESSION_DIR")) ??
-    (await $.env.get("FUI_MCP_SESSION_DIR")) ??
-    `${await $.env.get("HOME")}/.fui-mcp/session`;
+  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`;
 }
 
-async function sync($: Engine, command: string, lastCommand: string) {
-  const text = await $.fs.read(await sessionFile($, command)).catch(() => "");
-  let state: { target?: { projectId?: string; moduleId?: string } } = {};
+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 {
-    state = JSON.parse(text || "{}");
-  } catch {}
+    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 });
+  }
+}
 
-  await update($, target, () => ({
-    project: state.target?.projectId,
-    module: state.target?.moduleId,
-    lastCommand,
+// 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));
+  } catch {
+    return undefined;
+  }
+}
+
+function httpsUrl(raw: unknown): string | undefined {
+  if (typeof raw !== "string" || !raw.trim()) return undefined;
+  const text = raw.trim();
+  try {
+    return new URL(text.startsWith("//") ? `https:${text}` : /^https?:\/\//i.test(text) ? text : `https://${text}`)
+      .href;
+  } catch {
+    return undefined;
+  }
+}
+
+// pDomain is a host, or on multi-domain projects a JSON array of hosts kept as a string (see parseDomainField).
+function firstDomain(raw: unknown): string | undefined {
+  if (typeof raw !== "string") return undefined;
+  const text = raw.trim();
+  if (!text.startsWith("[")) return text || undefined;
+  try {
+    const hosts: unknown = JSON.parse(text);
+    return Array.isArray(hosts) && typeof hosts[0] === "string" ? hosts[0].trim() : undefined;
+  } catch {
+    return text;
+  }
+}
+
+async function moduleUrl($: Engine, session: SessionTarget) {
+  const info = (await readJson($, `${session.moduleDir}/_moduleInfo.json`)) as { url?: unknown } | undefined;
+  if (info?.url) return httpsUrl(info.url);
+  const list = await readJson($, `${session.workspaceRoot}/${session.projectId}/modules/_modules.json`);
+  const row = Array.isArray(list) ? list.find((item) => item?.ModuleID === session.moduleId) : undefined;
+  return httpsUrl(row?.url);
+}
+
+async function projectUrl($: Engine, session: SessionTarget) {
+  const info = (await readJson($, `${session.workspaceRoot}/${session.projectId}/_projectInfo.json`)) as
+    | { pDomain?: unknown }
+    | undefined;
+  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;
+  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);
+}
+
+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;
   });
 
@@ -45,26 +173,47 @@ export const register: Register = (on) => {
     const current: FuiTarget | null = await read($, target);
     if (e.props.hasSurvey || current === null) return next(e);
 
-    const { Box, Text } = $.ui.resolve(e);
+    const { Box, Text, Link } = $.ui.resolve(e);
     return (
       <Box flexDirection="row" columnGap={1}>
         <Text>🧩</Text>
         {current.project ? (
           <Text>
-            <Text bold color="cyan">
-              {current.project}
-            </Text>
-            {current.module && (
-              <Text>
-                <Text dimColor> › </Text>
-                <Text bold>{current.module}</Text>
+            {current.projectUrl ? (
+              <Link href={current.projectUrl}>{current.project}</Link>
+            ) : (
+              <Text bold color="cyan">
+                {current.project}
               </Text>
             )}
+            {current.module && <Text dimColor> › </Text>}
+            {current.module &&
+              (current.moduleUrl ? (
+                <Link href={current.moduleUrl}>{current.module}</Link>
+              ) : (
+                <Text bold>{current.module}</Text>
+              ))}
           </Text>
         ) : (
           <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/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  // Claude Code compiles hooks against its global `h`. Run /plugin-types from the repo root to write .claude/types.
+  "compilerOptions": {
+    "target": "es2023",
+    "lib": ["es2023"],
+    "types": [],
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "jsx": "react",
+    "jsxFactory": "h",
+    "jsxFragmentFactory": "Fragment"
+  },
+  "include": ["../../.claude/types", "hooks", "types"]
+}

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

@@ -1,4 +1,14 @@
-export type FuiTarget = { project?: string; module?: string; lastCommand?: string };
+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" {
   interface PluginState {