bunosh 0.3.2 → 0.4.0

package/src/program.js

@@ -3,8 +3,7 @@ import babelParser from "@babel/parser";
 import traverseDefault from "@babel/traverse";
 const traverse = traverseDefault.default || traverseDefault;
 import color from "chalk";
-import fs from 'fs';
-import openEditor from './open-editor.js';
+import { readFileSync, existsSync, writeFileSync } from 'fs';
 import { yell } from './io.js';
 import cprint from "./font.js";
 import { handleCompletion, detectCurrentShell, installCompletion, getCompletionPaths } from './completion.js';
@@ -13,12 +12,47 @@ import { upgradeExecutable, isExecutable, getCurrentVersion } from './upgrade.js
 export const BUNOSHFILE = `Bunoshfile.js`;
 
 export const banner = () => {
-  console.log(cprint('Bunosh', { symbol: '⯀' }));
+  const asciiArt = cprint('Bunosh', { symbol: '⯀' });
+  console.log(createGradientAscii(asciiArt));
   console.log(color.gray('🍲 Your exceptional task runner'));
+  
+  // Try to get version from package.json
+  try {
+    // First try relative to src directory
+    const pkgPath = new URL('../package.json', import.meta.url);
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    console.log(`Version: ${color.bold(pkg.version)}`);
+  } catch (e) {
+    // Ignore if version can't be read
+  }
   console.log();
 };
 
-export default function bunosh(commands, source) {
+function createGradientAscii(asciiArt) {
+  const lines = asciiArt.split('\n');
+  const colors = [
+    color.bold.yellow,
+    color.bold.green,
+    color.bold.greenBright,
+    color.bold.cyan,
+    color.bold.blue
+  ];
+  
+  return lines.map((line, index) => {
+    // Create smooth gradient by interpolating between colors
+    const progress = index / (lines.length - 1);
+    const colorIndex = progress * (colors.length - 1);
+    const lowerIndex = Math.floor(colorIndex);
+    const upperIndex = Math.min(lowerIndex + 1, colors.length - 1);
+    const factor = colorIndex - lowerIndex;
+    
+    // For smoother transition, we'll use the closest color
+    const color = factor < 0.5 ? colors[lowerIndex] : colors[upperIndex];
+    return color(line);
+  }).join('\n');
+}
+
+export default async function bunosh(commands, source) {
   const program = new Command();
   program.option('--bunoshfile <path>', 'Path to the Bunoshfile');
 
@@ -27,19 +61,33 @@ export default function bunosh(commands, source) {
   // Load npm scripts from package.json
   const npmScripts = loadNpmScripts();
 
+  // Load personal commands from $HOME/Bunoshfile.js
+  const { tasks: homeTasks, source: homeSource } = await loadHomeTasks();
+
   program.configureHelp({
     commandDescription: _cmd => {
       // Show banner and description
       banner();
+      
+      // Try to get version from current directory's package.json for help display
+      try {
+        if (existsSync('package.json')) {
+          const pkg = JSON.parse(readFileSync('package.json', 'utf8'));
+          console.log(`Version: ${color.bold(pkg.version)}`);
+        }
+      } catch {
+        // Ignore if version can't be read
+      }
+      
       return `  Commands are loaded from exported functions in ${color.bold(BUNOSHFILE)}`;
     },
-    commandUsage: usg => 'bunosh <command> <args> [options]',
+    commandUsage: usg => 'bunosh [-e <code>] <command> <args> [options]',
     showGlobalOptions: false,
     visibleGlobalOptions: _opt => [],
     visibleOptions: _opt => [],
     visibleCommands: cmd => {
       const commands = cmd.commands.filter(c => !internalCommands.includes(c));
-      return commands.filter(c => !c.name().startsWith('npm:'));
+      return commands.filter(c => !c.name().startsWith('npm:') && !c.name().startsWith('my:'));
     },
     subcommandTerm: (cmd) => color.white.bold(cmd.name()),
     subcommandDescription: (cmd) => color.gray(cmd.description()),
@@ -65,8 +113,9 @@ export default function bunosh(commands, source) {
   }
 
   const comments = fetchComments();
+  const homeComments = fetchHomeComments();
 
-  // Collect all commands (bunosh + npm scripts) and sort them
+  // Collect all commands (bunosh + personal commands + npm scripts) and sort them
   const allCommands = [];
 
   // Add bunosh commands
@@ -74,6 +123,13 @@ export default function bunosh(commands, source) {
     allCommands.push({ type: 'bunosh', name: fnName, data: commands[fnName] });
   });
 
+  // Add personal commands with my: prefix
+  Object.keys(homeTasks).forEach((fnName) => {
+    if (typeof homeTasks[fnName] === 'function') {
+      allCommands.push({ type: 'home', name: `my:${fnName}`, data: homeTasks[fnName], source: homeSource });
+    }
+  });
+
   // Add npm scripts
   Object.entries(npmScripts).forEach(([scriptName, scriptCommand]) => {
     allCommands.push({ type: 'npm', name: `npm:${scriptName}`, data: { scriptName, scriptCommand } });
@@ -221,6 +277,57 @@ export default function bunosh(commands, source) {
 
         return functionOpts;
       }
+    } else if (cmdData.type === 'home') {
+      // Handle personal commands with my: prefix
+      const originalFnName = cmdData.name.replace('my:', ''); // Remove my: prefix for internal usage
+      const fnBody = cmdData.data.toString();
+      const homeAst = fetchHomeFnAst(originalFnName, cmdData.source);
+      const homeArgs = parseHomeArgs(originalFnName, homeAst);
+      const homeOpts = parseHomeOpts(originalFnName, homeAst);
+      const homeComment = homeComments[originalFnName];
+
+      const commandName = cmdData.name; // Keep the full my: prefix for command name
+
+      const command = program.command(commandName);
+      command.hook('preAction', (_thisCommand) => {
+        process.env.BUNOSH_COMMAND_STARTED = true;
+      });
+
+      let argsAndOptsDescription = [];
+
+      Object.entries(homeArgs).forEach(([arg, value]) => {
+        if (value === undefined) {
+          argsAndOptsDescription.push(`<${arg}>`);
+          return command.argument(`<${arg}>`);
+        }
+
+        if (value === null) {
+          argsAndOptsDescription.push(`[${arg}]`);
+          return command.argument(`[${arg}]`, '', null);
+        }
+
+        argsAndOptsDescription.push(`[${arg}=${value}]`);
+        command.argument(`[${arg}]`, ``, value);
+      });
+
+      Object.entries(homeOpts).forEach(([opt, value]) => {
+        if (value === false || value === null) {
+          argsAndOptsDescription.push(`--${opt}`);
+          return command.option(`--${opt}`);
+        }
+
+        argsAndOptsDescription.push(`--${opt}=${value}`);
+        command.option(`--${opt} [${opt}]`, "", value);
+      });
+
+      let description = homeComment?.split('\n')[0] || '';
+
+      if (homeComment && argsAndOptsDescription.length) {
+        description += `\n  ${color.gray(`bunosh ${commandName}`)} ${color.blue(argsAndOptsDescription.join(' ').trim())}`;
+      }
+
+      command.description(description);
+      command.action(cmdData.data.bind(homeTasks));
     } else if (cmdData.type === 'npm') {
       // Handle npm scripts
       const { scriptName, scriptCommand } = cmdData.data;
@@ -252,15 +359,14 @@ export default function bunosh(commands, source) {
   const editCmd = program.command('edit')
     .description('Open the bunosh file in your editor. $EDITOR or \'code\' is used.')
     .action(async () => {
-      try {
-        await openEditor([{
-          file: BUNOSHFILE,
-        }]);
-      } catch (error) {
-        console.error(error.message);
-        console.error('Set $EDITOR environment variable to use a different editor');
+      if (!Bun) {
+        console.log('Bun is not available');
         process.exit(1);
+        return;
       }
+      await Bun.openEditor([{
+        file: BUNOSHFILE,
+      }]);
     });
 
   internalCommands.push(editCmd);
@@ -312,7 +418,7 @@ export default function bunosh(commands, source) {
         const paths = getCompletionPaths(shell);
 
         // Check if already installed
-        if (!options.force && fs.existsSync(paths.completionFile)) {
+        if (!options.force && existsSync(paths.completionFile)) {
           console.log(`⚠️  Completion already installed at: ${paths.completionFile}`);
           console.log('   Use --force to overwrite, or run:');
           console.log(`   ${color.dim('rm')} ${paths.completionFile}`);
@@ -437,6 +543,23 @@ export default function bunosh(commands, source) {
 
   internalCommands.push(upgradeCmd);
 
+  // Add personal commands help section if personal commands exist
+  const homeTaskNamesForHelp = Object.keys(homeTasks).filter(key => typeof homeTasks[key] === 'function');
+  if (homeTaskNamesForHelp.length > 0) {
+    const homeCommandsList = homeTaskNamesForHelp.sort().map(taskName => {
+      const commandName = `my:${taskName}`;
+      const taskComment = homeComments[taskName] || '';
+      const description = taskComment ? taskComment.split('\n')[0] : 'Personal command';
+      return `  ${color.white.bold(commandName.padEnd(18))} ${color.gray(description)}`;
+    }).join('\n');
+
+    program.addHelpText('after', `
+
+My Commands (from ~/${BUNOSHFILE}):
+${homeCommandsList}
+`);
+  }
+
   // Add npm scripts help section if npm scripts exist
   const npmScriptNamesForHelp = Object.keys(npmScripts);
   if (npmScriptNamesForHelp.length > 0) {
@@ -460,6 +583,10 @@ Special Commands:
   📝 Edit bunosh file: ${color.bold('bunosh edit')}
   📥 Export commands as scripts to package.json: ${color.bold('bunosh export:scripts')}
   🦾 Upgrade bunosh: ${color.bold('bunosh upgrade')}
+  
+Execute JavaScript:
+  ${color.bold('bunosh -e "console.log(\'Hello\')"')}    Execute inline JavaScript
+  ${color.bold('bunosh -e < script.js')}                 Execute JavaScript from file
 `);
 
   program.on("command:*", (cmd) => {
@@ -467,6 +594,12 @@ Special Commands:
     program.outputHelp();
   });
 
+  // Show help if no command provided
+  if (process.argv.length === 2) {
+    program.outputHelp();
+    return program;
+  }
+
   program.parse(process.argv);
 
   function fetchComments() {
@@ -509,6 +642,150 @@ Special Commands:
 
     return comments;
   }
+
+  function fetchHomeComments() {
+    if (!homeSource) return {};
+    
+    const homeComments = {};
+    let homeCompleteAst;
+    
+    try {
+      homeCompleteAst = babelParser.parse(homeSource, {
+        sourceType: "module",
+        ranges: true,
+        tokens: true,
+        comments: true,
+        attachComment: true,
+      });
+    } catch (parseError) {
+      console.warn('Warning: Could not parse home Bunoshfile for comments:', parseError.message);
+      return {};
+    }
+
+    let startFromLine = 0;
+
+    traverse(homeCompleteAst, {
+      FunctionDeclaration(path) {
+        const functionName = path.node.id && path.node.id.name;
+
+        const commentSource = homeSource
+          .split("\n")
+          .slice(startFromLine, path.node?.loc?.start?.line)
+          .join("\n");
+        const matches = commentSource.match(
+          /\/\*\*\s([\s\S]*)\\*\/\s*export/,
+        );
+
+        if (matches && matches[1]) {
+          homeComments[functionName] = matches[1]
+            .replace(/^\s*\*\s*/gm, "")
+            .replace(/\s*\*\*\s*$/gm, "")
+            .trim()
+            .replace(/^@.*$/gm, "")
+            .trim();
+        } else {
+          // Check for comments attached to the first statement in the function body
+          const firstStatement = path.node?.body?.body?.[0];
+          const leadingComments = firstStatement?.leadingComments;
+
+          if (leadingComments && leadingComments.length > 0) {
+            homeComments[functionName] = leadingComments[0].value.trim();
+          }
+        }
+
+        startFromLine = path.node?.loc?.end?.line;
+      },
+    });
+
+    return homeComments;
+  }
+
+  function fetchHomeFnAst(fnName, source) {
+    try {
+      return babelParser.parse(source, {
+        sourceType: "module",
+        ranges: true,
+        tokens: true,
+        comments: true,
+        attachComment: true,
+      });
+    } catch (parseError) {
+      console.warn('Warning: Could not parse home function AST:', parseError.message);
+      return null;
+    }
+  }
+
+  function parseHomeArgs(fnName, ast) {
+    if (!ast) return {};
+    
+    const functionArguments = {};
+
+    traverse(ast, {
+      FunctionDeclaration(path) {
+        if (path.node.id.name !== fnName) return;
+
+        const params = path.node.params
+          .filter((node) => {
+            return node?.right?.type !== "ObjectExpression";
+          })
+          .forEach((param) => {
+            if (param.type === "AssignmentPattern") {
+              functionArguments[param.left.name] = param.right.value;
+              return;
+            }
+            if (!param.name) return;
+
+            return functionArguments[param.name] = null;
+          });
+      },
+    });
+
+    return functionArguments;
+  }
+
+  function parseHomeOpts(fnName, ast) {
+    if (!ast) return {};
+    
+    let functionOpts = {};
+
+    traverse(ast, {
+      FunctionDeclaration(path) {
+        if (path.node.id.name !== fnName) return;
+
+        const node = path.node.params.pop();
+        if (!node) return;
+        if (
+          !node.type === "AssignmentPattern" &&
+          node.right.type === "ObjectExpression"
+        )
+          return;
+
+        node?.right?.properties?.forEach((p) => {
+          if (
+            ["NumericLiteral", "StringLiteral", "BooleanLiteral"].includes(
+              p.value.type,
+            )
+          ) {
+            functionOpts[camelToDasherize(p.key.name)] = p.value.value;
+            return;
+          }
+
+          if (p.value.type === "NullLiteral") {
+            functionOpts[camelToDasherize(p.key.name)] = null;
+            return;
+          }
+
+          if (p.value.type == "UnaryExpression" && p.value.operator == "!") {
+            functionOpts[camelToDasherize(p.key.name)] =
+              !p.value.argument.value;
+            return;
+          }
+        });
+      },
+    });
+
+    return functionOpts;
+  }
 }
 
 function prepareCommandName(name) {
@@ -541,17 +818,17 @@ function parseDocBlock(funcName, code) {
 }
 
 function exportFn(commands) {
-  if (!fs.existsSync(BUNOSHFILE)) {
+  if (!existsSync(BUNOSHFILE)) {
     console.error(`${BUNOSHFILE} file not found, can\'t export its commands.`);
     return false;
   }
 
-  if (!fs.existsSync('package.json')) {
+  if (!existsSync('package.json')) {
     console.error('package.json now found, can\'t set scripts.');
     return false;
   }
 
-  const pkg = JSON.parse(fs.readFileSync('package.json').toString());
+  const pkg = JSON.parse(readFileSync('package.json').toString());
   if (!pkg.scripts) {
     pkg.scripts = {};
   }
@@ -564,7 +841,7 @@ function exportFn(commands) {
 
   pkg.scripts = {...pkg.scripts, ...scripts };
 
-  fs.writeFileSync('package.json', JSON.stringify(pkg, null, 4));
+  writeFileSync('package.json', JSON.stringify(pkg, null, 4));
 
   console.log('Added scripts:');
   console.log();
@@ -579,11 +856,11 @@ function exportFn(commands) {
 
 function loadNpmScripts() {
   try {
-    if (!fs.existsSync('package.json')) {
+    if (!existsSync('package.json')) {
       return {};
     }
 
-    const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    const pkg = JSON.parse(readFileSync('package.json', 'utf8'));
     const scripts = pkg.scripts || {};
 
     // Filter out bunosh scripts (scripts that contain "bunosh")
@@ -600,3 +877,26 @@ function loadNpmScripts() {
     return {};
   }
 }
+
+// Load personal commands from user's home directory
+async function loadHomeTasks() {
+  try {
+    const os = await import('os');
+    const path = await import('path');
+    const homeDir = os.homedir();
+    const homeBunoshfile = path.join(homeDir, BUNOSHFILE);
+
+    if (!existsSync(homeBunoshfile)) {
+      return { tasks: {}, source: '' };
+    }
+
+    // Import the home Bunoshfile
+    const homeTasks = await import(homeBunoshfile);
+    const homeSource = readFileSync(homeBunoshfile, 'utf-8');
+
+    return { tasks: homeTasks, source: homeSource };
+  } catch (error) {
+    console.warn('Warning: Could not load personal commands:', error.message);
+    return { tasks: {}, source: '' };
+  }
+}

package/src/task.js

@@ -1,13 +1,15 @@
 import { AsyncLocalStorage } from 'async_hooks';
 import Printer from './printer.js';
 
-export const TaskStatus = {
+// Use global objects created in bunosh.js
+export const TaskStatus = globalThis._bunoshGlobalTaskStatus || {
   RUNNING: 'running',
   FAIL: 'fail',
   SUCCESS: 'success',
   WARNING: 'warning'
 };
 
+// Initialize local array and also keep global synced
 export const tasksExecuted = [];
 export const runningTasks = new Map();
 
@@ -45,34 +47,9 @@ export function prints() {
   globalSilenceMode = false;
 }
 
-const startTime = Date.now();
-
-process.on('exit', (code) => {
-  if (!process.env.BUNOSH_COMMAND_STARTED) return;
-
-  const totalTime = Date.now() - startTime;
-  const tasksFailed = tasksExecuted.filter(ti => ti.result?.status === TaskStatus.FAIL).length;
-  const tasksWarning = tasksExecuted.filter(ti => ti.result?.status === TaskStatus.WARNING).length;
-  
-  // Check if we're in test environment
-  const isTestEnvironment = process.env.NODE_ENV === 'test' ||
-                            typeof Bun?.jest !== 'undefined' ||
-                            process.argv.some(arg => arg.includes('vitest') || arg.includes('jest') || arg.includes('--test') || arg.includes('test:'));
-  
-  // Set exit code to 1 if any tasks failed AND we're not in ignoreFailures mode AND not in test environment
-  // Note: if stopOnFailuresMode is true, we would have already exited immediately
-  if (tasksFailed > 0 && !stopOnFailuresMode && !isTestEnvironment) {
-    process.exitCode = 1;
-  }
-  
-  const finalExitCode = (tasksFailed > 0 && !stopOnFailuresMode && !isTestEnvironment) ? 1 : code;
-  const success = finalExitCode === 0;
-
-  console.log(`\n🍲 ${success ? '' : 'FAIL '}Exit Code: ${finalExitCode} | Tasks: ${tasksExecuted.length}${tasksFailed ? ` | Failed: ${tasksFailed}` : ''}${tasksWarning ? ` | Warnings: ${tasksWarning}` : ''} | Time: ${totalTime}ms`);
-});
-
 export function getRunningTaskCount() {
-  return runningTasks.size;
+  // Only count top-level tasks (tasks without a parent)
+  return Array.from(runningTasks.values()).filter(task => !task.parentId).length;
 }
 
 export function getCurrentTaskId() {
@@ -80,14 +57,32 @@ export function getCurrentTaskId() {
 }
 
 export function getTaskPrefix(taskId) {
-  const taskNumber = Array.from(runningTasks.keys()).indexOf(taskId) + 1;
+  const taskInfo = runningTasks.get(taskId);
+  if (!taskInfo) return '';
+
+  // Only show prefixes for top-level tasks when there are multiple top-level tasks
+  if (taskInfo.parentId) {
+    // This is a child task, never show prefix
+    return '';
+  }
+
+  // For top-level tasks, calculate position among other top-level tasks
+  const topLevelTasks = Array.from(runningTasks.values()).filter(task => !task.parentId);
+  const taskNumber = topLevelTasks.findIndex(task => task.id === taskId) + 1;
   return getRunningTaskCount() > 1 ? `❰${taskNumber}❱` : '';
 }
 
-export function createTaskInfo(name) {
-  const taskInfo = new TaskInfo(name, Date.now(), TaskStatus.RUNNING);
+
+export function createTaskInfo(name, parentId = null) {
+  const taskInfo = new TaskInfo(name, Date.now(), TaskStatus.RUNNING, parentId);
   runningTasks.set(taskInfo.id, taskInfo);
   tasksExecuted.push(taskInfo);
+
+  // Also add to global array for exit handler
+  if (globalThis._bunoshGlobalTasksExecuted) {
+    globalThis._bunoshGlobalTasksExecuted.push(taskInfo);
+  }
+
   return taskInfo;
 }
 
@@ -106,11 +101,12 @@ export function finishTaskInfo(taskInfo, success = true, error = null, output =
 }
 
 export class TaskInfo {
-  constructor(name, startTime, status) {
+  constructor(name, startTime, status, parentId = null) {
     this.id = `task-${++taskCounter}-${Math.random().toString(36).substring(7)}`;
     this.name = name;
     this.startTime = startTime;
     this.status = status;
+    this.parentId = parentId;
   }
 }
 
@@ -120,10 +116,7 @@ export async function tryTask(name, fn, isSilent = false) {
     name = fn.toString().slice(0, 50).replace(/\s+/g, ' ').trim();
   }
 
-  const taskInfo = new TaskInfo(name, Date.now(), TaskStatus.RUNNING);
-
-  tasksExecuted.push(taskInfo);
-  runningTasks.set(taskInfo.id, taskInfo);
+  const taskInfo = createTaskInfo(name);
 
   const shouldPrint = !globalSilenceMode && !isSilent;
   const printer = new Printer('task', taskInfo.id);
@@ -166,10 +159,7 @@ export async function task(name, fn, isSilent = false) {
     name = fn.toString().slice(0, 50).replace(/\s+/g, ' ').trim();
   }
 
-  const taskInfo = new TaskInfo(name, Date.now(), TaskStatus.RUNNING);
-
-  tasksExecuted.push(taskInfo);
-  runningTasks.set(taskInfo.id, taskInfo);
+  const taskInfo = createTaskInfo(name);
 
   const shouldPrint = !globalSilenceMode && !isSilent;
   const printer = new Printer('task', taskInfo.id);
@@ -183,11 +173,16 @@ export async function task(name, fn, isSilent = false) {
     const endTime = Date.now();
     const duration = endTime - taskInfo.startTime;
 
+    // Check if result is a TaskResult instance
+    if (result && result.constructor && result.constructor.name === 'TaskResult') {
+      return result;
+    }
+
     taskInfo.status = TaskStatus.SUCCESS;
     taskInfo.duration = duration;
     taskInfo.result = { status: TaskStatus.SUCCESS, output: result };
 
-    if (shouldPrint) printer.finish(name);
+    printer.finish(name);
     runningTasks.delete(taskInfo.id);
 
     return result;
@@ -199,7 +194,7 @@ export async function task(name, fn, isSilent = false) {
     taskInfo.duration = duration;
     taskInfo.result = { status: TaskStatus.FAIL, output: err.message };
 
-    if (shouldPrint) printer.error(name, err);
+    printer.error(name, err);
     runningTasks.delete(taskInfo.id);
 
     // Don't exit during testing
@@ -216,11 +211,14 @@ export async function task(name, fn, isSilent = false) {
     if (stopFailToggle && !isTestEnvironment) {
       process.exit(1);
     }
-
+    
     throw err;
   }
 }
 
+// Add try method to task function
+task.try = tryTask;
+
 export class SilentTaskWrapper {
   constructor() {
     this.silent = true;

package/src/tasks/exec.js

@@ -1,9 +1,20 @@
-import { TaskResult, createTaskInfo, finishTaskInfo } from '../task.js';
+import { TaskResult, createTaskInfo, finishTaskInfo, getCurrentTaskId } from '../task.js';
 import Printer from '../printer.js';
 
 const isBun = typeof Bun !== 'undefined';
 
 export default function exec(strings, ...values) {
+  // Check if called as regular function instead of template literal
+  if (!Array.isArray(strings)) {
+    // If first argument is a string, treat it as the command
+    if (typeof strings === 'string') {
+      strings = [strings];
+      values = [];
+    } else {
+      throw new Error('exec() must be called as a template literal: exec`command` or exec("command")');
+    }
+  }
+  
   const cmd = strings.reduce((accumulator, str, i) => {
     return accumulator + str + (values[i] || '');
   }, '');
@@ -16,7 +27,8 @@ export default function exec(strings, ...values) {
     if (cwd) extraInfo.cwd = cwd;
     if (envs) extraInfo.env = envs;
 
-    const taskInfo = createTaskInfo(cmd);
+    const currentTaskId = getCurrentTaskId();
+    const taskInfo = createTaskInfo(cmd, currentTaskId);
     const printer = new Printer('exec', taskInfo.id);
     printer.start(cmd, extraInfo);
 

package/src/tasks/fetch.js

@@ -1,4 +1,4 @@
-import { TaskResult, createTaskInfo, finishTaskInfo } from '../task.js';
+import { TaskResult, createTaskInfo, finishTaskInfo, getCurrentTaskId } from '../task.js';
 import Printer from '../printer.js';
 
 export default async function httpFetch() {
@@ -6,7 +6,8 @@ export default async function httpFetch() {
   const method = arguments[1]?.method || 'GET';
   const taskName = `${method} ${url}`;
   
-  const taskInfo = createTaskInfo(taskName);
+  const currentTaskId = getCurrentTaskId();
+  const taskInfo = createTaskInfo(taskName, currentTaskId);
   const printer = new Printer('fetch', taskInfo.id);
   printer.start(taskName);
 
@@ -20,7 +21,7 @@ export default async function httpFetch() {
         const lines = textDecoder.decode(chunk, { stream: true }).toString().split('\n');
         for (const line of lines) {
           if (line.trim()) {
-            printer.print(line, 'output');
+            printer.output(line);
             output += line + '\n';
           }
         }