@zq-silk/yui 0.2.0 → 0.4.2

package/dist/commands/profileCommands.js

@@ -0,0 +1,203 @@
+import { usageError } from "../errors/cliError.js";
+import { defaultTableWidth, renderTable } from "../output/table.js";
+import { BUILTIN_PROFILE_IDS, builtinAgentProfileInputs, createAgentProfile, updateAgentProfile } from "../profile/agentProfile.js";
+import { parseRoleOptions } from "./roleConfiguration.js";
+export function runProfileCommand(args, store, now = () => new Date()) {
+    const [command, ...rest] = args;
+    switch (command) {
+        case "add": return addProfile(rest, store, now());
+        case "list": return listProfiles(rest, store);
+        case "show": return showProfile(rest, store);
+        case "update": return updateProfile(rest, store, now());
+        case "remove": return removeProfile(rest, store);
+        case "reset": return resetProfiles(rest, store, now());
+        default:
+            throw usageError(command === undefined
+                ? "Profile command is required."
+                : `Unknown command: profile ${command}`);
+    }
+}
+function addProfile(args, store, now) {
+    const usage = "Profile add usage: yui profile add <id> [--access <read|write>] [Profile settings].";
+    const [id, ...tail] = args;
+    if (id === undefined || id.startsWith("--"))
+        throw usageError("Profile id is required.", usage);
+    const parsed = parseProfileOptions(tail, false, usage);
+    const profile = createAgentProfile({
+        id,
+        defaultAccess: parseAccess(parsed.one("--access") ?? "read"),
+        ...profileValues(parsed)
+    }, now);
+    store.transaction((tx) => {
+        if (tx.getAgentProfile(profile.id) !== null) {
+            throw usageError(`Agent Profile already exists: ${profile.id}.`);
+        }
+        tx.saveAgentProfile(profile);
+    });
+    return { output: `Added Agent Profile ${profile.id}\n`, data: { profile } };
+}
+function listProfiles(args, store) {
+    noArgs(args, "Profile list usage: yui profile list.");
+    const profiles = store.listAgentProfiles();
+    const output = profiles.length === 0
+        ? "No Agent Profiles found.\n"
+        : `${renderTable("Agent Profiles", [
+            { header: "Profile", minWidth: 7, maxWidth: 24 },
+            { header: "Revision", minWidth: 8, maxWidth: 10 },
+            { header: "Access", minWidth: 6, maxWidth: 8 },
+            { header: "Description", minWidth: 12, maxWidth: 54 }
+        ], profiles.map((profile) => [
+            profile.id,
+            String(profile.revision),
+            profile.defaultAccess,
+            profile.description ?? "-"
+        ]), defaultTableWidth())}\n`;
+    return { output, data: { profiles } };
+}
+function showProfile(args, store) {
+    const profile = requireProfile(store, oneArg(args, "Profile show usage: yui profile show <id>."));
+    return {
+        output: `${[
+            `Agent Profile: ${profile.id}`,
+            `Revision: ${profile.revision}`,
+            `Default access: ${profile.defaultAccess}`,
+            `Description: ${profile.description ?? "-"}`,
+            `Instructions: ${profile.instructions ?? "-"}`,
+            `Skills: ${profile.skills?.join(", ") || "-"}`,
+            `Model: ${profile.model ?? "-"}`,
+            `Effort: ${profile.effort ?? "-"}`
+        ].join("\n")}\n`,
+        data: { profile }
+    };
+}
+function updateProfile(args, store, now) {
+    const usage = "Profile update usage: yui profile update <id> [--access <read|write>] [Profile settings].";
+    const [id, ...tail] = args;
+    if (id === undefined || id.startsWith("--"))
+        throw usageError("Profile id is required.", usage);
+    const parsed = parseProfileOptions(tail, true, usage);
+    if (parsed.seen.size === 0)
+        throw usageError("At least one Profile option is required.", usage);
+    assertOptionPairs(parsed);
+    const current = requireProfile(store, id);
+    const updated = updateAgentProfile(current, {
+        ...(parsed.has("--access") ? { defaultAccess: parseAccess(parsed.one("--access")) } : {}),
+        ...profilePatch(parsed)
+    }, now);
+    store.saveAgentProfile(updated);
+    return {
+        output: `Updated Agent Profile ${updated.id} to revision ${updated.revision}\n`,
+        data: { profile: updated }
+    };
+}
+function removeProfile(args, store) {
+    const id = oneArg(args, "Profile remove usage: yui profile remove <id>.");
+    if (BUILTIN_PROFILE_IDS.includes(id)) {
+        throw usageError(`Built-in Agent Profile cannot be removed: ${id}. Use profile reset instead.`);
+    }
+    if (!store.removeAgentProfile(id))
+        throw usageError(`Agent Profile not found: ${id}.`);
+    return { output: `Removed Agent Profile ${id}\n`, data: { profileId: id } };
+}
+function resetProfiles(args, store, now) {
+    noArgs(args, "Profile reset usage: yui profile reset.");
+    store.transaction((tx) => {
+        for (const desired of builtinAgentProfileInputs()) {
+            const existing = tx.getAgentProfile(desired.id);
+            tx.saveAgentProfile(existing === null
+                ? createAgentProfile(desired, now)
+                : updateAgentProfile(existing, {
+                    defaultAccess: desired.defaultAccess,
+                    description: desired.description,
+                    instructions: desired.instructions,
+                    skills: desired.skills,
+                    model: desired.model,
+                    effort: desired.effort
+                }, now));
+        }
+    });
+    const profiles = BUILTIN_PROFILE_IDS.map((id) => requireProfile(store, id));
+    return {
+        output: `Reset ${BUILTIN_PROFILE_IDS.length} built-in Agent Profiles\n`,
+        data: { profiles }
+    };
+}
+const BASE_OPTIONS = [
+    ["--access", "value"],
+    ["--description", "value"],
+    ["--instructions", "value"],
+    ["--skill", "repeatable"],
+    ["--model", "value"],
+    ["--effort", "value"]
+];
+const CLEAR_OPTIONS = [
+    ["--clear-description", "flag"],
+    ["--clear-instructions", "flag"],
+    ["--clear-skills", "flag"],
+    ["--clear-model", "flag"],
+    ["--clear-effort", "flag"]
+];
+function parseProfileOptions(args, update, usage) {
+    return parseRoleOptions(args, new Map([
+        ...BASE_OPTIONS,
+        ...(update ? CLEAR_OPTIONS : [])
+    ]), usage);
+}
+function profileValues(parsed) {
+    return {
+        ...(parsed.has("--description") ? { description: requiredText(parsed.one("--description")) } : {}),
+        ...(parsed.has("--instructions") ? { instructions: requiredText(parsed.one("--instructions")) } : {}),
+        ...(parsed.has("--skill") ? { skills: parsed.many("--skill").map(requiredText) } : {}),
+        ...(parsed.has("--model") ? { model: requiredText(parsed.one("--model")) } : {}),
+        ...(parsed.has("--effort") ? { effort: requiredText(parsed.one("--effort")) } : {})
+    };
+}
+function profilePatch(parsed) {
+    return {
+        ...profileValues(parsed),
+        ...(parsed.has("--clear-description") ? { description: undefined } : {}),
+        ...(parsed.has("--clear-instructions") ? { instructions: undefined } : {}),
+        ...(parsed.has("--clear-skills") ? { skills: undefined } : {}),
+        ...(parsed.has("--clear-model") ? { model: undefined } : {}),
+        ...(parsed.has("--clear-effort") ? { effort: undefined } : {})
+    };
+}
+function assertOptionPairs(parsed) {
+    for (const [value, clear] of [
+        ["--description", "--clear-description"],
+        ["--instructions", "--clear-instructions"],
+        ["--skill", "--clear-skills"],
+        ["--model", "--clear-model"],
+        ["--effort", "--clear-effort"]
+    ]) {
+        if (parsed.has(value) && parsed.has(clear)) {
+            throw usageError(`${value} and ${clear} cannot be used together.`);
+        }
+    }
+}
+function requireProfile(store, id) {
+    const profile = store.getAgentProfile(id);
+    if (profile === null)
+        throw usageError(`Agent Profile not found: ${id}.`);
+    return profile;
+}
+function parseAccess(value) {
+    if (value === "read" || value === "write")
+        return value;
+    throw usageError(`Invalid Profile access: ${String(value)}.`);
+}
+function requiredText(value) {
+    const result = value?.trim();
+    if (result === undefined || result.length === 0)
+        throw usageError("Profile option value is required.");
+    return result;
+}
+function oneArg(args, usage) {
+    if (args.length !== 1 || args[0].trim().length === 0)
+        throw usageError(usage);
+    return args[0];
+}
+function noArgs(args, usage) {
+    if (args.length !== 0)
+        throw usageError(usage);
+}