@polka-codes/cli 0.9.98 → 0.9.100

package/dist/index.js

@@ -112338,7 +112338,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.9.98";
+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);
   }
@@ -120125,10 +120207,12 @@ init_code_workflow();
 init_fix_workflow();
 init_plan_workflow();
 init_review_workflow();
-var memoryStoreCache = null;
-async function getMemoryStore(logger) {
-  if (memoryStoreCache) {
-    return memoryStoreCache;
+var memoryStoreCache = new Map;
+async function getMemoryStore(logger, projectPath) {
+  const normalizedPath = path11.resolve(projectPath).split(path11.sep).join("/");
+  const cached2 = memoryStoreCache.get(normalizedPath);
+  if (cached2) {
+    return cached2;
   }
   try {
     const globalConfigPath = getGlobalConfigPath();
@@ -120137,20 +120221,20 @@ async function getMemoryStore(logger) {
     if (!memoryConfig.enabled || memoryConfig.type === "memory") {
       return null;
     }
-    const cwd = process.cwd();
-    const scope = detectProjectScope(cwd);
+    const scope = `project:${normalizedPath}`;
     const dbPath = memoryConfig.path || DEFAULT_MEMORY_CONFIG.path;
     const resolvedDbPath = path11.resolve(resolveHomePath(dbPath));
     const sqliteStore = new SQLiteMemoryStore({ enabled: true, type: "sqlite", path: resolvedDbPath }, scope);
     const memoryManager = new MemoryManager(sqliteStore);
-    memoryStoreCache = {
+    const store = {
       store: memoryManager,
       close: () => {
         sqliteStore.close();
-        memoryStoreCache = null;
+        memoryStoreCache.delete(normalizedPath);
       }
     };
-    return memoryStoreCache;
+    memoryStoreCache.set(normalizedPath, store);
+    return store;
   } catch (error48) {
     logger.error(`Failed to initialize memory store: ${error48 instanceof Error ? error48.message : String(error48)}`);
     return null;
@@ -120271,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);
       }
     },
     {
@@ -120357,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;
@@ -120375,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,
@@ -120455,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);
       }
     },
     {
@@ -120534,16 +120618,18 @@ Memory persists across tool calls, allowing you to maintain context
 between different operations.
 
 Parameters:
+- project (required): Absolute path to the project directory. This isolates memory to a specific project.
 - topic (optional): The memory topic to read from. Defaults to ":default:" which stores general conversation context.
 
 Returns the content stored in the specified topic, or a message indicating the topic is empty.`,
       inputSchema: exports_external.object({
+        project: exports_external.string().describe('Absolute path to the project directory (e.g., "/home/user/my-project")'),
         topic: exports_external.string().optional().describe('The memory topic to read from (defaults to ":default:")')
       }),
       handler: async (args, toolContext) => {
-        const { topic = ":default:" } = args;
-        toolContext.logger.info(`MCP: Reading from memory topic "${topic}"`);
-        const memoryStore = await getMemoryStore(toolContext.logger);
+        const { project, topic = ":default:" } = args;
+        toolContext.logger.info(`MCP: Reading from memory topic "${topic}" for project "${project}"`);
+        const memoryStore = await getMemoryStore(toolContext.logger, project);
         if (!memoryStore) {
           return "Error: Memory store is not enabled. Configure it in your .polkacodes.yml with memory.enabled: true";
         }
@@ -120567,6 +120653,7 @@ Memory persists across tool calls, allowing you to maintain context
 between different operations.
 
 Parameters:
+- project (required): Absolute path to the project directory. This isolates memory to a specific project.
 - operation (required): The operation to perform. Use "append" to add content, "replace" to overwrite all content, or "remove" to delete the topic.
 - topics (optional): Array of topic names for batch operations. Content can be an array (one per topic) or a single string (broadcast to all topics).
 - topic (optional): Single memory topic to update. Defaults to ":default:".
@@ -120578,6 +120665,7 @@ Supports wildcards in topic name for remove operation:
 
 Returns a message confirming the operation performed.`,
       inputSchema: exports_external.object({
+        project: exports_external.string().describe('Absolute path to the project directory (e.g., "/home/user/my-project")'),
         operation: exports_external.enum(["append", "replace", "remove"]).describe("The operation: append (add content), replace (overwrite), or remove (delete topic(s))"),
         topic: exports_external.string().optional().describe('Single memory topic to update (defaults to ":default:")'),
         topics: exports_external.array(exports_external.string()).min(1).optional().describe("Array of topics for batch operations"),
@@ -120598,13 +120686,14 @@ Returns a message confirming the operation performed.`,
       }),
       handler: async (args, toolContext) => {
         const {
+          project,
           operation,
           topic: singleTopic,
           topics,
           content: contentInput
         } = args;
-        toolContext.logger.info(`MCP: Memory operation "${operation}" on ${topics ? `${topics.length} topics` : `topic "${singleTopic}"`}`);
-        const memoryStore = await getMemoryStore(toolContext.logger);
+        toolContext.logger.info(`MCP: Memory operation "${operation}" on ${topics ? `${topics.length} topics` : `topic "${singleTopic}"`} for project "${project}"`);
+        const memoryStore = await getMemoryStore(toolContext.logger, project);
         if (!memoryStore) {
           return "Error: Memory store is not enabled. Configure it in your .polkacodes.yml with memory.enabled: true";
         }
@@ -120674,23 +120763,21 @@ Use this to see what information has been stored and which topics are
 available to read from. Returns a list of topic names that have content.
 
 Parameters:
-- pattern (optional): Filter topics by wildcard pattern (e.g., ":plan:*" for all plan topics)
-- scope (optional): Filter by scope ("auto", "project", or "global")`,
+- project (required): Absolute path to the project directory. This isolates memory to a specific project.
+- pattern (optional): Filter topics by wildcard pattern (e.g., ":plan:*" for all plan topics)`,
       inputSchema: exports_external.object({
-        pattern: exports_external.string().optional().describe('Filter topics by wildcard pattern (e.g., ":plan:*")'),
-        scope: exports_external.enum(["auto", "project", "global"]).optional().describe('Filter by scope (defaults to "auto")')
+        project: exports_external.string().describe('Absolute path to the project directory (e.g., "/home/user/my-project")'),
+        pattern: exports_external.string().optional().describe('Filter topics by wildcard pattern (e.g., ":plan:*")')
       }),
       handler: async (args, toolContext) => {
-        const { pattern, scope } = args;
-        toolContext.logger.info(`MCP: Listing memory topics${pattern ? ` with pattern "${pattern}"` : ""}`);
-        const memoryStore = await getMemoryStore(toolContext.logger);
+        const { project, pattern } = args;
+        toolContext.logger.info(`MCP: Listing memory topics for project "${project}"${pattern ? ` with pattern "${pattern}"` : ""}`);
+        const memoryStore = await getMemoryStore(toolContext.logger, project);
         if (!memoryStore) {
           return "Error: Memory store is not enabled. Configure it in your .polkacodes.yml with memory.enabled: true";
         }
         try {
-          const query = {};
-          query.scope = scope ?? "auto";
-          const entries = await memoryStore.store.queryMemory(query, { operation: "select" });
+          const entries = await memoryStore.store.queryMemory({}, { operation: "select" });
           if (!entries || !Array.isArray(entries) || entries.length === 0) {
             return "No memory topics found.";
           }
@@ -120718,42 +120805,41 @@ Use this to search memory entries by content, metadata, or other criteria.
 Returns detailed entry information with metadata.
 
 Parameters:
+- project (required): Absolute path to the project directory. This isolates memory to a specific project.
 - search (optional): Search text to find in content
 - type (optional): Filter by entry type (note, todo, plan, etc.)
 - status (optional): Filter by status (open, completed, closed, etc.)
 - priority (optional): Filter by priority (null, low, medium, high)
 - tags (optional): Filter by tags
-- scope (optional): Filter by scope ("auto", "project", or "global")
 - operation (optional): Query operation - "select" returns entries, "count" returns count
 
 Returns matching entries with full metadata.`,
       inputSchema: exports_external.object({
+        project: exports_external.string().describe('Absolute path to the project directory (e.g., "/home/user/my-project")'),
         search: exports_external.string().optional().describe("Search text to find in content"),
         type: exports_external.string().optional().describe("Filter by entry type (note, todo, plan, etc.)"),
         status: exports_external.string().optional().describe("Filter by status (open, completed, closed, etc.)"),
         priority: exports_external.string().optional().describe("Filter by priority (null, low, medium, high)"),
         tags: exports_external.string().optional().describe("Filter by tags"),
-        scope: exports_external.enum(["auto", "project", "global"]).optional().describe('Filter by scope (defaults to "auto")'),
         operation: exports_external.enum(["select", "count"]).optional().describe('Query operation (defaults to "select")')
       }),
       handler: async (args, toolContext) => {
         const {
+          project,
           search,
           type,
           status,
           priority,
           tags,
-          scope,
           operation = "select"
         } = args;
-        toolContext.logger.info(`MCP: Querying memory - operation: "${operation}"`);
-        const memoryStore = await getMemoryStore(toolContext.logger);
+        toolContext.logger.info(`MCP: Querying memory for project "${project}" - operation: "${operation}"`);
+        const memoryStore = await getMemoryStore(toolContext.logger, project);
         if (!memoryStore) {
           return "Error: Memory store is not enabled. Configure it in your .polkacodes.yml with memory.enabled: true";
         }
         try {
           const memoryQuery = {};
-          memoryQuery.scope = scope ?? "auto";
           if (search)
             memoryQuery.search = search;
           if (type)
@@ -121416,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);
@@ -121432,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);
@@ -121452,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?");
@@ -121477,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) {
@@ -121488,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)) {
@@ -121523,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 {
@@ -121895,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 });
@@ -121969,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 {
@@ -121992,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);
@@ -122001,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);
@@ -122019,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.98",
+  "version": "0.9.100",
   "license": "AGPL-3.0",
   "author": "github@polka.codes",
   "type": "module",