@zq-silk/yui 0.2.0 → 0.4.2

package/dist/cli/completion.js

@@ -1,4 +1,5 @@
 import { ROOT_COMMAND, listPublicCommandPaths, orderedImmediateTokens, visibleChildren } from "./commandCatalog.js";
+import { findInteractionPolicy } from "./interactionPolicy.js";
 export function renderCompletion(shell, identity = "yui") {
     const entries = collectEntries(ROOT_COMMAND);
     switch (shell) {
@@ -12,10 +13,13 @@ function collectEntries(root) {
     const entries = [];
     const visit = (node) => {
         if (!node.hidden && !node.commandPathArguments) {
+            const policy = findInteractionPolicy(node);
             entries.push({
                 path: node.path.slice(1).join(" "),
                 immediate: orderedImmediateTokens(node),
-                options: node.options
+                options: node.options,
+                dynamicArguments: policy?.selectors.flatMap((selector) => selector.argumentIndex === undefined ? [] : [selector.argumentIndex]) ?? [],
+                dynamicOptions: policy?.selectors.flatMap((selector) => selector.option === undefined ? [] : [selector.option]) ?? []
             });
         }
         visibleChildren(node).forEach(visit);
@@ -30,18 +34,34 @@ function renderBash(entries, identity) {
     const functionName = identity === "yui" ? "_yui" : "_yui_dev";
     return `${manifest("# yui command:")}
 ${functionName}() {
-  local current path dynamic_candidate
+  local current path previous dynamic_candidate dynamic=false
   local -a candidates dynamic_candidates
   current="\${COMP_WORDS[COMP_CWORD]}"
   path=""
   if (( COMP_CWORD > 1 )); then
     path="\${COMP_WORDS[*]:1:COMP_CWORD-1}"
   fi
-  while IFS= read -r dynamic_candidate; do
-    [[ -n "$dynamic_candidate" ]] && dynamic_candidates+=("$dynamic_candidate")
-  done < <(command ${identity} completion candidates "$current" -- "\${COMP_WORDS[@]:1:COMP_CWORD-1}" 2>/dev/null)
-  if (( \${#dynamic_candidates[@]} > 0 )); then
+  previous="\${COMP_WORDS[COMP_CWORD-1]}"
+  if [[ "$current" != -* ]]; then
+    case "$COMP_CWORD:$path" in
+${bashDynamicArgumentCases(entries)}
+    esac
+  fi
+  if [[ "$dynamic" == false ]]; then
+    case "$previous:$path" in
+${bashDynamicOptionCases(entries)}
+    esac
+  fi
+  if [[ "$dynamic" == true ]]; then
+    while IFS= read -r dynamic_candidate; do
+      [[ -n "$dynamic_candidate" ]] && dynamic_candidates+=("$dynamic_candidate")
+    done < <(command ${identity} completion candidates "$current" -- "\${COMP_WORDS[@]:1:COMP_CWORD-1}" 2>/dev/null)
     candidates=("\${dynamic_candidates[@]}")
+  elif [[ "$current" == -* ]]; then
+    case "$path" in
+${bashStaticOptionCases(entries)}
+      *) candidates=();;
+    esac
   else
     case "$path" in
 ${entries.map((entry) => `      ${bashPattern(entry.path)}) candidates=(${[...entry.immediate, ...entry.options].map(shellQuote).join(" ")});;`).join("\n")}
@@ -56,18 +76,34 @@ complete -F ${functionName} ${identity}
 function renderZsh(entries, identity) {
     return `#compdef ${identity}
 ${manifest("# yui command:")}
-local current path dynamic_output
+local current command_path previous dynamic_output dynamic=false
 local -a candidates
 current="$words[CURRENT]"
-path=""
+command_path=""
 if (( CURRENT > 2 )); then
-  path="\${(j: :)words[2,CURRENT-1]}"
+  command_path="\${(j: :)words[2,CURRENT-1]}"
+fi
+previous="$words[CURRENT-1]"
+if [[ "$current" != -* ]]; then
+  case "$CURRENT:$command_path" in
+${zshDynamicArgumentCases(entries)}
+  esac
 fi
-dynamic_output="$(command ${identity} completion candidates "$current" -- "\${(@)words[2,CURRENT-1]}" 2>/dev/null)"
-if [[ -n "$dynamic_output" ]]; then
+if [[ "$dynamic" == false ]]; then
+  case "$previous:$command_path" in
+${zshDynamicOptionCases(entries)}
+  esac
+fi
+if [[ "$dynamic" == true ]]; then
+  dynamic_output="$(command ${identity} completion candidates "$current" -- "\${(@)words[2,CURRENT-1]}" 2>/dev/null)"
   candidates=("\${(@f)dynamic_output}")
+elif [[ "$current" == -* ]]; then
+  case "$command_path" in
+${zshStaticOptionCases(entries)}
+    *) candidates=();;
+  esac
 else
-  case "$path" in
+  case "$command_path" in
 ${entries.map((entry) => `    ${zshPattern(entry.path)}) candidates=(${[...entry.immediate, ...entry.options].map(shellQuote).join(" ")});;`).join("\n")}
     *) candidates=();;
   esac
@@ -76,24 +112,112 @@ fi
 `;
 }
 function renderFish(entries, identity) {
+    const prefix = `__${identity.replaceAll("-", "_")}`;
     const lines = [
         manifest("# yui command:"),
-        `function __${identity.replaceAll("-", "_")}_dynamic`,
-        `  ${identity} completion candidates (commandline -ct) -- (commandline -opc | string split ' ' | tail -n +2) 2>/dev/null`,
+        `function ${prefix}_at_path`,
+        "  set -l actual (commandline -opc)",
+        "  set -e actual[1]",
+        "  test (count $actual) -eq (count $argv); or return 1",
+        "  for index in (seq (count $argv))",
+        "    test \"$actual[$index]\" = \"$argv[$index]\"; or return 1",
+        "  end",
         "end",
-        `complete -c ${identity} -f -a '(__${identity.replaceAll("-", "_")}_dynamic)'`
+        `function ${prefix}_at_command_options`,
+        "  string match -q -- '-*' (commandline -ct); or return 1",
+        "  set -l actual (commandline -opc)",
+        "  set -e actual[1]",
+        "  test (count $actual) -ge (count $argv); or return 1",
+        "  for index in (seq (count $argv))",
+        "    test \"$actual[$index]\" = \"$argv[$index]\"; or return 1",
+        "  end",
+        "end",
+        `function ${prefix}_needs_dynamic`,
+        "  set -l mode $argv[1]",
+        "  set -l expected $argv[2]",
+        "  set -l expected_path $argv[3..-1]",
+        "  set -l actual (commandline -opc)",
+        "  set -e actual[1]",
+        "  test (count $actual) -ge (count $expected_path); or return 1",
+        "  for index in (seq (count $expected_path))",
+        "    test \"$actual[$index]\" = \"$expected_path[$index]\"; or return 1",
+        "  end",
+        "  if test \"$mode\" = argument",
+        "    string match -q -- '-*' (commandline -ct); and return 1",
+        "    test (count $actual) -eq \"$expected\"",
+        "  else",
+        "    test \"$actual[-1]\" = \"$expected\"",
+        "  end",
+        "end",
+        `function ${prefix}_dynamic`,
+        "  set -l words (commandline -opc)",
+        `  ${identity} completion candidates (commandline -ct) -- $words[2..-1] 2>/dev/null`,
+        "end"
     ];
     for (const entry of entries) {
-        const candidates = [...entry.immediate, ...entry.options].join(" ");
-        if (candidates.length === 0)
-            continue;
-        const condition = entry.path.length === 0
-            ? "__fish_use_subcommand"
-            : `__fish_seen_subcommand_from ${entry.path.split(" ").map(fishQuote).join(" ")}`;
-        lines.push(`complete -c ${identity} -n '${condition}' -a '${escapeSingle(candidates)}'`);
+        for (const argument of entry.dynamicArguments) {
+            const condition = `${prefix}_needs_dynamic argument ${argument} ${fishPath(entry.path)}`;
+            lines.push(`complete -c ${identity} -f -n ${fishQuote(condition)} -a '(${prefix}_dynamic)'`);
+        }
+        for (const option of entry.dynamicOptions) {
+            const condition = `${prefix}_needs_dynamic option ${option} ${fishPath(entry.path)}`;
+            lines.push(`complete -c ${identity} -f -n ${fishQuote(condition)} -a '(${prefix}_dynamic)'`);
+        }
+    }
+    for (const entry of entries) {
+        if (entry.immediate.length > 0) {
+            const condition = entry.path.length === 0
+                ? "__fish_use_subcommand"
+                : `${prefix}_at_path ${fishPath(entry.path)}${fishInitialDynamicExclusion(entry, prefix)}`;
+            lines.push(`complete -c ${identity} -f -n ${fishQuote(condition)} -a '${escapeSingle(entry.immediate.join(" "))}'`);
+        }
+        if (entry.options.length > 0) {
+            const path = fishPath(entry.path);
+            const exact = `${prefix}_at_path ${path}${fishInitialDynamicExclusion(entry, prefix)}`;
+            const condition = `begin; ${exact}; end; or ${prefix}_at_command_options ${path}`;
+            lines.push(`complete -c ${identity} -f -n ${fishQuote(condition)} -a '${escapeSingle(entry.options.join(" "))}'`);
+        }
     }
     return `${lines.join("\n")}\n`;
 }
+function bashDynamicArgumentCases(entries) {
+    return entries.flatMap((entry) => entry.dynamicArguments.map((argument) => `    ${dynamicArgumentPattern(argument + 1, entry.path)}) dynamic=true;;`)).join("\n");
+}
+function zshDynamicArgumentCases(entries) {
+    return entries.flatMap((entry) => entry.dynamicArguments.map((argument) => `  ${dynamicArgumentPattern(argument + 2, entry.path)}) dynamic=true;;`)).join("\n");
+}
+function dynamicArgumentPattern(position, path) {
+    return `${position}:${shellQuote(path)}|${position}:${shellQuote(`${path} `)}*`;
+}
+function bashDynamicOptionCases(entries) {
+    return entries.flatMap((entry) => entry.dynamicOptions.map((option) => `      ${dynamicOptionPattern(option, entry.path)}) dynamic=true;;`)).join("\n");
+}
+function zshDynamicOptionCases(entries) {
+    return entries.flatMap((entry) => entry.dynamicOptions.map((option) => `    ${dynamicOptionPattern(option, entry.path)}) dynamic=true;;`)).join("\n");
+}
+function dynamicOptionPattern(option, path) {
+    return `${shellQuote(`${option}:${path}`)}|${shellQuote(`${option}:${path} `)}*`;
+}
+function bashStaticOptionCases(entries) {
+    return staticOptionEntries(entries).map((entry) => `      ${commandPrefixPattern(entry.path)}) candidates=(${entry.options.map(shellQuote).join(" ")});;`).join("\n");
+}
+function zshStaticOptionCases(entries) {
+    return staticOptionEntries(entries).map((entry) => `    ${commandPrefixPattern(entry.path)}) candidates=(${entry.options.map(shellQuote).join(" ")});;`).join("\n");
+}
+function staticOptionEntries(entries) {
+    return entries.filter((entry) => entry.options.length > 0)
+        .sort((left, right) => right.path.split(" ").length - left.path.split(" ").length);
+}
+function commandPrefixPattern(path) {
+    return `${shellQuote(path)}|${shellQuote(`${path} `)}*`;
+}
+function fishInitialDynamicExclusion(entry, prefix) {
+    const initial = entry.dynamicArguments.filter((position) => position === entry.path.split(" ").filter(Boolean).length);
+    return initial.map((position) => `; and not ${prefix}_needs_dynamic argument ${position} ${fishPath(entry.path)}`).join("");
+}
+function fishPath(path) {
+    return path.split(" ").filter(Boolean).join(" ");
+}
 function bashPattern(path) {
     return path.length === 0 ? '""' : shellQuote(path);
 }

package/dist/cli/helpRenderer.js

@@ -22,8 +22,10 @@ function describeOption(option) {
         "--agent": "Select an Agent.",
         "--base": "Set the base Git reference.",
         "--input": "Set dispatch input.",
+        "--host": "Set the loopback listen address.",
+        "--port": "Set the local listen port.",
         "--json": "Emit machine-readable JSON.",
-        "--repository": "Select a repository.",
+        "--project": "Select a Project.",
         "--role": "Select a Task role.",
         "--summary": "Set summary text.",
         "--task": "Select a Task."

package/dist/cli/interactionCandidates.js

@@ -4,38 +4,47 @@ export async function getSelectionCandidates(selector, ports, args) {
         case "tasks":
             return entities("task", "Select task", (await list(ports, "task.list", {})).filter((task) => selector.statuses === undefined
                 || selector.statuses.includes(stringField(task, "status") ?? "")), ["id", "title", "status"]);
-        case "repositories":
-            return entities("repository", "Select repository", await list(ports, "repository.list", {}), ["id", "name", "path"]);
+        case "projects":
+            return entities("project", "Select Project", await list(ports, "project.list", {}), ["id", "name", "path"]);
         case "configured-agents": {
-            const agents = await list(ports, "agent.list", {});
+            const agents = (await list(ports, "agent.list", {})).filter((agent) => selector.adapterIds === undefined
+                || selector.adapterIds.includes(stringField(agent, "adapterId") ?? ""));
             const config = await optionalEntity(ports, "config.get", {});
-            const defaultValue = config === undefined
+            const configuredDefault = config === undefined
                 ? undefined
                 : stringField(config, "defaultAgent");
+            const defaultValue = agents.some((agent) => stringField(agent, "id") === configuredDefault) ? configuredDefault : undefined;
             const set = entities("agent", "Select Agent", agents.map((agent) => ({
                 ...agent,
                 default: stringField(agent, "id") === defaultValue ? "default" : ""
             })), ["id", "adapterId", "command", "default"]);
             return { ...set, defaultValue };
         }
+        case "agent-profiles":
+            return entities("Agent Profile", "Select Agent Profile", await list(ports, "profile.list", {}), ["id", "revision", "defaultAccess", "agentId"]);
         case "global-roles":
             return entities("global role", "Select global Role", await list(ports, "role.list", {}), ["name", "activeAgentId", "workspace"]);
         case "jobs":
             return entities("job", "Select job", await list(ports, "jobs.list", {}), ["id", "type", "status"]);
         case "input-requests": {
             const taskId = dependencyValue(selector, args);
-            return entities("input request", taskId === undefined ? "Select input request" : `Select input request: ${taskId}`, (await list(ports, "task.input.list", {
+            const requests = (await list(ports, "task.input.list", {
                 ...(taskId === undefined ? {} : { taskId }),
                 all: true
             })).filter((request) => selector.statuses === undefined
-                || selector.statuses.includes(stringField(request, "status") ?? "")), ["id", "taskId", "status", "question"]);
+                || selector.statuses.includes(stringField(request, "status") ?? ""));
+            return entities("input request", taskId === undefined ? "Select input request" : `Select input request: ${taskId}`, taskId === undefined ? qualifyTaskRecords(requests) : requests, taskId === undefined
+                ? ["qualifiedId", "status", "question"]
+                : ["id", "status", "question"]);
         }
         case "task-roles": {
             const taskId = dependencyValue(selector, args);
             if (taskId === undefined)
                 return null;
             const roles = orderRoleOptions(await list(ports, "task.role.list", { taskId }));
-            return entities("task role", `Select Task role: ${taskId}`, roles, ["name", "kind", "agentId"]);
+            return entities("task role", `Select Task role: ${taskId}`, roles, [
+                "name", "kind", "activeAgentId"
+            ]);
         }
         case "task-decisions": {
             const taskId = dependencyValue(selector, args);
@@ -58,11 +67,40 @@ export async function getSelectionCandidates(selector, ports, args) {
             return entities("event", `Select Event: ${taskId}`, await list(ports, "task.event.list", { taskId }), ["id", "type", "createdAt"]);
         }
         case "work-items":
-            return entities("work item", "Select work item", await listAllWorkItems(ports), ["id", "title", "status"]);
-        case "runs":
-            return entities("run", "Select run", await listAllRuns(ports), ["id", "status", "workItemId"]);
+            return entities("work item", "Select work item", qualifyTaskRecords(await listAllWorkItems(ports)), ["qualifiedId", "title", "status"]);
+        case "runs": {
+            const workItemId = dependencyValue(selector, args);
+            const runs = await listAllByTask(ports, "task.run.list", "runs");
+            return entities("run", workItemId === undefined ? "Select Run" : `Select Run: ${workItemId}`, qualifyTaskRecords(runs.filter((run) => workItemId === undefined
+                || matchesTaskRecordReference(run, "workItemId", workItemId))), ["qualifiedId", "roleName", "status", "summary"]);
+        }
+        case "integration-attempts":
+            return entities("Integration Attempt", "Select Integration Attempt", qualifyTaskRecords((await listAllByTask(ports, "task.integration.list", "integrations")).filter((attempt) => selector.statuses === undefined
+                || selector.statuses.includes(stringField(attempt, "status") ?? ""))), ["qualifiedId", "status", "targetRef"]);
+        case "change-sets": {
+            const taskId = dependencyValue(selector, args);
+            if (taskId === undefined)
+                return null;
+            return entities("ChangeSet", `Select ChangeSet: ${taskId}`, await list(ports, "task.change-set.list", { taskId }), ["id", "workItemId", "baseCommit", "headCommit"]);
+        }
     }
 }
+function qualifyTaskRecords(input) {
+    return input.flatMap((entity) => {
+        const taskId = stringField(entity, "taskId");
+        const id = stringField(entity, "id");
+        return taskId === undefined || id === undefined
+            ? []
+            : [{ ...entity, qualifiedId: `${taskId}/${id}` }];
+    });
+}
+function matchesTaskRecordReference(entity, field, reference) {
+    const separator = reference.indexOf("/");
+    if (separator < 0)
+        return false;
+    return stringField(entity, "taskId") === reference.slice(0, separator)
+        && stringField(entity, field) === reference.slice(separator + 1);
+}
 async function listAllWorkItems(ports) {
     const tasks = await list(ports, "task.list", {});
     const groups = await Promise.all(tasks.flatMap((task) => {
@@ -71,11 +109,11 @@ async function listAllWorkItems(ports) {
     }));
     return groups.flat();
 }
-async function listAllRuns(ports) {
-    const workItems = await listAllWorkItems(ports);
-    const groups = await Promise.all(workItems.flatMap((item) => {
-        const workItemId = stringField(item, "id");
-        return workItemId === undefined ? [] : [list(ports, "task.run.list", { workItemId })];
+async function listAllByTask(ports, method, resultKey) {
+    const tasks = await list(ports, "task.list", {});
+    const groups = await Promise.all(tasks.flatMap((task) => {
+        const taskId = stringField(task, "id");
+        return taskId === undefined ? [] : [list(ports, method, { taskId, resultKey })];
     }));
     return groups.flat();
 }