@polka-codes/cli 0.9.99 → 0.9.100

package/dist/index.js

@@ -112338,7 +112338,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.9.99";
+var version = "0.9.100";
 
 // src/commands/agent.ts
 init_src();
@@ -117712,13 +117712,15 @@ init_prompts2();
 
 // src/workflows/task.workflow.ts
 init_src();
+init_zod();
 init_workflow_utils();
 var SYSTEM_PROMPT = `You are a generic AI assistant.
 You are able to perform simple tasks including making simple changes, reading code, and answering user questions.
 Use the available tools to perform the task.`;
+var TaskOutputSchema = exports_external.any().describe("A JSON value with the task result");
 var taskWorkflow = async (input2, context) => {
   const { logger, step } = context;
-  const { task, additionalTools } = input2;
+  const { task, additionalTools, jsonMode } = input2;
   logger.info(`
 Running generic agent...
 `);
@@ -117740,33 +117742,44 @@ Running generic agent...
   if (additionalTools?.mcpTools) {
     agentTools.push(...additionalTools.mcpTools);
   }
-  await step("agent", async () => {
+  const result = await step("agent", async () => {
     const defaultContext = await getDefaultContext("task");
     const userMessage = `${task}
 
 ${defaultContext}`;
-    await agentWorkflow({
+    return await agentWorkflow({
       systemPrompt: SYSTEM_PROMPT,
       userMessage: [{ role: "user", content: userMessage }],
-      tools: agentTools
+      tools: agentTools,
+      outputSchema: jsonMode ? TaskOutputSchema : undefined
     }, context);
   });
   logger.info(`
 Agent finished!
 `);
-  return { success: true };
+  return result;
 };
 
 // src/workflows/meta.workflow.ts
 var DecisionSchema = exports_external.object({
   workflow: exports_external.enum(["code", "task"])
 });
+var MetaOutputSchema = exports_external.object({
+  workflow: exports_external.enum(["code", "task"]).describe("The workflow that was executed"),
+  success: exports_external.boolean().describe("Whether the workflow completed successfully"),
+  summary: exports_external.string().optional().describe("Summary of what was done"),
+  error: exports_external.string().optional().describe("Error message if the workflow failed")
+});
 var metaWorkflow = async (input2, context) => {
   const { task } = input2;
   const { logger } = context;
   if (!task) {
     logger.error("Task is not defined in the input for metaWorkflow.");
-    return;
+    return {
+      workflow: "task",
+      success: false,
+      error: "Task is not defined in the input for metaWorkflow."
+    };
   }
   logger.info(`
 Deciding which workflow to use for task...
@@ -117783,27 +117796,67 @@ Deciding which workflow to use for task...
     outputSchema: DecisionSchema
   }, context);
   if (result.type !== "Exit" || !result.object) {
-    throw new Error(`Could not decide which workflow to run. Agent exited with reason: ${result.type}`);
+    const errorMsg = `Could not decide which workflow to run. Agent exited with reason: ${result.type}`;
+    logger.error(errorMsg);
+    return {
+      workflow: "task",
+      success: false,
+      error: errorMsg
+    };
   }
   const decision = result.object;
   if (!decision.workflow) {
-    throw new Error("Could not decide which workflow to run.");
+    const errorMsg = "Could not decide which workflow to run.";
+    logger.error(errorMsg);
+    return {
+      workflow: "task",
+      success: false,
+      error: errorMsg
+    };
   }
   logger.info(`
 Decision: Using '${decision.workflow}' workflow.`);
   switch (decision.workflow) {
-    case "code":
-      await codeWorkflow({ task, interactive: input2.interactive, additionalTools: input2.additionalTools }, context);
-      break;
-    case "task":
-      await taskWorkflow({
+    case "code": {
+      const codeResult = await codeWorkflow({ task, interactive: input2.interactive, additionalTools: input2.additionalTools }, context);
+      return {
+        workflow: "code",
+        success: codeResult.success,
+        summary: codeResult.summaries?.join(`
+`),
+        error: codeResult.success === false ? codeResult.reason : undefined
+      };
+    }
+    case "task": {
+      const taskResult = await taskWorkflow({
         task,
         interactive: input2.interactive,
         additionalTools: input2.additionalTools
       }, context);
-      break;
-    default:
-      throw new Error(`Unknown workflow: ${decision.workflow}`);
+      if (taskResult.type === "Exit") {
+        return {
+          workflow: "task",
+          success: true,
+          summary: taskResult.message
+        };
+      } else if (taskResult.type === "Error") {
+        return {
+          workflow: "task",
+          success: false,
+          error: taskResult.error.message
+        };
+      } else {
+        return {
+          workflow: "task",
+          success: false,
+          error: "Usage limit exceeded"
+        };
+      }
+    }
+    default: {
+      const errorMsg = `Unknown workflow: ${decision.workflow}`;
+      throw new Error(errorMsg);
+    }
   }
 };
 
@@ -117957,12 +118010,28 @@ async function fix3(options = {}) {
     onUsageMeterCreated: onUsage
   });
 }
+async function task2(options) {
+  const { task: taskInput, jsonMode, interactive, onUsage, ...context } = options;
+  const verbose = context.silent ? -1 : context.verbose ?? 0;
+  const logger = createLogger({ verbose });
+  const workflowInput = {
+    task: taskInput,
+    jsonMode
+  };
+  return runWorkflow(taskWorkflow, workflowInput, {
+    commandName: "task",
+    context,
+    logger,
+    interactive: interactive !== false,
+    onUsageMeterCreated: onUsage
+  });
+}
 async function plan3(options = {}) {
-  const { task: task2, fileContent, planFile, files, mode, interactive, onUsage, ...context } = options;
+  const { task: task3, fileContent, planFile, files, mode, interactive, onUsage, ...context } = options;
   const verbose = context.silent ? -1 : context.verbose ?? 0;
   const logger = createLogger({ verbose });
   const workflowInput = {
-    task: task2,
+    task: task3,
     fileContent,
     filePath: planFile,
     files,
@@ -118025,8 +118094,8 @@ var readStdin = async (timeoutMs = COMMAND_CONSTANTS.DEFAULT_STDIN_TIMEOUT_MS) =
     });
   });
 };
-async function runCode(task2, _options, command) {
-  let taskInput = task2;
+async function runCode(task3, _options, command) {
+  let taskInput = task3;
   const stdin = await readStdin();
   if (stdin) {
     taskInput = stdin;
@@ -118113,7 +118182,20 @@ init_lodash();
 init_dist();
 
 // src/builtin-commands.ts
-var BUILT_IN_COMMANDS = ["code", "commit", "pr", "review", "fix", "plan", "workflow", "run", "init", "meta", "skills"];
+var BUILT_IN_COMMANDS = [
+  "code",
+  "commit",
+  "pr",
+  "review",
+  "fix",
+  "plan",
+  "task",
+  "workflow",
+  "run",
+  "init",
+  "meta",
+  "skills"
+];
 
 // src/configPrompt.ts
 init_dist18();
@@ -119444,15 +119526,15 @@ class McpServer {
     const taskExtra = { ...extra, taskStore: extra.taskStore };
     const createTaskResult = args ? await Promise.resolve(handler20.createTask(args, taskExtra)) : await Promise.resolve(handler20.createTask(taskExtra));
     const taskId = createTaskResult.task.taskId;
-    let task2 = createTaskResult.task;
-    const pollInterval = task2.pollInterval ?? 5000;
-    while (task2.status !== "completed" && task2.status !== "failed" && task2.status !== "cancelled") {
+    let task3 = createTaskResult.task;
+    const pollInterval = task3.pollInterval ?? 5000;
+    while (task3.status !== "completed" && task3.status !== "failed" && task3.status !== "cancelled") {
       await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError2(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
       }
-      task2 = updatedTask;
+      task3 = updatedTask;
     }
     return await extra.taskStore.getTaskResult(taskId);
   }
@@ -120273,10 +120355,10 @@ Parameters:
         ...providerOverrideSchema.shape
       }),
       handler: async (args, toolContext) => {
-        const { task: task2 } = args;
+        const { task: task3 } = args;
         const providerOverride = extractProviderOverride(args);
-        logger.info(`MCP: Executing code workflow - task: "${task2}"${providerOverride?.provider ? ` with provider: ${providerOverride.provider}` : ""}`);
-        return await executeWorkflow(codeWorkflow, { task: task2 }, "code", logger, providerOverride, toolContext.defaultProvider);
+        logger.info(`MCP: Executing code workflow - task: "${task3}"${providerOverride?.provider ? ` with provider: ${providerOverride.provider}` : ""}`);
+        return await executeWorkflow(codeWorkflow, { task: task3 }, "code", logger, providerOverride, toolContext.defaultProvider);
       }
     },
     {
@@ -120359,9 +120441,9 @@ Parameters:
         ...providerOverrideSchema.shape
       }),
       handler: async (args, toolContext) => {
-        const { task: task2 } = args;
+        const { task: task3 } = args;
         const providerOverride = extractProviderOverride(args);
-        logger.info(`MCP: Executing plan workflow - task: "${task2}"${providerOverride?.provider ? ` with provider: ${providerOverride.provider}` : ""}`);
+        logger.info(`MCP: Executing plan workflow - task: "${task3}"${providerOverride?.provider ? ` with provider: ${providerOverride.provider}` : ""}`);
         try {
           const context = createExecutionContext(logger);
           const finalProvider = providerOverride?.provider || toolContext.defaultProvider?.provider;
@@ -120377,7 +120459,7 @@ Parameters:
           if (finalApiKey) {
             context.apiKey = finalApiKey;
           }
-          const result = await runWorkflow(planWorkflow, { task: task2, interactive: false }, {
+          const result = await runWorkflow(planWorkflow, { task: task3, interactive: false }, {
             commandName: "plan",
             context,
             logger,
@@ -120457,10 +120539,10 @@ Parameters:
         ...providerOverrideSchema.shape
       }),
       handler: async (args, toolContext) => {
-        const { task: task2 } = args;
+        const { task: task3 } = args;
         const providerOverride = extractProviderOverride(args);
-        logger.info(`MCP: Executing fix workflow - task: "${task2}"${providerOverride?.provider ? ` with provider: ${providerOverride.provider}` : ""}`);
-        return await executeWorkflow(fixWorkflow, { task: task2 }, "fix", logger, providerOverride, toolContext.defaultProvider);
+        logger.info(`MCP: Executing fix workflow - task: "${task3}"${providerOverride?.provider ? ` with provider: ${providerOverride.provider}` : ""}`);
+        return await executeWorkflow(fixWorkflow, { task: task3 }, "fix", logger, providerOverride, toolContext.defaultProvider);
       }
     },
     {
@@ -121420,14 +121502,14 @@ async function executeScript(script, name18, logger, args = []) {
 }
 
 // src/commands/meta.ts
-async function runMeta(task2, command) {
+async function runMeta(task3, command) {
   const workflowOpts = getBaseWorkflowOptions(command);
-  const { verbose } = workflowOpts;
+  const { verbose, json: json2 } = workflowOpts;
   const logger = createLogger({
-    verbose
+    verbose: json2 ? -1 : verbose
   });
-  if (task2) {
-    const trimmedTask = task2.trim();
+  if (task3) {
+    const trimmedTask = task3.trim();
     const words2 = trimmedTask.split(/\s+/);
     if (words2.length === 1) {
       const matched = await tryExecuteCommand(words2[0], logger);
@@ -121436,7 +121518,7 @@ async function runMeta(task2, command) {
       }
       logger.error(`Error: Unknown command '${words2[0]}'`);
       logger.info("Available commands:");
-      logger.info("  Built-in: code, commit, pr, review, fix, plan, workflow, run");
+      logger.info("  Built-in: code, commit, pr, review, fix, plan, task, workflow, run");
       const config4 = await loadConfig2();
       if (config4?.scripts) {
         const scriptNames = Object.keys(config4.scripts);
@@ -121456,15 +121538,19 @@ async function runMeta(task2, command) {
       return;
     }
     const workflowInput2 = {
-      task: task2,
+      task: task3,
+      jsonMode: json2 === true,
       ...workflowOpts
     };
-    await runWorkflow(metaWorkflow, workflowInput2, {
+    const result2 = await runWorkflow(metaWorkflow, workflowInput2, {
       commandName: "meta",
       context: workflowOpts,
       logger,
       ...workflowOpts
     });
+    if (json2 && result2) {
+      console.log(JSON.stringify(result2, null, 2));
+    }
     return;
   }
   const input2 = await getUserInput("What do you want to work on?");
@@ -121481,7 +121567,7 @@ async function runMeta(task2, command) {
     }
     logger.error(`Error: Unknown command '${words[0]}'`);
     logger.info("Available commands:");
-    logger.info("  Built-in: code, commit, pr, review, fix, plan, workflow, run");
+    logger.info("  Built-in: code, commit, pr, review, fix, plan, task, workflow, run");
     return;
   }
   if (words.length < 2) {
@@ -121492,14 +121578,18 @@ async function runMeta(task2, command) {
   }
   const workflowInput = {
     task: input2,
+    jsonMode: json2 === true,
     ...workflowOpts
   };
-  await runWorkflow(metaWorkflow, workflowInput, {
+  const result = await runWorkflow(metaWorkflow, workflowInput, {
     commandName: "meta",
     context: workflowOpts,
     logger,
     ...workflowOpts
   });
+  if (json2 && result) {
+    console.log(JSON.stringify(result, null, 2));
+  }
 }
 async function tryExecuteCommand(commandName, logger) {
   if (BUILT_IN_COMMANDS.includes(commandName)) {
@@ -121527,8 +121617,8 @@ async function tryExecuteCommand(commandName, logger) {
 
 // src/commands/plan.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-var planCommand = new Command("plan").description("Create or update a plan for a task.").argument("[task]", "The task to plan.").option("-p, --plan-file <path>", "The path to the plan file.").action(async (task2, options, command) => {
-  let taskInput = task2;
+var planCommand = new Command("plan").description("Create or update a plan for a task.").argument("[task]", "The task to plan.").option("-p, --plan-file <path>", "The path to the plan file.").action(async (task3, options, command) => {
+  let taskInput = task3;
   let fileContent;
   if (options.planFile) {
     try {
@@ -121899,10 +121989,33 @@ skillsCommand.command("validate").description("Validate a skill's structure and
   }
 });
 
+// src/commands/task.ts
+async function runTask(taskInput, options, command) {
+  const workflowOpts = getBaseWorkflowOptions(command);
+  if (options.json) {
+    workflowOpts.silent = true;
+  }
+  const result = await task2({
+    task: taskInput ?? "",
+    jsonMode: options.json === true,
+    ...workflowOpts
+  });
+  if (options.json) {
+    if (result) {
+      if (result.type === "Exit" && result.object) {
+        console.log(JSON.stringify(result.object, null, 2));
+      } else {
+        console.log(JSON.stringify(result, null, 2));
+      }
+    }
+  }
+}
+var taskCommand = new Command("task").description("Run a generic task using an AI agent.").argument("[task]", "The task to perform").option("--json", "Output result as JSON").action(runTask);
+
 // src/commands/workflow.ts
 init_src();
 import { readFile as readFile14 } from "node:fs/promises";
-async function runWorkflowCommand(task2, _options, command) {
+async function runWorkflowCommand(task3, _options, command) {
   const workflowOpts = getBaseWorkflowOptions(command);
   const { verbose } = workflowOpts;
   const logger = createLogger({ verbose });
@@ -121973,10 +122086,10 @@ async function runWorkflowCommand(task2, _options, command) {
   };
   const selectedWorkflow = workflowDef.workflows[workflowId];
   const workflowInput = {};
-  if (selectedWorkflow.inputs && selectedWorkflow.inputs.length > 0 && task2) {
+  if (selectedWorkflow.inputs && selectedWorkflow.inputs.length > 0 && task3) {
     const firstInput = selectedWorkflow.inputs[0];
-    workflowInput[firstInput.id] = task2;
-    logger.info(`Workflow input '${firstInput.id}': ${task2}`);
+    workflowInput[firstInput.id] = task3;
+    logger.info(`Workflow input '${firstInput.id}': ${task3}`);
   } else if (selectedWorkflow.inputs && selectedWorkflow.inputs.length > 0) {
     logger.info(`Workflow expects inputs: ${selectedWorkflow.inputs.map((i2) => i2.id).join(", ")}`);
   } else {
@@ -121996,7 +122109,7 @@ var workflowCommand = new Command("workflow").description("Run custom workflows.
 globalThis.AI_SDK_LOG_WARNINGS = false;
 var program2 = new Command;
 program2.name("polka").description("Polka Codes CLI").version(version);
-program2.argument("[task]", "The task to execute").action((task2, _options, command) => runMeta(task2, command));
+program2.argument("[task]", "The task to execute").action((task3, _options, command) => runMeta(task3, command));
 program2.addCommand(initCommand);
 program2.addCommand(agentCommand);
 program2.addCommand(commitCommand);
@@ -122005,6 +122118,7 @@ program2.addCommand(reviewCommand);
 program2.addCommand(planCommand);
 program2.addCommand(codeCommand);
 program2.addCommand(fixCommand);
+program2.addCommand(taskCommand);
 program2.addCommand(runCommand);
 program2.addCommand(skillsCommand);
 program2.addCommand(mcpServerCommand);
@@ -122023,6 +122137,7 @@ process.on("uncaughtException", (error48) => {
   }
 });
 export {
+  task2 as task,
   reviewCode,
   plan3 as plan,
   fix3 as fix,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polka-codes/cli",
-  "version": "0.9.99",
+  "version": "0.9.100",
   "license": "AGPL-3.0",
   "author": "github@polka.codes",
   "type": "module",