@piagent/platform 1.11.1 → 1.12.1

package/packages/piagent-webui/dist/client/index.html

@@ -7,7 +7,7 @@
     <meta name="csp-nonce" content="__PIAGENT_CSP_NONCE__" />
     <meta name="piagent-webui-mode" content="__PIAGENT_WEBUI_MODE__" />
     <title>Piagent WebUI</title>
-    <script type="module" crossorigin src="/assets/index-BuIJR5rd.js"></script>
+    <script type="module" crossorigin src="/assets/index-DFKHLVYk.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Z91z6SlN.css">
   </head>
   <body>

package/packages/piagent-webui/gateway/gateway-service.ts

@@ -19,6 +19,8 @@ import {
   type GatewayDescriptor
 } from "./profile-state.ts";
 import { buildSessionCatalog, projectRefForCwd } from "./session-catalog.ts";
+import { suggestPaths } from "./path-suggestions.ts";
+import { listAgentCommands } from "../../piagent-core/runtime/resources/agent-resources.mjs";
 import { sessionRefForPath } from "../ownership/session-refs.ts";
 import { SessionMetadataStore } from "./session-metadata-store.ts";
 import { GatewayProtocolService } from "./gateway-protocol-service.ts";
@@ -222,6 +224,9 @@ export async function startPiagentGateway(options: {
     // Every revision the browser sees and sends back is the merged one.
     const hubCatalog = relay ? async () => relay!.merge(await readCatalog()) : readCatalog;
     const company = (sessionRef: unknown) => !!relay?.owns(sessionRef);
+    const projectFolder = async (projectRef: string) => projects.resolve(projectRef)
+      ?? (await runtimes!.listSessions()).find((info) => typeof info.cwd === "string" && projectRefForCwd(key, info.cwd) === projectRef)?.cwd
+      ?? (relay ? (await relay.folders()).find((folder) => projectRefForCwd(key, folder) === projectRef) : undefined);
     const relayPost = (path: string, body: unknown) => relay!.json("POST", path, body);
     const commands = new SessionCommandController({ catalog: hubCatalog, runtimes, metadata,
       store: new SessionCommandStore(state.root, key), events,
@@ -286,6 +291,17 @@ export async function startPiagentGateway(options: {
       // conversation runs (the company Gateway for a company conversation).
       readSessionQuestions: (sessionRef) => company(sessionRef)
         ? relay!.json("GET", `/api/v1/sessions/${encodeURIComponent(sessionRef)}/questions`) : runtimes!.questions(sessionRef),
+      // What an @ or a / in the composer offers, under a folder this dashboard
+      // knows: an imported project or the folder of a conversation (company
+      // ones too).
+      suggestPaths: async (projectRef, query) => {
+        const root = await projectFolder(projectRef);
+        return root ? await suggestPaths({ root, query }) : null;
+      },
+      listCommands: async (projectRef) => {
+        const root = await projectFolder(projectRef);
+        return root ? { commands: listAgentCommands({ cwd: root }) } : null;
+      },
       updates: { status: () => updates!.status(), check: () => updates!.check(), apply: (request) => updates!.apply(request) },
       answerSessionQuestion: (sessionRef, questionRef, answer) => company(sessionRef)
         ? relayPost(`/api/v1/sessions/${encodeURIComponent(sessionRef)}/questions/${encodeURIComponent(questionRef)}/answer`, answer)

package/packages/piagent-webui/gateway/path-suggestions.ts

@@ -0,0 +1,118 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+// What an @ in the composer offers, as Pi's terminal does: files and folders
+// of the project matched loosely by name (fd, which honours .gitignore), and,
+// after a folder and a slash (src/, ~/Documents/, /Volumes/), the names under
+// that folder anywhere on this Mac. Only names reach the browser; no file is
+// opened.
+export type PathSuggestion = { value: string; label: string; detail: string; kind: "file" | "directory" };
+type Entry = { path: string; directory: boolean };
+
+const LIMIT = 20;
+const SEARCH_RESULTS = 100;
+const LISTED_ENTRIES = 5_000;
+// Outside the project a search stays shallow and skips app data and
+// dependency folders: a home folder is far larger than a repository.
+const OUTSIDE_DEPTH = 4;
+const fold = (value: string) => value.normalize("NFC").toLowerCase();
+const escape = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+// A name typed composed (Dự án) may be stored decomposed on disk: either form matches.
+const either = (value: string) => value.normalize("NFC") === value.normalize("NFD") ? escape(value)
+  : `(?:${escape(value.normalize("NFC"))}|${escape(value.normalize("NFD"))})`;
+const inside = (file: string, root: string) => file === root || file.startsWith(root + path.sep);
+
+export function findFd(home = os.homedir()): string | null {
+  for (const candidate of ["/opt/homebrew/bin/fd", "/usr/local/bin/fd", path.join(home, ".pi/agent/bin/fd")]) {
+    try { fs.accessSync(candidate, fs.constants.X_OK); return candidate; } catch { /* next */ }
+  }
+  return null;
+}
+
+// Higher is better: the name itself, then its start, then anywhere in it,
+// then anywhere in the path; a folder before a file with the same score.
+function score(entry: string, query: string, directory: boolean): number {
+  const name = fold(path.basename(entry)), wanted = fold(query);
+  const value = name === wanted ? 100 : name.startsWith(wanted) ? 80 : name.includes(wanted) ? 50 : fold(entry).includes(wanted) ? 30 : 0;
+  return value && directory ? value + 10 : value;
+}
+
+function run(file: string, args: string[], signal?: AbortSignal, input?: string): Promise<string> {
+  return new Promise((resolve) => {
+    const child = execFile(file, args, { encoding: "utf8", timeout: 4_000, maxBuffer: 8 << 20, signal }, (error, stdout) => resolve(error ? "" : stdout));
+    child.stdin?.on("error", () => {}); child.stdin?.end(input ?? "");
+  });
+}
+
+// The folder's own names, without what its repository ignores (dist/,
+// node_modules/), as fd lists them for Pi.
+async function listed(folder: string, signal?: AbortSignal): Promise<Entry[]> {
+  const entries: Entry[] = [];
+  try {
+    for await (const entry of await fs.promises.opendir(folder)) {
+      let directory = entry.isDirectory();
+      if (entry.isSymbolicLink()) try { directory = fs.statSync(path.join(folder, entry.name)).isDirectory(); } catch { /* broken link */ }
+      entries.push({ path: entry.name, directory });
+      if (entries.length >= LISTED_ENTRIES) break;
+    }
+  } catch { /* unreadable */ }
+  if (!entries.length) return entries;
+  const ignored = new Set((await run("/usr/bin/git", ["-C", folder, "check-ignore", "-z", "--stdin"], signal, entries.map((entry) => `${entry.path}\0`).join("")))
+    .split("\0").filter(Boolean));
+  return ignored.size ? entries.filter((entry) => !ignored.has(entry.path)) : entries;
+}
+
+// Names deeper down that match: fd as Pi runs it in the project; shallow and
+// without hidden folders elsewhere; without fd, the files git knows about.
+async function searched(folder: string, query: string, options: { fd: string | null; project: boolean; atRoot: boolean; signal?: AbortSignal }): Promise<Entry[]> {
+  if (options.fd) {
+    const args = ["--base-directory", folder, "--type", "f", "--type", "d", "--max-results", String(SEARCH_RESULTS), "--ignore-case", "--exclude", ".git",
+      ...(options.project ? ["--follow", "--hidden"] : ["--max-depth", String(OUTSIDE_DEPTH), "--exclude", "Library", "--exclude", "node_modules", ...(query.startsWith(".") ? ["--hidden"] : [])]),
+      ...(query.includes("/") ? ["--full-path", query.split("/").filter(Boolean).map(either).join("/")] : [either(query)])];
+    return (await run(options.fd, args, options.signal)).split("\n").filter(Boolean)
+      .map((line) => ({ path: line.replace(/^\.\//, "").replace(/\/$/, ""), directory: line.endsWith("/") }));
+  }
+  if (!options.atRoot) return [];
+  const files = (await run("/usr/bin/git", ["-C", folder, "ls-files", "--cached", "--others", "--exclude-standard", "-z"], options.signal))
+    .split("\0").filter(Boolean).slice(0, 50_000);
+  const folders = new Set<string>();
+  for (const file of files) for (let dir = path.posix.dirname(file); dir !== "."; dir = path.posix.dirname(dir)) folders.add(dir);
+  const wanted = fold(query);
+  return [...[...folders].map((dir) => ({ path: dir, directory: true })), ...files.map((file) => ({ path: file, directory: false }))]
+    .filter((entry) => fold(entry.path).includes(wanted));
+}
+
+export async function suggestPaths(options: { root: string; query: string; home?: string; fd?: string | null; signal?: AbortSignal }): Promise<{ suggestions: PathSuggestion[] }> {
+  const home = options.home ?? os.homedir(), fd = options.fd === undefined ? findFd(home) : options.fd;
+  const root = fs.realpathSync(options.root);
+  const typed = options.query.trim() === "~" ? "~/" : options.query.trim();
+  // Text up to the last slash names a folder: search under it (Pi's scoped
+  // search). When it is not a folder, the whole text is matched in the project.
+  const cut = typed.lastIndexOf("/") + 1;
+  let base = typed.slice(0, cut), name = typed.slice(cut), folder = root;
+  if (base) {
+    try {
+      const candidate = fs.realpathSync(base.startsWith("~/") ? path.join(home, base.slice(2)) : path.resolve(root, base));
+      if (fs.statSync(candidate).isDirectory()) folder = candidate; else { base = ""; name = typed; }
+    } catch { base = ""; name = typed; }
+  }
+  const project = inside(folder, root);
+  const near = await listed(folder, options.signal);
+  const deep = name ? await searched(folder, name, { fd, project, atRoot: folder === root, signal: options.signal }) : [];
+  const seen = new Set<string>(), entries: Array<Entry & { score: number }> = [];
+  for (const entry of [...near, ...deep]) {
+    if (seen.has(entry.path)) continue; seen.add(entry.path);
+    // Hidden entries (.github, .ssh, .zshrc) for a name typed with a dot, and
+    // in the project for any name typed, as Pi's search finds them there.
+    if (entry.path.split("/").some((part) => part.startsWith(".")) && !name.startsWith(".") && !(project && name)) continue;
+    const value = name ? score(entry.path, name.split("/").filter(Boolean).at(-1) ?? name, entry.directory) : 1;
+    if (value > 0) entries.push({ ...entry, score: value });
+  }
+  const depth = (entry: Entry) => entry.path.split("/").length;
+  entries.sort((a, b) => b.score - a.score || depth(a) - depth(b)
+    || (name ? a.path.length - b.path.length : Number(b.directory) - Number(a.directory)) || a.path.localeCompare(b.path));
+  return { suggestions: entries.slice(0, LIMIT).map((entry) => ({ value: `${base}${entry.path}${entry.directory ? "/" : ""}`,
+    label: path.basename(entry.path) + (entry.directory ? "/" : ""), detail: `${base}${entry.path}`, kind: entry.directory ? "directory" : "file" })) };
+}

package/packages/piagent-webui/gateway/session-runtime-supervisor.ts

@@ -426,7 +426,9 @@ export class SessionRuntimeSupervisor {
       if (!file) throw new Error("session-fork-unavailable");
       forkManager = this.#host.SessionManager.open(file);
     } else {
-      forkManager = this.#host.SessionManager.forkFrom(source.path, source.cwd);
+      // Managed members keep sessions flat in one folder; Pi would otherwise write
+      // the fork into its per-cwd folder, where the gateway never finds it again.
+      forkManager = this.#host.SessionManager.forkFrom(source.path, source.cwd, this.#sessionDirectory);
     }
     if (title) forkManager.appendSessionInfo(title);
     const file = forkManager.getSessionFile(), id = forkManager.getSessionId?.();

package/packages/piagent-webui/server/loopback-server.ts

@@ -70,6 +70,8 @@ export async function startLoopbackServer(options: {
   executeApproval?: (approvalRef: string, decision: unknown) => unknown | Promise<unknown>;
   readSessionQuestions?: (sessionRef: string) => unknown | Promise<unknown>;
   answerSessionQuestion?: (sessionRef: string, questionRef: string, answer: unknown) => unknown | Promise<unknown>;
+  suggestPaths?: (projectRef: string, query: string) => unknown | Promise<unknown>;
+  listCommands?: (projectRef: string) => unknown | Promise<unknown>;
   updates?: UpdateRoutes;
   bootstrapTtlMs?: number;
   sessionTtlMs?: number;

package/packages/piagent-webui/server/member-routes.ts

@@ -4,12 +4,14 @@ import { errorResponse, jsonResponse, requestBody } from "./http-security.ts";
 import type { SessionAuthority } from "./session-auth.ts";
 
 // Requests a member makes beside a conversation: answering the main agent's
-// questions, and keeping Piagent itself up to date. Reads need the browser
-// session; every change also needs this origin, the session's CSRF token and
-// a share of the control rate.
+// questions, what an @ or a / in the composer offers, and keeping
+// Piagent itself up to date. Reads need the browser session; every change
+// also needs this origin, the session's CSRF token and a share of the control
+// rate.
 const MAX_CONTROL_BODY_BYTES = 70_000;
 const CURSOR = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,159}$/;
 const QUESTION_PATH = /^\/api\/v1\/sessions\/([^/]+)\/questions(?:\/([^/]+)\/answer)?$/;
+const PROJECT_PATH = /^\/api\/v1\/projects\/([^/]+)\/(paths|commands)$/;
 
 export type UpdateRoutes = {
   // What is installed, what is available, and the last update run.
@@ -27,6 +29,11 @@ type Context = {
 type Options = {
   readSessionQuestions?: (sessionRef: string) => unknown | Promise<unknown>;
   answerSessionQuestion?: (sessionRef: string, questionRef: string, answer: unknown) => unknown | Promise<unknown>;
+  // Names under the project (or the folder typed after ~/ or /); null when the
+  // project is not one this dashboard knows.
+  suggestPaths?: (projectRef: string, query: string) => unknown | Promise<unknown>;
+  // The project's and the member's commands and skills; null as above.
+  listCommands?: (projectRef: string) => unknown | Promise<unknown>;
   updates?: UpdateRoutes;
 };
 
@@ -76,6 +83,18 @@ export async function routeMemberRequest(context: Context, options: Options): Pr
     }
     return true;
   }
+  const project = request.method === "GET" ? PROJECT_PATH.exec(url.pathname) : null;
+  const read = project?.[2] === "paths" ? options.suggestPaths : project ? options.listCommands : undefined;
+  if (project && read) {
+    if (!auth.authenticate(request)) { errorResponse(response, 401, "authentication-required"); return true; }
+    const projectRef = decodeURIComponent(project[1]), query = url.searchParams.get("query") ?? "";
+    if (!CURSOR.test(projectRef) || query.length > 512 || /[\x00-\x1f]/.test(query)) { errorResponse(response, 400, `invalid-${project[2] === "paths" ? "path" : "command"}-query`); return true; }
+    try {
+      const value = await read(projectRef, query);
+      if (value === null) errorResponse(response, 404, "project-not-found"); else jsonResponse(response, 200, value);
+    } catch { errorResponse(response, 503, `${project[2] === "paths" ? "path-suggestions" : "commands"}-unavailable`); }
+    return true;
+  }
 
   if (!options.updates || !url.pathname.startsWith("/api/v1/updates")) return false;
   const updates = options.updates;

package/packages/piagent-webui/server/transcript-projection.ts

@@ -98,7 +98,13 @@ function userMessageProjection(message: any): { text: string; attachments: Trans
   // hashing them here would turn the chat bubble into a document dump and make
   // a bounded UI digest an oracle over user files. The first block is the exact
   // text the operator typed; the remaining recognized blocks become cards.
-  return { text: attachments.length ? String(textParts[0]?.text ?? "") : messageText(message), attachments: attachments.slice(0, 4) };
+  return { text: typedSkillCall(attachments.length ? String(textParts[0]?.text ?? "") : messageText(message)), attachments: attachments.slice(0, 4) };
+}
+// A skill the member called (/skill:name): the message holds the skill's
+// instructions for the model; the chat shows what was typed.
+function typedSkillCall(text: string): string {
+  const skill = /^<skill name="([^"\n]+)" location="[^"\n]+">\n[\s\S]*?\n<\/skill>(?:\n\n([\s\S]+))?$/.exec(text);
+  return skill ? `/skill:${skill[1]}${skill[2] ? ` ${skill[2]}` : ""}` : text;
 }
 // A company request fails with Studio's (or Agent Watch's) own code: who
 // failed, which kind of failure, and Studio's request id. Text is never shown.