Skip to content

An AI-powered task-management system you can drop into Cursor, Lovable, Windsurf, Roo, and others.

feat: implement export tasks (#1260)

Ralph Khreish7265a6cf537a
diff --git a/apps/cli/src/command-registry.ts b/apps/cli/src/command-registry.ts
new file mode 100644
index 00000000..fffc8379
--- /dev/null
+++ b/apps/cli/src/command-registry.ts
@@ -0,0 +1,255 @@
+/**
+ * @fileoverview Centralized Command Registry
+ * Provides a single location for registering all CLI commands
+ */
+
+import { Command } from 'commander';
+
+// Import all commands
+import { ListTasksCommand } from './commands/list.command.js';
+import { ShowCommand } from './commands/show.command.js';
+import { AuthCommand } from './commands/auth.command.js';
+import { ContextCommand } from './commands/context.command.js';
+import { StartCommand } from './commands/start.command.js';
+import { SetStatusCommand } from './commands/set-status.command.js';
+import { ExportCommand } from './commands/export.command.js';
+
+/**
+ * Command metadata for registration
+ */
+export interface CommandMetadata {
+ name: string;
+ description: string;
+ commandClass: typeof Command;
+ category?: 'task' | 'auth' | 'utility' | 'development';
+}
+
+/**
+ * Registry of all available commands
+ */
+export class CommandRegistry {
+ /**
+ * All available commands with their metadata
+ */
+ private static commands: CommandMetadata[] = [
+ // Task Management Commands
+ {
+ name: 'list',
+ description: 'List all tasks with filtering and status overview',
+ commandClass: ListTasksCommand as any,
+ category: 'task'
+ },
+ {
+ name: 'show',
+ description: 'Display detailed information about a specific task',
+ commandClass: ShowCommand as any,
+ category: 'task'
+ },
+ {
+ name: 'start',
+ description: 'Start working on a task with claude-code',
+ commandClass: StartCommand as any,
+ category: 'task'
+ },
+ {
+ name: 'set-status',
+ description: 'Update the status of one or more tasks',
+ commandClass: SetStatusCommand as any,
+ category: 'task'
+ },
+ {
+ name: 'export',
+ description: 'Export tasks to external systems',
+ commandClass: ExportCommand as any,
+ category: 'task'
+ },
+
+ // Authentication & Context Commands
+ {
+ name: 'auth',
+ description: 'Manage authentication with tryhamster.com',
+ commandClass: AuthCommand as any,
+ category: 'auth'
+ },
+ {
+ name: 'context',
+ description: 'Manage workspace context (organization/brief)',
+ commandClass: ContextCommand as any,
+ category: 'auth'
+ }
+ ];
+
+ /**
+ * Register all commands on a program instance
+ * @param program - Commander program to register commands on
+ */
+ static registerAll(program: Command): void {
+ for (const cmd of this.commands) {
+ this.registerCommand(program, cmd);
+ }
+ }
+
+ /**
+ * Register specific commands by category
+ * @param program - Commander program to register commands on
+ * @param category - Category of commands to register
+ */
+ static registerByCategory(
+ program: Command,
+ category: 'task' | 'auth' | 'utility' | 'development'
+ ): void {
+ const categoryCommands = this.commands.filter(
+ (cmd) => cmd.category === category
+ );
+
+ for (const cmd of categoryCommands) {
+ this.registerCommand(program, cmd);
+ }
+ }
+
+ /**
+ * Register a single command by name
+ * @param program - Commander program to register the command on
+ * @param name - Name of the command to register
+ */
+ static registerByName(program: Command, name: string): void {
+ const cmd = this.commands.find((c) => c.name === name);
+ if (cmd) {
+ this.registerCommand(program, cmd);
+ } else {
+ throw new Error(`Command '${name}' not found in registry`);
+ }
+ }
+
+ /**
+ * Register a single command
+ * @param program - Commander program to register the command on
+ * @param metadata - Command metadata
+ */
+ private static registerCommand(
+ program: Command,
+ metadata: CommandMetadata
+ ): void {
+ const CommandClass = metadata.commandClass as any;
+
+ // Use the static registration method that all commands have
+ if (CommandClass.registerOn) {
+ CommandClass.registerOn(program);
+ } else if (CommandClass.register) {
+ CommandClass.register(program);
+ } else {
+ // Fallback to creating instance and adding
+ const instance = new CommandClass();
+ program.addCommand(instance);
+ }
+ }
+
+ /**
+ * Get all registered command names
+ */
+ static getCommandNames(): string[] {
+ return this.commands.map((cmd) => cmd.name);
+ }
+
+ /**
+ * Get commands by category
+ */
+ static getCommandsByCategory(
+ category: 'task' | 'auth' | 'utility' | 'development'
+ ): CommandMetadata[] {
+ return this.commands.filter((cmd) => cmd.category === category);
+ }
+
+ /**
+ * Add a new command to the registry
+ * @param metadata - Command metadata to add
+ */
+ static addCommand(metadata: CommandMetadata): void {
+ // Check if command already exists
+ if (this.commands.some((cmd) => cmd.name === metadata.name)) {
+ throw new Error(`Command '${metadata.name}' already exists in registry`);
+ }
+
+ this.commands.push(metadata);
+ }
+
+ /**
+ * Remove a command from the registry
+ * @param name - Name of the command to remove
+ */
+ static removeCommand(name: string): boolean {
+ const index = this.commands.findIndex((cmd) => cmd.name === name);
+ if (index >= 0) {
+ this.commands.splice(index, 1);
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Get command metadata by name
+ * @param name - Name of the command
+ */
+ static getCommand(name: string): CommandMetadata | undefined {
+ return this.commands.find((cmd) => cmd.name === name);
+ }
+
+ /**
+ * Check if a command exists
+ * @param name - Name of the command
+ */
+ static hasCommand(name: string): boolean {
+ return this.commands.some((cmd) => cmd.name === name);
+ }
+
+ /**
+ * Get a formatted list of all commands for display
+ */
+ static getFormattedCommandList(): string {
+ const categories = {
+ task: 'Task Management',
+ auth: 'Authentication & Context',
+ utility: 'Utilities',
+ development: 'Development'
+ };
+
+ let output = '';
+
+ for (const [category, title] of Object.entries(categories)) {
+ const cmds = this.getCommandsByCategory(
+ category as keyof typeof categories
+ );
+ if (cmds.length > 0) {
+ output += `\n${title}:\n`;
+ for (const cmd of cmds) {
+ output += ` ${cmd.name.padEnd(20)} ${cmd.description}\n`;
+ }
+ }
+ }
+
+ return output;
+ }
+}
+
+/**
+ * Convenience function to register all CLI commands
+ * @param program - Commander program instance
+ */
+export function registerAllCommands(program: Command): void {
+ CommandRegistry.registerAll(program);
+}
+
+/**
+ * Convenience function to register commands by category
+ * @param program - Commander program instance
+ * @param category - Category to register
+ */
+export function registerCommandsByCategory(
+ program: Command,
+ category: 'task' | 'auth' | 'utility' | 'development'
+): void {
+ CommandRegistry.registerByCategory(program, category);
+}
+
+// Export the registry for direct access if needed
+export default CommandRegistry;
diff --git a/apps/cli/src/commands/auth.command.ts b/apps/cli/src/commands/auth.command.ts
index c79ff6bb..8053311d 100644
--- a/apps/cli/src/commands/auth.command.ts
+++ b/apps/cli/src/commands/auth.command.ts
@@ -493,18 +493,7 @@ export class AuthCommand extends Command {
}
/**
- * Static method to register this command on an existing program
- * This is for gradual migration - allows commands.js to use this
- */
- static registerOn(program: Command): Command {
- const authCommand = new AuthCommand();
- program.addCommand(authCommand);
- return authCommand;
- }
-
- /**
- * Alternative registration that returns the command for chaining
- * Can also configure the command name if needed
+ * Register this command on an existing program
*/
static register(program: Command, name?: string): AuthCommand {
const authCommand = new AuthCommand(name);
diff --git a/apps/cli/src/commands/context.command.ts b/apps/cli/src/commands/context.command.ts
index e4c0a73f..04d475f3 100644
--- a/apps/cli/src/commands/context.command.ts
+++ b/apps/cli/src/commands/context.command.ts
@@ -694,16 +694,7 @@ export class ContextCommand extends Command {
}
/**
- * Static method to register this command on an existing program
- */
- static registerOn(program: Command): Command {
- const contextCommand = new ContextCommand();
- program.addCommand(contextCommand);
- return contextCommand;
- }
-
- /**
- * Alternative registration that returns the command for chaining
+ * Register this command on an existing program
*/
static register(program: Command, name?: string): ContextCommand {
const contextCommand = new ContextCommand(name);
diff --git a/apps/cli/src/commands/export.command.ts b/apps/cli/src/commands/export.command.ts
new file mode 100644
index 00000000..0d09efe3
--- /dev/null
+++ b/apps/cli/src/commands/export.command.ts
@@ -0,0 +1,379 @@
+/**
+ * @fileoverview Export command for exporting tasks to external systems
+ * Provides functionality to export tasks to Hamster briefs
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora, { Ora } from 'ora';
+import {
+ AuthManager,
+ AuthenticationError,
+ type UserContext
+} from '@tm/core/auth';
+import { TaskMasterCore, type ExportResult } from '@tm/core';
+import * as ui from '../utils/ui.js';
+
+/**
+ * Result type from export command
+ */
+export interface ExportCommandResult {
+ success: boolean;
+ action: 'export' | 'validate' | 'cancelled';
+ result?: ExportResult;
+ message?: string;
+}
+
+/**
+ * ExportCommand extending Commander's Command class
+ * Handles task export to external systems
+ */
+export class ExportCommand extends Command {
+ private authManager: AuthManager;
+ private taskMasterCore?: TaskMasterCore;
+ private lastResult?: ExportCommandResult;
+
+ constructor(name?: string) {
+ super(name || 'export');
+
+ // Initialize auth manager
+ this.authManager = AuthManager.getInstance();
+
+ // Configure the command
+ this.description('Export tasks to external systems (e.g., Hamster briefs)');
+
+ // Add options
+ this.option('--org <id>', 'Organization ID to export to');
+ this.option('--brief <id>', 'Brief ID to export tasks to');
+ this.option('--tag <tag>', 'Export tasks from a specific tag');
+ this.option(
+ '--status <status>',
+ 'Filter tasks by status (pending, in-progress, done, etc.)'
+ );
+ this.option('--exclude-subtasks', 'Exclude subtasks from export');
+ this.option('-y, --yes', 'Skip confirmation prompt');
+
+ // Accept optional positional argument for brief ID or Hamster URL
+ this.argument('[briefOrUrl]', 'Brief ID or Hamster brief URL');
+
+ // Default action
+ this.action(async (briefOrUrl?: string, options?: any) => {
+ await this.executeExport(briefOrUrl, options);
+ });
+ }
+
+ /**
+ * Initialize the TaskMasterCore
+ */
+ private async initializeServices(): Promise<void> {
+ if (this.taskMasterCore) {
+ return;
+ }
+
+ try {
+ // Initialize TaskMasterCore
+ this.taskMasterCore = await TaskMasterCore.create({
+ projectPath: process.cwd()
+ });
+ } catch (error) {
+ throw new Error(
+ `Failed to initialize services: ${(error as Error).message}`
+ );
+ }
+ }
+
+ /**
+ * Execute the export command
+ */
+ private async executeExport(
+ briefOrUrl?: string,
+ options?: any
+ ): Promise<void> {
+ let spinner: Ora | undefined;
+
+ try {
+ // Check authentication
+ if (!this.authManager.isAuthenticated()) {
+ ui.displayError('Not authenticated. Run "tm auth login" first.');
+ process.exit(1);
+ }
+
+ // Initialize services
+ await this.initializeServices();
+
+ // Get current context
+ const context = this.authManager.getContext();
+
+ // Determine org and brief IDs
+ let orgId = options?.org || context?.orgId;
+ let briefId = options?.brief || briefOrUrl || context?.briefId;
+
+ // If a URL/ID was provided as argument, resolve it
+ if (briefOrUrl && !options?.brief) {
+ spinner = ora('Resolving brief...').start();
+ const resolvedBrief = await this.resolveBriefInput(briefOrUrl);
+ if (resolvedBrief) {
+ briefId = resolvedBrief.briefId;
+ orgId = resolvedBrief.orgId;
+ spinner.succeed('Brief resolved');
+ } else {
+ spinner.fail('Could not resolve brief');
+ process.exit(1);
+ }
+ }
+
+ // Validate we have necessary IDs
+ if (!orgId) {
+ ui.displayError(
+ 'No organization selected. Run "tm context org" or use --org flag.'
+ );
+ process.exit(1);
+ }
+
+ if (!briefId) {
+ ui.displayError(
+ 'No brief specified. Run "tm context brief", provide a brief ID/URL, or use --brief flag.'
+ );
+ process.exit(1);
+ }
+
+ // Confirm export if not auto-confirmed
+ if (!options?.yes) {
+ const confirmed = await this.confirmExport(orgId, briefId, context);
+ if (!confirmed) {
+ ui.displayWarning('Export cancelled');
+ this.lastResult = {
+ success: false,
+ action: 'cancelled',
+ message: 'User cancelled export'
+ };
+ process.exit(0);
+ }
+ }
+
+ // Perform export
+ spinner = ora('Exporting tasks...').start();
+
+ const exportResult = await this.taskMasterCore!.exportTasks({
+ orgId,
+ briefId,
+ tag: options?.tag,
+ status: options?.status,
+ excludeSubtasks: options?.excludeSubtasks || false
+ });
+
+ if (exportResult.success) {
+ spinner.succeed(
+ `Successfully exported ${exportResult.taskCount} task(s) to brief`
+ );
+
+ // Display summary
+ console.log(chalk.cyan('\n📤 Export Summary\n'));
+ console.log(chalk.white(` Organization: ${orgId}`));
+ console.log(chalk.white(` Brief: ${briefId}`));
+ console.log(chalk.white(` Tasks exported: ${exportResult.taskCount}`));
+ if (options?.tag) {
+ console.log(chalk.gray(` Tag: ${options.tag}`));
+ }
+ if (options?.status) {
+ console.log(chalk.gray(` Status filter: ${options.status}`));
+ }
+
+ if (exportResult.message) {
+ console.log(chalk.gray(`\n ${exportResult.message}`));
+ }
+ } else {
+ spinner.fail('Export failed');
+ if (exportResult.error) {
+ console.error(chalk.red(`\n✗ ${exportResult.error.message}`));
+ }
+ }
+
+ this.lastResult = {
+ success: exportResult.success,
+ action: 'export',
+ result: exportResult
+ };
+ } catch (error: any) {
+ if (spinner?.isSpinning) spinner.fail('Export failed');
+ this.handleError(error);
+ process.exit(1);
+ }
+ }
+
+ /**
+ * Resolve brief input to get brief and org IDs
+ */
+ private async resolveBriefInput(
+ briefOrUrl: string
+ ): Promise<{ briefId: string; orgId: string } | null> {
+ try {
+ // Extract brief ID from input
+ const briefId = this.extractBriefId(briefOrUrl);
+ if (!briefId) {
+ return null;
+ }
+
+ // Fetch brief to get organization
+ const brief = await this.authManager.getBrief(briefId);
+ if (!brief) {
+ ui.displayError('Brief not found or you do not have access');
+ return null;
+ }
+
+ return {
+ briefId: brief.id,
+ orgId: brief.accountId
+ };
+ } catch (error) {
+ console.error(chalk.red(`Failed to resolve brief: ${error}`));
+ return null;
+ }
+ }
+
+ /**
+ * Extract a brief ID from raw input (ID or URL)
+ */
+ private extractBriefId(input: string): string | null {
+ const raw = input?.trim() ?? '';
+ if (!raw) return null;
+
+ const parseUrl = (s: string): URL | null => {
+ try {
+ return new URL(s);
+ } catch {}
+ try {
+ return new URL(`https://${s}`);
+ } catch {}
+ return null;
+ };
+
+ const fromParts = (path: string): string | null => {
+ const parts = path.split('/').filter(Boolean);
+ const briefsIdx = parts.lastIndexOf('briefs');
+ const candidate =
+ briefsIdx >= 0 && parts.length > briefsIdx + 1
+ ? parts[briefsIdx + 1]
+ : parts[parts.length - 1];
+ return candidate?.trim() || null;
+ };
+
+ // Try URL parsing
+ const url = parseUrl(raw);
+ if (url) {
+ const qId = url.searchParams.get('id') || url.searchParams.get('briefId');
+ const candidate = (qId || fromParts(url.pathname)) ?? null;
+ if (candidate) {
+ if (this.isLikelyId(candidate) || candidate.length >= 8) {
+ return candidate;
+ }
+ }
+ }
+
+ // Check if it looks like a path
+ if (raw.includes('/')) {
+ const candidate = fromParts(raw);
+ if (candidate && (this.isLikelyId(candidate) || candidate.length >= 8)) {
+ return candidate;
+ }
+ }
+
+ // Return raw if it looks like an ID
+ return raw;
+ }
+
+ /**
+ * Check if a string looks like a brief ID
+ */
+ private isLikelyId(value: string): boolean {
+ const uuidRegex =
+ /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+ const ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
+ const slugRegex = /^[A-Za-z0-9_-]{16,}$/;
+ return (
+ uuidRegex.test(value) || ulidRegex.test(value) || slugRegex.test(value)
+ );
+ }
+
+ /**
+ * Confirm export with the user
+ */
+ private async confirmExport(
+ orgId: string,
+ briefId: string,
+ context: UserContext | null
+ ): Promise<boolean> {
+ console.log(chalk.cyan('\n📤 Export Tasks\n'));
+
+ // Show org name if available
+ if (context?.orgName) {
+ console.log(chalk.white(` Organization: ${context.orgName}`));
+ console.log(chalk.gray(` ID: ${orgId}`));
+ } else {
+ console.log(chalk.white(` Organization ID: ${orgId}`));
+ }
+
+ // Show brief info
+ if (context?.briefName) {
+ console.log(chalk.white(`\n Brief: ${context.briefName}`));
+ console.log(chalk.gray(` ID: ${briefId}`));
+ } else {
+ console.log(chalk.white(`\n Brief ID: ${briefId}`));
+ }
+
+ const { confirmed } = await inquirer.prompt([
+ {
+ type: 'confirm',
+ name: 'confirmed',
+ message: 'Do you want to proceed with export?',
+ default: true
+ }
+ ]);
+
+ return confirmed;
+ }
+
+ /**
+ * Handle errors
+ */
+ private handleError(error: any): void {
+ if (error instanceof AuthenticationError) {
+ console.error(chalk.red(`\n✗ ${error.message}`));
+
+ if (error.code === 'NOT_AUTHENTICATED') {
+ ui.displayWarning('Please authenticate first: tm auth login');
+ }
+ } else {
+ const msg = error?.message ?? String(error);
+ console.error(chalk.red(`Error: ${msg}`));
+
+ if (error.stack && process.env.DEBUG) {
+ console.error(chalk.gray(error.stack));
+ }
+ }
+ }
+
+ /**
+ * Get the last export result (useful for testing)
+ */
+ public getLastResult(): ExportCommandResult | undefined {
+ return this.lastResult;
+ }
+
+ /**
+ * Clean up resources
+ */
+ async cleanup(): Promise<void> {
+ // No resources to clean up
+ }
+
+ /**
+ * Register this command on an existing program
+ */
+ static register(program: Command, name?: string): ExportCommand {
+ const exportCommand = new ExportCommand(name);
+ program.addCommand(exportCommand);
+ return exportCommand;
+ }
+}
diff --git a/apps/cli/src/commands/list.command.ts b/apps/cli/src/commands/list.command.ts
index a3ce900e..38e4184b 100644
--- a/apps/cli/src/commands/list.command.ts
+++ b/apps/cli/src/commands/list.command.ts
@@ -474,18 +474,7 @@ export class ListTasksCommand extends Command {
}
/**
- * Static method to register this command on an existing program
- * This is for gradual migration - allows commands.js to use this
- */
- static registerOn(program: Command): Command {
- const listCommand = new ListTasksCommand();
- program.addCommand(listCommand);
- return listCommand;
- }
-
- /**
- * Alternative registration that returns the command for chaining
- * Can also configure the command name if needed
+ * Register this command on an existing program
*/
static register(program: Command, name?: string): ListTasksCommand {
const listCommand = new ListTasksCommand(name);
diff --git a/apps/cli/src/commands/set-status.command.ts b/apps/cli/src/commands/set-status.command.ts
index 960febba..25dc40bd 100644
--- a/apps/cli/src/commands/set-status.command.ts
+++ b/apps/cli/src/commands/set-status.command.ts
@@ -287,18 +287,7 @@ export class SetStatusCommand extends Command {
}
/**
- * Static method to register this command on an existing program
- * This is for gradual migration - allows commands.js to use this
- */
- static registerOn(program: Command): Command {
- const setStatusCommand = new SetStatusCommand();
- program.addCommand(setStatusCommand);
- return setStatusCommand;
- }
-
- /**
- * Alternative registration that returns the command for chaining
- * Can also configure the command name if needed
+ * Register this command on an existing program
*/
static register(program: Command, name?: string): SetStatusCommand {
const setStatusCommand = new SetStatusCommand(name);
diff --git a/apps/cli/src/commands/show.command.ts b/apps/cli/src/commands/show.command.ts
index ba19779c..f41cb786 100644
--- a/apps/cli/src/commands/show.command.ts
+++ b/apps/cli/src/commands/show.command.ts
@@ -322,18 +322,7 @@ export class ShowCommand extends Command {
}
/**
- * Static method to register this command on an existing program
- * This is for gradual migration - allows commands.js to use this
- */
- static registerOn(program: Command): Command {
- const showCommand = new ShowCommand();
- program.addCommand(showCommand);
- return showCommand;
- }
-
- /**
- * Alternative registration that returns the command for chaining
- * Can also configure the command name if needed
+ * Register this command on an existing program
*/
static register(program: Command, name?: string): ShowCommand {
const showCommand = new ShowCommand(name);
diff --git a/apps/cli/src/commands/start.command.ts b/apps/cli/src/commands/start.command.ts
index f5ca0a5b..ec82c2e5 100644
--- a/apps/cli/src/commands/start.command.ts
+++ b/apps/cli/src/commands/start.command.ts
@@ -493,16 +493,7 @@ export class StartCommand extends Command {
}
/**
- * Static method to register this command on an existing program
- */
- static registerOn(program: Command): Command {
- const startCommand = new StartCommand();
- program.addCommand(startCommand);
- return startCommand;
- }
-
- /**
- * Alternative registration that returns the command for chaining
+ * Register this command on an existing program
*/
static register(program: Command, name?: string): StartCommand {
const startCommand = new StartCommand(name);
diff --git a/apps/cli/src/index.ts b/apps/cli/src/index.ts
index ce0405ee..fbf8757a 100644
--- a/apps/cli/src/index.ts
+++ b/apps/cli/src/index.ts
@@ -10,6 +10,15 @@ export { AuthCommand } from './commands/auth.command.js';
export { ContextCommand } from './commands/context.command.js';
export { StartCommand } from './commands/start.command.js';
export { SetStatusCommand } from './commands/set-status.command.js';
+export { ExportCommand } from './commands/export.command.js';
+
+// Command Registry
+export {
+ CommandRegistry,
+ registerAllCommands,
+ registerCommandsByCategory,
+ type CommandMetadata
+} from './command-registry.js';
// UI utilities (for other commands to use)
export * as ui from './utils/ui.js';
diff --git a/packages/tm-core/src/errors/task-master-error.ts b/packages/tm-core/src/errors/task-master-error.ts
index f2dbb710..545e6353 100644
--- a/packages/tm-core/src/errors/task-master-error.ts
+++ b/packages/tm-core/src/errors/task-master-error.ts
@@ -51,7 +51,8 @@ export const ERROR_CODES = {
INTERNAL_ERROR: 'INTERNAL_ERROR',
INVALID_INPUT: 'INVALID_INPUT',
NOT_IMPLEMENTED: 'NOT_IMPLEMENTED',
- UNKNOWN_ERROR: 'UNKNOWN_ERROR'
+ UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+ NOT_FOUND: 'NOT_FOUND'
} as const;
export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
diff --git a/packages/tm-core/src/index.ts b/packages/tm-core/src/index.ts
index 7702b868..0f96f694 100644
--- a/packages/tm-core/src/index.ts
+++ b/packages/tm-core/src/index.ts
@@ -11,7 +11,9 @@ export {
type ListTasksResult,
type StartTaskOptions,
type StartTaskResult,
- type ConflictCheckResult
+ type ConflictCheckResult,
+ type ExportTasksOptions,
+ type ExportResult
} from './task-master-core.js';
// Re-export types
diff --git a/packages/tm-core/src/interfaces/storage.interface.ts b/packages/tm-core/src/interfaces/storage.interface.ts
index ee7297f5..14f0a148 100644
--- a/packages/tm-core/src/interfaces/storage.interface.ts
+++ b/packages/tm-core/src/interfaces/storage.interface.ts
@@ -5,6 +5,16 @@
import type { Task, TaskMetadata, TaskStatus } from '../types/index.js';
+/**
+ * Options for loading tasks from storage
+ */
+export interface LoadTasksOptions {
+ /** Filter tasks by status */
+ status?: TaskStatus;
+ /** Exclude subtasks from loaded tasks (default: false) */
+ excludeSubtasks?: boolean;
+}
+
/**
* Result type for updateTaskStatus operations
*/
@@ -21,11 +31,12 @@ export interface UpdateStatusResult {
*/
export interface IStorage {
/**
- * Load all tasks from storage, optionally filtered by tag
+ * Load all tasks from storage, optionally filtered by tag and other criteria
* @param tag - Optional tag to filter tasks by
+ * @param options - Optional filtering options (status, excludeSubtasks)
* @returns Promise that resolves to an array of tasks
*/
- loadTasks(tag?: string): Promise<Task[]>;
+ loadTasks(tag?: string, options?: LoadTasksOptions): Promise<Task[]>;
/**
* Load a single task by ID
@@ -205,7 +216,7 @@ export abstract class BaseStorage implements IStorage {
}
// Abstract methods that must be implemented by concrete classes
- abstract loadTasks(tag?: string): Promise<Task[]>;
+ abstract loadTasks(tag?: string, options?: LoadTasksOptions): Promise<Task[]>;
abstract loadTask(taskId: string, tag?: string): Promise<Task | null>;
abstract saveTasks(tasks: Task[], tag?: string): Promise<void>;
abstract appendTasks(tasks: Task[], tag?: string): Promise<void>;
diff --git a/packages/tm-core/src/repositories/supabase/supabase-task-repository.ts b/packages/tm-core/src/repositories/supabase/supabase-task-repository.ts
index 14a26594..925de209 100644
--- a/packages/tm-core/src/repositories/supabase/supabase-task-repository.ts
+++ b/packages/tm-core/src/repositories/supabase/supabase-task-repository.ts
@@ -8,6 +8,7 @@ import {
TaskWithRelations,
TaskDatabaseUpdate
} from '../../types/repository-types.js';
+import { LoadTasksOptions } from '../../interfaces/storage.interface.js';
import { z } from 'zod';
// Zod schema for task status validation
@@ -56,11 +57,14 @@ export class SupabaseTaskRepository {
return context.briefId;
}
- async getTasks(_projectId?: string): Promise<Task[]> {
+ async getTasks(
+ _projectId?: string,
+ options?: LoadTasksOptions
+ ): Promise<Task[]> {
const briefId = this.getBriefIdOrThrow();
- // Get all tasks for the brief using the exact query structure
- const { data: tasks, error } = await this.supabase
+ // Build query with filters
+ let query = this.supabase
.from('tasks')
.select(`
*,
@@ -71,7 +75,22 @@ export class SupabaseTaskRepository {
description
)
`)
- .eq('brief_id', briefId)
+ .eq('brief_id', briefId);
+
+ // Apply status filter at database level if specified
+ if (options?.status) {
+ const dbStatus = this.mapStatusToDatabase(options.status);
+ query = query.eq('status', dbStatus);
+ }
+
+ // Apply subtask exclusion at database level if specified
+ if (options?.excludeSubtasks) {
+ // Only fetch parent tasks (where parent_task_id is null)
+ query = query.is('parent_task_id', null);
+ }
+
+ // Execute query with ordering
+ const { data: tasks, error } = await query
.order('position', { ascending: true })
.order('subtask_position', { ascending: true })
.order('created_at', { ascending: true });
diff --git a/packages/tm-core/src/repositories/task-repository.interface.ts b/packages/tm-core/src/repositories/task-repository.interface.ts
index d256e551..0d5928d3 100644
--- a/packages/tm-core/src/repositories/task-repository.interface.ts
+++ b/packages/tm-core/src/repositories/task-repository.interface.ts
@@ -1,8 +1,9 @@
import { Task, TaskTag } from '../types/index.js';
+import { LoadTasksOptions } from '../interfaces/storage.interface.js';
export interface TaskRepository {
// Task operations
- getTasks(projectId: string): Promise<Task[]>;
+ getTasks(projectId: string, options?: LoadTasksOptions): Promise<Task[]>;
getTask(projectId: string, taskId: string): Promise<Task | null>;
createTask(projectId: string, task: Omit<Task, 'id'>): Promise<Task>;
updateTask(
diff --git a/packages/tm-core/src/services/export.service.ts b/packages/tm-core/src/services/export.service.ts
new file mode 100644
index 00000000..03037dbb
--- /dev/null
+++ b/packages/tm-core/src/services/export.service.ts
@@ -0,0 +1,496 @@
+/**
+ * @fileoverview Export Service
+ * Core service for exporting tasks to external systems (e.g., Hamster briefs)
+ */
+
+import type { Task, TaskStatus } from '../types/index.js';
+import type { UserContext } from '../auth/types.js';
+import { ConfigManager } from '../config/config-manager.js';
+import { AuthManager } from '../auth/auth-manager.js';
+import { ERROR_CODES, TaskMasterError } from '../errors/task-master-error.js';
+import { FileStorage } from '../storage/file-storage/index.js';
+
+// Type definitions for the bulk API response
+interface TaskImportResult {
+ externalId?: string;
+ index: number;
+ success: boolean;
+ taskId?: string;
+ error?: string;
+ validationErrors?: string[];
+}
+
+interface BulkTasksResponse {
+ dryRun: boolean;
+ totalTasks: number;
+ successCount: number;
+ failedCount: number;
+ skippedCount: number;
+ results: TaskImportResult[];
+ summary: {
+ message: string;
+ duration: number;
+ };
+}
+
+/**
+ * Options for exporting tasks
+ */
+export interface ExportTasksOptions {
+ /** Optional tag to export tasks from (uses active tag if not provided) */
+ tag?: string;
+ /** Brief ID to export to */
+ briefId?: string;
+ /** Organization ID (required if briefId is provided) */
+ orgId?: string;
+ /** Filter by task status */
+ status?: TaskStatus;
+ /** Exclude subtasks from export (default: false, subtasks included by default) */
+ excludeSubtasks?: boolean;
+}
+
+/**
+ * Result of the export operation
+ */
+export interface ExportResult {
+ /** Whether the export was successful */
+ success: boolean;
+ /** Number of tasks exported */
+ taskCount: number;
+ /** The brief ID tasks were exported to */
+ briefId: string;
+ /** The organization ID */
+ orgId: string;
+ /** Optional message */
+ message?: string;
+ /** Error details if export failed */
+ error?: {
+ code: string;
+ message: string;
+ };
+}
+
+/**
+ * Brief information from API
+ */
+export interface Brief {
+ id: string;
+ accountId: string;
+ createdAt: string;
+ name?: string;
+}
+
+/**
+ * ExportService handles task export to external systems
+ */
+export class ExportService {
+ private configManager: ConfigManager;
+ private authManager: AuthManager;
+
+ constructor(configManager: ConfigManager, authManager: AuthManager) {
+ this.configManager = configManager;
+ this.authManager = authManager;
+ }
+
+ /**
+ * Export tasks to a brief
+ */
+ async exportTasks(options: ExportTasksOptions): Promise<ExportResult> {
+ // Validate authentication
+ if (!this.authManager.isAuthenticated()) {
+ throw new TaskMasterError(
+ 'Authentication required for export',
+ ERROR_CODES.AUTHENTICATION_ERROR
+ );
+ }
+
+ // Get current context
+ const context = this.authManager.getContext();
+
+ // Determine org and brief IDs
+ let orgId = options.orgId || context?.orgId;
+ let briefId = options.briefId || context?.briefId;
+
+ // Validate we have necessary IDs
+ if (!orgId) {
+ throw new TaskMasterError(
+ 'Organization ID is required for export. Use "tm context org" to select one.',
+ ERROR_CODES.MISSING_CONFIGURATION
+ );
+ }
+
+ if (!briefId) {
+ throw new TaskMasterError(
+ 'Brief ID is required for export. Use "tm context brief" or provide --brief flag.',
+ ERROR_CODES.MISSING_CONFIGURATION
+ );
+ }
+
+ // Get tasks from the specified or active tag
+ const activeTag = this.configManager.getActiveTag();
+ const tag = options.tag || activeTag;
+
+ // Always read tasks from local file storage for export
+ // (we're exporting local tasks to a remote brief)
+ const fileStorage = new FileStorage(this.configManager.getProjectRoot());
+ await fileStorage.initialize();
+
+ // Load tasks with filters applied at storage layer
+ const filteredTasks = await fileStorage.loadTasks(tag, {
+ status: options.status,
+ excludeSubtasks: options.excludeSubtasks
+ });
+
+ // Get total count (without filters) for comparison
+ const allTasks = await fileStorage.loadTasks(tag);
+
+ const taskListResult = {
+ tasks: filteredTasks,
+ total: allTasks.length,
+ filtered: filteredTasks.length,
+ tag,
+ storageType: 'file' as const
+ };
+
+ if (taskListResult.tasks.length === 0) {
+ return {
+ success: false,
+ taskCount: 0,
+ briefId,
+ orgId,
+ message: 'No tasks found to export',
+ error: {
+ code: 'NO_TASKS',
+ message: 'No tasks match the specified criteria'
+ }
+ };
+ }
+
+ try {
+ // Call the export API with the original tasks
+ // performExport will handle the transformation based on the method used
+ await this.performExport(orgId, briefId, taskListResult.tasks);
+
+ return {
+ success: true,
+ taskCount: taskListResult.tasks.length,
+ briefId,
+ orgId,
+ message: `Successfully exported ${taskListResult.tasks.length} task(s) to brief`
+ };
+ } catch (error) {
+ const errorMessage =
+ error instanceof Error ? error.message : String(error);
+
+ return {
+ success: false,
+ taskCount: 0,
+ briefId,
+ orgId,
+ error: {
+ code: 'EXPORT_FAILED',
+ message: errorMessage
+ }
+ };
+ }
+ }
+
+ /**
+ * Export tasks from a brief ID or URL
+ */
+ async exportFromBriefInput(briefInput: string): Promise<ExportResult> {
+ // Extract brief ID from input
+ const briefId = this.extractBriefId(briefInput);
+ if (!briefId) {
+ throw new TaskMasterError(
+ 'Invalid brief ID or URL provided',
+ ERROR_CODES.VALIDATION_ERROR
+ );
+ }
+
+ // Fetch brief to get organization
+ const brief = await this.authManager.getBrief(briefId);
+ if (!brief) {
+ throw new TaskMasterError(
+ 'Brief not found or you do not have access',
+ ERROR_CODES.NOT_FOUND
+ );
+ }
+
+ // Export with the resolved org and brief
+ return this.exportTasks({
+ orgId: brief.accountId,
+ briefId: brief.id
+ });
+ }
+
+ /**
+ * Validate export context before prompting
+ */
+ async validateContext(): Promise<{
+ hasOrg: boolean;
+ hasBrief: boolean;
+ context: UserContext | null;
+ }> {
+ const context = this.authManager.getContext();
+
+ return {
+ hasOrg: !!context?.orgId,
+ hasBrief: !!context?.briefId,
+ context
+ };
+ }
+
+ /**
+ * Transform tasks for API bulk import format (flat structure)
+ */
+ private transformTasksForBulkImport(tasks: Task[]): any[] {
+ const flatTasks: any[] = [];
+
+ // Process each task and its subtasks
+ tasks.forEach((task) => {
+ // Add parent task
+ flatTasks.push({
+ externalId: String(task.id),
+ title: task.title,
+ description: this.enrichDescription(task),
+ status: this.mapStatusForAPI(task.status),
+ priority: task.priority || 'medium',
+ dependencies: task.dependencies?.map(String) || [],
+ details: task.details,
+ testStrategy: task.testStrategy,
+ complexity: task.complexity,
+ metadata: {
+ complexity: task.complexity,
+ originalId: task.id,
+ originalDescription: task.description,
+ originalDetails: task.details,
+ originalTestStrategy: task.testStrategy
+ }
+ });
+
+ // Add subtasks if they exist
+ if (task.subtasks && task.subtasks.length > 0) {
+ task.subtasks.forEach((subtask) => {
+ flatTasks.push({
+ externalId: `${task.id}.${subtask.id}`,
+ parentExternalId: String(task.id),
+ title: subtask.title,
+ description: this.enrichDescription(subtask),
+ status: this.mapStatusForAPI(subtask.status),
+ priority: subtask.priority || 'medium',
+ dependencies:
+ subtask.dependencies?.map((dep) => {
+ // Convert subtask dependencies to full ID format
+ if (String(dep).includes('.')) {
+ return String(dep);
+ }
+ return `${task.id}.${dep}`;
+ }) || [],
+ details: subtask.details,
+ testStrategy: subtask.testStrategy,
+ complexity: subtask.complexity,
+ metadata: {
+ complexity: subtask.complexity,
+ originalId: subtask.id,
+ originalDescription: subtask.description,
+ originalDetails: subtask.details,
+ originalTestStrategy: subtask.testStrategy
+ }
+ });
+ });
+ }
+ });
+
+ return flatTasks;
+ }
+
+ /**
+ * Enrich task/subtask description with implementation details and test strategy
+ * Creates a comprehensive markdown-formatted description
+ */
+ private enrichDescription(taskOrSubtask: Task | any): string {
+ const sections: string[] = [];
+
+ // Start with original description if it exists
+ if (taskOrSubtask.description) {
+ sections.push(taskOrSubtask.description);
+ }
+
+ // Add implementation details section
+ if (taskOrSubtask.details) {
+ sections.push('## Implementation Details\n');
+ sections.push(taskOrSubtask.details);
+ }
+
+ // Add test strategy section
+ if (taskOrSubtask.testStrategy) {
+ sections.push('## Test Strategy\n');
+ sections.push(taskOrSubtask.testStrategy);
+ }
+
+ // Join sections with double newlines for better markdown formatting
+ return sections.join('\n\n').trim() || 'No description provided';
+ }
+
+ /**
+ * Map internal status to API status format
+ */
+ private mapStatusForAPI(status?: string): string {
+ switch (status) {
+ case 'pending':
+ return 'todo';
+ case 'in-progress':
+ return 'in_progress';
+ case 'done':
+ return 'done';
+ default:
+ return 'todo';
+ }
+ }
+
+ /**
+ * Perform the actual export API call
+ */
+ private async performExport(
+ orgId: string,
+ briefId: string,
+ tasks: any[]
+ ): Promise<void> {
+ // Check if we should use the API endpoint or direct Supabase
+ const useAPIEndpoint = process.env.TM_PUBLIC_BASE_DOMAIN;
+
+ if (useAPIEndpoint) {
+ // Use the new bulk import API endpoint
+ const apiUrl = `${process.env.TM_PUBLIC_BASE_DOMAIN}/ai/api/v1/briefs/${briefId}/tasks/bulk`;
+
+ // Transform tasks to flat structure for API
+ const flatTasks = this.transformTasksForBulkImport(tasks);
+
+ // Prepare request body
+ const requestBody = {
+ source: 'task-master-cli',
+ accountId: orgId,
+ options: {
+ dryRun: false,
+ stopOnError: false
+ },
+ tasks: flatTasks
+ };
+
+ // Get auth token
+ const credentials = this.authManager.getCredentials();
+ if (!credentials || !credentials.token) {
+ throw new Error('Not authenticated');
+ }
+
+ // Make API request
+ const response = await fetch(apiUrl, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ Authorization: `Bearer ${credentials.token}`
+ },
+ body: JSON.stringify(requestBody)
+ });
+
+ if (!response.ok) {
+ const errorText = await response.text();
+ throw new Error(
+ `API request failed: ${response.status} - ${errorText}`
+ );
+ }
+
+ const result = (await response.json()) as BulkTasksResponse;
+
+ if (result.failedCount > 0) {
+ const failedTasks = result.results
+ .filter((r) => !r.success)
+ .map((r) => `${r.externalId}: ${r.error}`)
+ .join(', ');
+ console.warn(
+ `Warning: ${result.failedCount} tasks failed to import: ${failedTasks}`
+ );
+ }
+
+ console.log(
+ `Successfully exported ${result.successCount} of ${result.totalTasks} tasks to brief ${briefId}`
+ );
+ } else {
+ // Direct Supabase approach is no longer supported
+ // The extractTasks method has been removed from SupabaseTaskRepository
+ // as we now exclusively use the API endpoint for exports
+ throw new Error(
+ 'Export API endpoint not configured. Please set TM_PUBLIC_BASE_DOMAIN environment variable to enable task export.'
+ );
+ }
+ }
+
+ /**
+ * Extract a brief ID from raw input (ID or URL)
+ */
+ private extractBriefId(input: string): string | null {
+ const raw = input?.trim() ?? '';
+ if (!raw) return null;
+
+ const parseUrl = (s: string): URL | null => {
+ try {
+ return new URL(s);
+ } catch {}
+ try {
+ return new URL(`https://${s}`);
+ } catch {}
+ return null;
+ };
+
+ const fromParts = (path: string): string | null => {
+ const parts = path.split('/').filter(Boolean);
+ const briefsIdx = parts.lastIndexOf('briefs');
+ const candidate =
+ briefsIdx >= 0 && parts.length > briefsIdx + 1
+ ? parts[briefsIdx + 1]
+ : parts[parts.length - 1];
+ return candidate?.trim() || null;
+ };
+
+ // Try to parse as URL
+ const url = parseUrl(raw);
+ if (url) {
+ const qId = url.searchParams.get('id') || url.searchParams.get('briefId');
+ const candidate = (qId || fromParts(url.pathname)) ?? null;
+ if (candidate) {
+ if (this.isLikelyId(candidate) || candidate.length >= 8) {
+ return candidate;
+ }
+ }
+ }
+
+ // Check if it looks like a path without scheme
+ if (raw.includes('/')) {
+ const candidate = fromParts(raw);
+ if (candidate && (this.isLikelyId(candidate) || candidate.length >= 8)) {
+ return candidate;
+ }
+ }
+
+ // Return as-is if it looks like an ID
+ if (this.isLikelyId(raw) || raw.length >= 8) {
+ return raw;
+ }
+
+ return null;
+ }
+
+ /**
+ * Check if a string looks like a brief ID (UUID-like)
+ */
+ private isLikelyId(value: string): boolean {
+ const uuidRegex =
+ /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+ const ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
+ const slugRegex = /^[A-Za-z0-9_-]{16,}$/;
+ return (
+ uuidRegex.test(value) || ulidRegex.test(value) || slugRegex.test(value)
+ );
+ }
+}
diff --git a/packages/tm-core/src/services/index.ts b/packages/tm-core/src/services/index.ts
index d436f950..004c472b 100644
--- a/packages/tm-core/src/services/index.ts
+++ b/packages/tm-core/src/services/index.ts
@@ -5,4 +5,9 @@
export { TaskService } from './task-service.js';
export { OrganizationService } from './organization.service.js';
+export { ExportService } from './export.service.js';
export type { Organization, Brief } from './organization.service.js';
+export type {
+ ExportTasksOptions,
+ ExportResult
+} from './export.service.js';
diff --git a/packages/tm-core/src/services/task-service.ts b/packages/tm-core/src/services/task-service.ts
index c0c01839..60fb7d3c 100644
--- a/packages/tm-core/src/services/task-service.ts
+++ b/packages/tm-core/src/services/task-service.ts
@@ -14,6 +14,7 @@ import { ConfigManager } from '../config/config-manager.js';
import { StorageFactory } from '../storage/storage-factory.js';
import { TaskEntity } from '../entities/task.entity.js';
import { ERROR_CODES, TaskMasterError } from '../errors/task-master-error.js';
+import { getLogger } from '../logger/factory.js';
/**
* Result returned by getTaskList
@@ -51,6 +52,7 @@ export class TaskService {
private configManager: ConfigManager;
private storage: IStorage;
private initialized = false;
+ private logger = getLogger('TaskService');
constructor(configManager: ConfigManager) {
this.configManager = configManager;
@@ -90,37 +92,76 @@ export class TaskService {
const tag = options.tag || activeTag;
try {
- // Load raw tasks from storage - storage only knows about tags
- const rawTasks = await this.storage.loadTasks(tag);
+ // Determine if we can push filters to storage layer
+ const canPushStatusFilter =
+ options.filter?.status &&
+ !options.filter.priority &&
+ !options.filter.tags &&
+ !options.filter.assignee &&
+ !options.filter.search &&
+ options.filter.hasSubtasks === undefined;
+
+ // Build storage-level options
+ const storageOptions: any = {};
+
+ // Push status filter to storage if it's the only filter
+ if (canPushStatusFilter) {
+ const statuses = Array.isArray(options.filter!.status)
+ ? options.filter!.status
+ : [options.filter!.status];
+ // Only push single status to storage (multiple statuses need in-memory filtering)
+ if (statuses.length === 1) {
+ storageOptions.status = statuses[0];
+ }
+ }
+
+ // Push subtask exclusion to storage
+ if (options.includeSubtasks === false) {
+ storageOptions.excludeSubtasks = true;
+ }
+
+ // Load tasks from storage with pushed-down filters
+ const rawTasks = await this.storage.loadTasks(tag, storageOptions);
+
+ // Get total count without status filters, but preserve subtask exclusion
+ const baseOptions: any = {};
+ if (options.includeSubtasks === false) {
+ baseOptions.excludeSubtasks = true;
+ }
+
+ const allTasks =
+ storageOptions.status !== undefined
+ ? await this.storage.loadTasks(tag, baseOptions)
+ : rawTasks;
// Convert to TaskEntity for business logic operations
const taskEntities = TaskEntity.fromArray(rawTasks);
- // Apply filters if provided
+ // Apply remaining filters in-memory if needed
let filteredEntities = taskEntities;
- if (options.filter) {
+ if (options.filter && !canPushStatusFilter) {
+ filteredEntities = this.applyFilters(taskEntities, options.filter);
+ } else if (
+ options.filter?.status &&
+ Array.isArray(options.filter.status) &&
+ options.filter.status.length > 1
+ ) {
+ // Multiple statuses - filter in-memory
filteredEntities = this.applyFilters(taskEntities, options.filter);
}
// Convert back to plain objects
- let tasks = filteredEntities.map((entity) => entity.toJSON());
-
- // Handle subtasks option
- if (options.includeSubtasks === false) {
- tasks = tasks.map((task) => ({
- ...task,
- subtasks: []
- }));
- }
+ const tasks = filteredEntities.map((entity) => entity.toJSON());
return {
tasks,
- total: rawTasks.length,
+ total: allTasks.length,
filtered: filteredEntities.length,
tag: tag, // Return the actual tag being used (either explicitly provided or active tag)
storageType: this.getStorageType()
};
} catch (error) {
+ this.logger.error('Failed to get task list', error);
throw new TaskMasterError(
'Failed to get task list',
ERROR_CODES.INTERNAL_ERROR,
diff --git a/packages/tm-core/src/storage/api-storage.ts b/packages/tm-core/src/storage/api-storage.ts
index d7fe906d..8a1fcd22 100644
--- a/packages/tm-core/src/storage/api-storage.ts
+++ b/packages/tm-core/src/storage/api-storage.ts
@@ -6,7 +6,8 @@
import type {
IStorage,
StorageStats,
- UpdateStatusResult
+ UpdateStatusResult,
+ LoadTasksOptions
} from '../interfaces/storage.interface.js';
import type {
Task,
@@ -146,7 +147,7 @@ export class ApiStorage implements IStorage {
* Load tasks from API
* In our system, the tag parameter represents a brief ID
*/
- async loadTasks(tag?: string): Promise<Task[]> {
+ async loadTasks(tag?: string, options?: LoadTasksOptions): Promise<Task[]> {
await this.ensureInitialized();
try {
@@ -160,9 +161,9 @@ export class ApiStorage implements IStorage {
);
}
- // Load tasks from the current brief context
+ // Load tasks from the current brief context with filters pushed to repository
const tasks = await this.retryOperation(() =>
- this.repository.getTasks(this.projectId)
+ this.repository.getTasks(this.projectId, options)
);
// Update the tag cache with the loaded task IDs
diff --git a/packages/tm-core/src/storage/file-storage/file-storage.ts b/packages/tm-core/src/storage/file-storage/file-storage.ts
index 73749e70..d3fe29fd 100644
--- a/packages/tm-core/src/storage/file-storage/file-storage.ts
+++ b/packages/tm-core/src/storage/file-storage/file-storage.ts
@@ -6,7 +6,8 @@ import type { Task, TaskMetadata, TaskStatus } from '../../types/index.js';
import type {
IStorage,
StorageStats,
- UpdateStatusResult
+ UpdateStatusResult,
+ LoadTasksOptions
} from '../../interfaces/storage.interface.js';
import { FormatHandler } from './format-handler.js';
import { FileOperations } from './file-operations.js';
@@ -92,15 +93,30 @@ export class FileStorage implements IStorage {
* Load tasks from the single tasks.json file for a specific tag
* Enriches tasks with complexity data from the complexity report
*/
- async loadTasks(tag?: string): Promise<Task[]> {
+ async loadTasks(tag?: string, options?: LoadTasksOptions): Promise<Task[]> {
const filePath = this.pathResolver.getTasksPath();
const resolvedTag = tag || 'master';
try {
const rawData = await this.fileOps.readJson(filePath);
- const tasks = this.formatHandler.extractTasks(rawData, resolvedTag);
+ let tasks = this.formatHandler.extractTasks(rawData, resolvedTag);
+
+ // Apply filters if provided
+ if (options) {
+ // Filter by status if specified
+ if (options.status) {
+ tasks = tasks.filter((task) => task.status === options.status);
+ }
+
+ // Exclude subtasks if specified
+ if (options.excludeSubtasks) {
+ tasks = tasks.map((task) => ({
+ ...task,
+ subtasks: []
+ }));
+ }
+ }
- // Enrich tasks with complexity data
return await this.enrichTasksWithComplexity(tasks, resolvedTag);
} catch (error: any) {
if (error.code === 'ENOENT') {
diff --git a/packages/tm-core/src/task-master-core.ts b/packages/tm-core/src/task-master-core.ts
index 47616d91..8b0d07ee 100644
--- a/packages/tm-core/src/task-master-core.ts
+++ b/packages/tm-core/src/task-master-core.ts
@@ -14,7 +14,14 @@ import {
type StartTaskResult,
type ConflictCheckResult
} from './services/task-execution-service.js';
+import {
+ ExportService,
+ type ExportTasksOptions,
+ type ExportResult
+} from './services/export.service.js';
+import { AuthManager } from './auth/auth-manager.js';
import { ERROR_CODES, TaskMasterError } from './errors/task-master-error.js';
+import type { UserContext } from './auth/types.js';
import type { IConfiguration } from './interfaces/configuration.interface.js';
import type {
Task,
@@ -47,6 +54,10 @@ export type {
StartTaskResult,
ConflictCheckResult
} from './services/task-execution-service.js';
+export type {
+ ExportTasksOptions,
+ ExportResult
+} from './services/export.service.js';
/**
* TaskMasterCore facade class
@@ -56,6 +67,7 @@ export class TaskMasterCore {
private configManager: ConfigManager;
private taskService: TaskService;
private taskExecutionService: TaskExecutionService;
+ private exportService: ExportService;
private executorService: ExecutorService | null = null;
/**
@@ -80,6 +92,7 @@ export class TaskMasterCore {
this.configManager = null as any;
this.taskService = null as any;
this.taskExecutionService = null as any;
+ this.exportService = null as any;
}
/**
@@ -109,6 +122,10 @@ export class TaskMasterCore {
// Create task execution service
this.taskExecutionService = new TaskExecutionService(this.taskService);
+
+ // Create export service
+ const authManager = AuthManager.getInstance();
+ this.exportService = new ExportService(this.configManager, authManager);
} catch (error) {
throw new TaskMasterError(
'Failed to initialize TaskMasterCore',
@@ -242,6 +259,33 @@ export class TaskMasterCore {
return this.taskExecutionService.getNextAvailableTask();
}
+ // ==================== Export Service Methods ====================
+
+ /**
+ * Export tasks to an external system (e.g., Hamster brief)
+ */
+ async exportTasks(options: ExportTasksOptions): Promise<ExportResult> {
+ return this.exportService.exportTasks(options);
+ }
+
+ /**
+ * Export tasks from a brief ID or URL
+ */
+ async exportFromBriefInput(briefInput: string): Promise<ExportResult> {
+ return this.exportService.exportFromBriefInput(briefInput);
+ }
+
+ /**
+ * Validate export context before prompting
+ */
+ async validateExportContext(): Promise<{
+ hasOrg: boolean;
+ hasBrief: boolean;
+ context: UserContext | null;
+ }> {
+ return this.exportService.validateContext();
+ }
+
// ==================== Executor Service Methods ====================
/**
diff --git a/scripts/modules/commands.js b/scripts/modules/commands.js
index 90e2d252..f9a45f67 100644
--- a/scripts/modules/commands.js
+++ b/scripts/modules/commands.js
@@ -12,17 +12,11 @@ import https from 'https';
import http from 'http';
import inquirer from 'inquirer';
import search from '@inquirer/search';
-import ora from 'ora'; // Import ora
import { log, readJSON } from './utils.js';
-// Import new commands from @tm/cli
+// Import command registry and utilities from @tm/cli
import {
- ListTasksCommand,
- ShowCommand,
- AuthCommand,
- ContextCommand,
- StartCommand,
- SetStatusCommand,
+ registerAllCommands,
checkForUpdate,
performAutoUpdate,
displayUpgradeNotification
@@ -32,7 +26,6 @@ import {
parsePRD,
updateTasks,
generateTaskFiles,
- listTasks,
expandTask,
expandAllTasks,
clearSubtasks,
@@ -53,11 +46,7 @@ import {
validateStrength
} from './task-manager.js';
-import {
- moveTasksBetweenTags,
- MoveTaskError,
- MOVE_ERROR_CODES
-} from './task-manager/move-task.js';
+import { moveTasksBetweenTags } from './task-manager/move-task.js';
import {
createTag,
@@ -72,9 +61,7 @@ import {
addDependency,
removeDependency,
validateDependenciesCommand,
- fixDependenciesCommand,
- DependencyError,
- DEPENDENCY_ERROR_CODES
+ fixDependenciesCommand
} from './dependency-manager.js';
import {
@@ -103,7 +90,6 @@ import {
displayBanner,
displayHelp,
displayNextTask,
- displayTaskById,
displayComplexityReport,
getStatusWithColor,
confirmTaskOverwrite,
@@ -112,8 +98,6 @@ import {
displayModelConfiguration,
displayAvailableModels,
displayApiKeyStatus,
- displayAiUsageSummary,
- displayMultipleTasksSummary,
displayTaggedTasksFYI,
displayCurrentTagIndicator,
displayCrossTagDependencyError,
@@ -137,10 +121,6 @@ import {
setModel,
getApiKeyStatusReport
} from './task-manager/models.js';
-import {
- isValidTaskStatus,
- TASK_STATUS_OPTIONS
-} from '../../src/constants/task-status.js';
import {
isValidRulesAction,
RULES_ACTIONS,
@@ -1687,29 +1667,12 @@ function registerCommands(programInstance) {
});
});
- // Register the set-status command from @tm/cli
- // Handles task status updates with proper error handling and validation
- SetStatusCommand.registerOn(programInstance);
-
- // NEW: Register the new list command from @tm/cli
- // This command handles all its own configuration and logic
- ListTasksCommand.registerOn(programInstance);
-
- // Register the auth command from @tm/cli
- // Handles authentication with tryhamster.com
- AuthCommand.registerOn(programInstance);
-
- // Register the context command from @tm/cli
- // Manages workspace context (org/brief selection)
- ContextCommand.registerOn(programInstance);
-
- // Register the show command from @tm/cli
- // Displays detailed information about tasks
- ShowCommand.registerOn(programInstance);
-
- // Register the start command from @tm/cli
- // Starts working on a task by launching claude-code with a standardized prompt
- StartCommand.registerOn(programInstance);
+ // ========================================
+ // Register All Commands from @tm/cli
+ // ========================================
+ // Use the centralized command registry to register all CLI commands
+ // This replaces individual command registrations and reduces duplication
+ registerAllCommands(programInstance);
// expand command
programInstance
diff --git a/tsdown.config.ts b/tsdown.config.ts
index 0d877c49..24a1aef5 100644
--- a/tsdown.config.ts
+++ b/tsdown.config.ts
@@ -1,6 +1,10 @@
import { defineConfig } from 'tsdown';
import { baseConfig, mergeConfig } from '@tm/build-config';
-import 'dotenv/config';
+import { config } from 'dotenv';
+import { resolve } from 'path';
+
+// Load .env file explicitly with absolute path
+config({ path: resolve(process.cwd(), '.env') });
// Get all TM_PUBLIC_* env variables for build-time injection
const getBuildTimeEnvs = () => {