@skaile/forge-app-actions 0.0.0-stage → 0.2.0

package/dist/runtime/composables/usePaletteArgStep.js

@@ -0,0 +1,51 @@
+import { computed, ref, shallowRef } from "vue";
+export function usePaletteArgStep() {
+  const action = shallowRef(null);
+  const options = shallowRef([]);
+  const loading = ref(false);
+  let ticket = 0;
+  const active = computed(() => action.value !== null);
+  const prompt = computed(() => action.value?.arg ?? null);
+  function begin(next) {
+    if (!next.arg) return false;
+    action.value = next;
+    options.value = [];
+    void query("");
+    return true;
+  }
+  async function query(text) {
+    const arg = action.value?.arg;
+    if (!arg?.options) {
+      options.value = [];
+      return;
+    }
+    const mine = ++ticket;
+    loading.value = true;
+    try {
+      const found = await arg.options(text);
+      if (mine !== ticket) return;
+      options.value = found;
+    } catch {
+      if (mine === ticket) options.value = [];
+    } finally {
+      if (mine === ticket) loading.value = false;
+    }
+  }
+  function cancel() {
+    ticket++;
+    action.value = null;
+    options.value = [];
+    loading.value = false;
+  }
+  function valueFor(typed, index) {
+    const arg = action.value?.arg;
+    if (!arg) return null;
+    const picked = options.value[index];
+    if (picked) return picked.value;
+    const allowCustom = arg.allowCustom ?? !arg.options;
+    const trimmed = typed.trim();
+    if (allowCustom && trimmed.length > 0) return trimmed;
+    return null;
+  }
+  return { action, options, loading, active, prompt, begin, query, cancel, valueFor };
+}

package/dist/runtime/internal/describe-error.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Turn a thrown value into the single line the agent (or model) will read.
+ *
+ * A zod v4 error carries the useful part in `issues`; `err.message` alone is a
+ * JSON blob. Flatten it to `path: message` pairs so the model can act on it.
+ *
+ * Lives outside `composables/` on purpose: that directory is auto-imported by
+ * the Nuxt module, and this helper is internal.
+ */
+export declare function describeError(err: unknown): string;

package/dist/runtime/internal/describe-error.js

@@ -0,0 +1,12 @@
+export function describeError(err) {
+  if (err && typeof err === "object" && Array.isArray(err.issues)) {
+    const issues = err.issues;
+    const lines = issues.map((issue) => {
+      const path = Array.isArray(issue.path) ? issue.path.join(".") : "";
+      return path ? `${path}: ${issue.message}` : String(issue.message);
+    });
+    if (lines.length > 0) return lines.join("; ");
+  }
+  if (err instanceof Error) return err.message;
+  return String(err);
+}

package/dist/runtime/server/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Explicit entry point for the server-side client-capability bridge, via the
+ * `./server` subpath. In a Nuxt consumer the same symbols are auto-imported
+ * (the module's `addServerImportsDir` on `runtime/server/utils`).
+ */
+export * from "./utils/capability-registry.js";
+export * from "./utils/client-capability-bridge.js";

package/dist/runtime/server/index.js

@@ -0,0 +1,2 @@
+export * from "./utils/capability-registry.js";
+export * from "./utils/client-capability-bridge.js";

package/dist/runtime/server/utils/capability-registry.d.ts

@@ -0,0 +1,35 @@
+import type { AgentEvent, Capability } from "@skaile/workspaces/sdk/types";
+/** Event sink handed to a capability handler when it runs. */
+export interface CapabilityHandlerCtx {
+    /** Emit a synthetic AgentEvent into the app's SSE stream. */
+    emitEvent: (event: AgentEvent) => void;
+}
+export type CapabilityHandler = (input: Record<string, unknown>, ctx: CapabilityHandlerCtx) => Promise<unknown>;
+export interface CapabilityEntry {
+    capability: Capability;
+    handler: CapabilityHandler;
+}
+/**
+ * Plain-TS capability registry for the forge app — holds client-side v2
+ * capabilities and routes `capability_invoked` calls to their handlers.
+ */
+export declare class CapabilityRegistry {
+    private entries;
+    register(entry: CapabilityEntry): void;
+    list(): Capability[];
+    dispatch(name: string, input: Record<string, unknown>, ctx: CapabilityHandlerCtx): Promise<unknown | {
+        error: string;
+    }>;
+}
+/** Dispatch a `capability_invoked` event and send back its `capability_result`. */
+export declare function handleCapabilityInvoked(event: {
+    callId: string;
+    name: string;
+    input: unknown;
+}, deps: {
+    registry: CapabilityRegistry;
+    ctx: CapabilityHandlerCtx;
+    sendResult: (callId: string, result: unknown) => Promise<void> | void;
+}): Promise<void>;
+/** Process-wide singleton — capabilities are registered once at module load. */
+export declare const capabilityRegistry: CapabilityRegistry;

package/dist/runtime/server/utils/capability-registry.js

@@ -0,0 +1,24 @@
+export class CapabilityRegistry {
+  entries = /* @__PURE__ */ new Map();
+  register(entry) {
+    this.entries.set(entry.capability.name, entry);
+  }
+  list() {
+    return [...this.entries.values()].map((e) => e.capability);
+  }
+  async dispatch(name, input, ctx) {
+    const entry = this.entries.get(name);
+    if (!entry) return { error: `Unknown capability: ${name}` };
+    try {
+      return await entry.handler(input, ctx);
+    } catch (err) {
+      return { error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+}
+export async function handleCapabilityInvoked(event, deps) {
+  const input = event.input && typeof event.input === "object" ? event.input : {};
+  const result = await deps.registry.dispatch(event.name, input, deps.ctx);
+  await deps.sendResult(event.callId, result);
+}
+export const capabilityRegistry = new CapabilityRegistry();