u-foo 1.7.4 → 1.8.0

package/src/cli/groupCoreCommands.js

@@ -6,7 +6,7 @@ const {
   resolveTemplateReference,
   createTemplateFromBuiltin,
 } = require("../group/templates");
-const { validateTemplate } = require("../group/validateTemplate");
+const { validateTemplateTarget } = require("../group/templateValidation");
 
 function parseTemplateNewArgs(args = []) {
   const alias = String(args[0] || "").trim();
@@ -97,15 +97,13 @@ function printList({ templates, errors }, { write, json, cwd }) {
 function formatResolveErrors(errors = []) {
   if (!Array.isArray(errors) || errors.length === 0) return "";
   return errors
-    .map((item) => `${item.filePath}: ${item.error}`)
+    .map((item) => `${item.filePath}: ${item.error || item.message || "unknown error"}`)
     .join("; ");
 }
 
 function throwResolveFailure(target, resolved = {}) {
   const details = formatResolveErrors(resolved.errors || []);
-  if (details) {
-    throw new Error(`Failed to load template "${target}": ${details}`);
-  }
+  if (details) throw new Error(`Failed to load template "${target}": ${details}`);
   throw new Error(`Template not found: ${target}`);
 }
 
@@ -120,6 +118,7 @@ function printValidation(result, target, entry, { write, json }) {
           filePath: entry.filePath,
           ok: result.ok,
           errors: result.errors,
+          prompt_profiles: result.promptProfiles || [],
         },
         null,
         2
@@ -130,6 +129,15 @@ function printValidation(result, target, entry, { write, json }) {
 
   if (result.ok) {
     write(`✓ Template "${entry.alias}" is valid (${entry.source})`);
+    if (Array.isArray(result.promptProfiles) && result.promptProfiles.length > 0) {
+      for (const profile of result.promptProfiles) {
+        write(
+          `  - ${profile.nickname || profile.agent_id || "agent"}: `
+          + `${profile.requested_profile} -> ${profile.resolved_profile} `
+          + `[${profile.profile_source}]`
+        );
+      }
+    }
     return;
   }
 
@@ -144,6 +152,7 @@ async function runGroupCoreCommand(subcmd, cmdArgs = [], options = {}) {
   const write = typeof options.write === "function" ? options.write : console.log;
   const json = Boolean(options.json);
   const templatesOptions = options.templatesOptions || {};
+  const promptProfilesOptions = options.promptProfilesOptions || {};
 
   const args = Array.isArray(cmdArgs) ? cmdArgs.filter((item) => item !== undefined) : [];
   const normalizedSubcmd = String(subcmd || "").trim().toLowerCase();
@@ -205,18 +214,18 @@ async function runGroupCoreCommand(subcmd, cmdArgs = [], options = {}) {
   if (action === "validate") {
     const target = String(args[1] || "").trim();
     if (!target) throw new Error("group template validate requires <alias|path>");
-    const resolved = resolveTemplateReference(cwd, target, {
+    const result = validateTemplateTarget(cwd, target, {
       allowPath: true,
       cwd,
-      ...templatesOptions,
+      templatesOptions,
+      promptProfilesOptions,
     });
-    if (!resolved.entry) {
-      throwResolveFailure(target, resolved);
+    if (!result.entry) {
+      throwResolveFailure(target, { errors: result.errors || [] });
     }
-    const result = validateTemplate(resolved.entry.data);
-    printValidation(result, target, resolved.entry, { write, json });
+    printValidation(result, target, result.entry, { write, json });
     if (!result.ok) {
-      throw new Error(`Template validation failed: ${resolved.entry.alias}`);
+      throw new Error(`Template validation failed: ${result.entry.alias}`);
     }
     return;
   }

package/src/cli.js

@@ -411,7 +411,8 @@ async function runCli(argv) {
       .description("Launch an agent (ucode, uclaude, ucodex)")
       .argument("<agent>", "Agent type: ucode|uclaude|ucodex|claude|codex")
       .argument("[nickname]", "Optional nickname for the agent")
-      .action(async (agent, nickname) => {
+      .option("--profile <id>", "Prompt profile to assign after launch")
+      .action(async (agent, nickname, opts) => {
         try {
           const projectRoot = process.cwd();
           await ensureDaemonRunning(projectRoot);
@@ -436,6 +437,7 @@ async function runCli(argv) {
             type: "launch_agent",
             agent: normalizedAgent,
             nickname: nickname || "",
+            prompt_profile: opts.profile || "",
             count: 1,
             ...collectHostLaunchRequestContext(),
           });
@@ -446,6 +448,26 @@ async function runCli(argv) {
           process.exitCode = 1;
         }
       });
+    program
+      .command("role")
+      .description("Assign a preset role to an existing agent")
+      .argument("<target>", "Agent subscriber id or nickname")
+      .argument("<profile>", "Prompt profile id or alias")
+      .action(async (target, profile) => {
+        try {
+          const projectRoot = process.cwd();
+          await ensureDaemonRunning(projectRoot);
+          const resp = await sendDaemonRequest(projectRoot, {
+            type: "assign_role",
+            target,
+            prompt_profile: profile,
+          });
+          console.log(resp?.data?.reply || `Assigned role ${profile}`);
+        } catch (err) {
+          console.error(err.message || String(err));
+          process.exitCode = 1;
+        }
+      });
     program
       .command("resume")
       .description("Resume agent sessions (optional nickname)")

package/src/daemon/cronOps.js

@@ -128,18 +128,41 @@ function sanitizeSummaryText(value = "") {
     .trim();
 }
 
-function summarizeCronTask(task = {}) {
-  const id = String(task.id || "");
-  const targets = Array.isArray(task.targets) ? task.targets.join("+") : "";
-  const promptRaw = sanitizeSummaryText(task.prompt || "");
-  const prompt = promptRaw.length > 24 ? `${promptRaw.slice(0, 24)}...` : promptRaw;
+function truncateCronText(value = "", maxLength = 24) {
+  const text = String(value || "").trim();
+  if (!text) return "";
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(1, maxLength - 3))}...`;
+}
 
-  if (Number(task.onceAtMs) > 0) {
-    return `${id}@once(${formatCronAtMs(task.onceAtMs)})->${targets}: ${prompt || "(empty)"}`;
-  }
+function normalizeCronTitle(value = "", prompt = "") {
+  const explicitTitle = truncateCronText(
+    sanitizeSummaryText(value || "").replace(/:/g, "-"),
+    24
+  );
+  if (explicitTitle) return explicitTitle;
+  const fallbackTitle = truncateCronText(
+    sanitizeSummaryText(prompt || "").replace(/:/g, "-"),
+    24
+  );
+  return fallbackTitle || "(empty)";
+}
 
-  const interval = formatIntervalMs(task.intervalMs || 0);
-  return `${id}@${interval}->${targets}: ${prompt || "(empty)"}`;
+function buildCronLabel(task = {}) {
+  const targets = Array.isArray(task.targets) && task.targets.length > 0
+    ? task.targets.join("+")
+    : "unknown";
+  const title = normalizeCronTitle(task.title || "", task.prompt || "");
+  const schedule = Number(task.onceAtMs) > 0
+    ? formatCronAtMs(task.onceAtMs)
+    : formatIntervalMs(task.intervalMs || 0);
+  return `${targets}:${title}:${schedule || "0s"}`;
+}
+
+function summarizeCronTask(task = {}) {
+  const id = String(task.id || "");
+  const label = buildCronLabel(task);
+  return id ? `${id} ${label}` : label;
 }
 
 function formatCronTask(task = {}) {
@@ -153,6 +176,8 @@ function formatCronTask(task = {}) {
     onceAt: onceAtMs > 0 ? formatCronAtMs(onceAtMs) : "",
     targets: Array.isArray(task.targets) ? task.targets.slice() : [],
     prompt: String(task.prompt || ""),
+    title: normalizeCronTitle(task.title || "", task.prompt || ""),
+    label: buildCronLabel(task),
     createdAt: Number(task.createdAt) || 0,
     lastRunAt: Number(task.lastRunAt) || 0,
     tickCount: Number(task.tickCount) || 0,
@@ -160,6 +185,10 @@ function formatCronTask(task = {}) {
   };
 }
 
+function resolveCronTitle(op = {}) {
+  return String(op.title || op.name || op.label || "").trim();
+}
+
 function createDaemonCronController(options = {}) {
   const {
     projectRoot = "",
@@ -198,6 +227,7 @@ function createDaemonCronController(options = {}) {
         onceAtMs: task.onceAtMs,
         targets: task.targets.slice(),
         prompt: task.prompt,
+        title: task.title,
         createdAt: task.createdAt,
         lastRunAt: task.lastRunAt,
         tickCount: task.tickCount,
@@ -275,13 +305,14 @@ function createDaemonCronController(options = {}) {
     }, task.intervalMs);
   }
 
-  function addTask({ intervalMs = 0, onceAtMs = 0, targets = [], prompt = "" } = {}) {
+  function addTask({ intervalMs = 0, onceAtMs = 0, targets = [], prompt = "", title = "" } = {}) {
     const safeInterval = Number.parseInt(intervalMs, 10);
     const safeOnceAt = Number.parseInt(onceAtMs, 10);
     const safeTargets = Array.isArray(targets)
       ? targets.map((item) => String(item || "").trim()).filter(Boolean)
       : [];
     const safePrompt = String(prompt || "").trim();
+    const safeTitle = normalizeCronTitle(title, safePrompt);
 
     if (!safePrompt || safeTargets.length === 0) return null;
 
@@ -296,6 +327,7 @@ function createDaemonCronController(options = {}) {
       onceAtMs: useOnce ? safeOnceAt : 0,
       targets: Array.from(new Set(safeTargets)),
       prompt: safePrompt,
+      title: safeTitle,
       createdAt: nowFn(),
       lastRunAt: 0,
       tickCount: 0,
@@ -367,6 +399,7 @@ function createDaemonCronController(options = {}) {
         ? item.targets.map((v) => String(v || "").trim()).filter(Boolean)
         : [];
       const prompt = String(item && item.prompt ? item.prompt : "").trim();
+      const title = normalizeCronTitle(item && item.title ? item.title : "", prompt);
 
       if (!prompt || targets.length === 0) {
         changed = true;
@@ -389,6 +422,7 @@ function createDaemonCronController(options = {}) {
         onceAtMs: Number.isFinite(onceAtMs) ? Math.floor(onceAtMs) : 0,
         targets: Array.from(new Set(targets)),
         prompt,
+        title,
         createdAt: Number(item && item.createdAt) || now,
         lastRunAt: Number(item && item.lastRunAt) || 0,
         tickCount: Number(item && item.tickCount) || 0,
@@ -535,6 +569,7 @@ function createDaemonCronController(options = {}) {
       onceAtMs,
       targets,
       prompt,
+      title: resolveCronTitle(op),
     });
 
     if (!task) {
@@ -567,8 +602,10 @@ module.exports = {
   resolveCronOperation,
   resolveCronIntervalMs,
   resolveCronOnceAtMs,
+  resolveCronTitle,
   resolveCronPrompt,
   resolveCronTaskId,
   parseCronAtMs,
+  buildCronLabel,
   formatCronTask,
 };