@fui-org/fui-cli 2.0.0 → 2.1.1

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-bmg5pnmq.js");await e();
+import{enableCompileCache as a}from"node:module";a?.();var{run:e}=await import("./fui-kchph3mb.js");await e();

package/package.json

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

package/skills/fui-target/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "fui-target",
+  "version": "1.0.0",
+  "description": "Shows the FUI project and module the fui CLI targets, once a Claude Code session runs fui",
+  "types": "./types/index.d.ts"
+}

package/skills/fui-target/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }

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

@@ -0,0 +1,127 @@
+import { atom, read, update } from "claude-code";
+import type { EngineInterface as Engine, Register } from "claude-code";
+
+import type { FuiTarget } from "../types";
+
+type SessionTarget = { projectId?: string; moduleId?: string; moduleDir?: string; workspaceRoot?: string };
+
+const target = atom({ plugin: "fui-target", key: "target" } as const, null);
+
+// 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("HOME")}/.fui/session`;
+  return `${dir}/cli-${key}.json`;
+}
+
+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.projectUrl = await projectUrl($, session);
+    found.moduleUrl = session.moduleId ? await moduleUrl($, session) : undefined;
+  }
+  await update($, target, () => found);
+}
+
+export const register: Register = (on) => {
+  on("prompt.submit", async ($, e, next) => {
+    await update($, target, () => null);
+    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;
+
+    await sync($, e.command, [call[1], call[2]].filter(Boolean).join(" "));
+    return result;
+  });
+
+  on("ui.render", { component: "AbovePrompt" }, async ($, e, next) => {
+    const current: FuiTarget | null = await read($, target);
+    if (e.props.hasSurvey || current === null) return next(e);
+
+    const { Box, Text, Link } = $.ui.resolve(e);
+    return (
+      <Box flexDirection="row" columnGap={1}>
+        <Text>🧩</Text>
+        {current.project ? (
+          <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>}
+      </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

@@ -0,0 +1,13 @@
+export type FuiTarget = {
+  project?: string;
+  module?: string;
+  projectUrl?: string;
+  moduleUrl?: string;
+  lastCommand?: string;
+};
+
+declare module "claude-code" {
+  interface PluginState {
+    "fui-target": { target: FuiTarget | null };
+  }
+}