@workdynamite/cli 1.0.0

package/src/commands/logout.ts

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { clearConfig, isAuthenticated, getConfig } from '../lib/config.js';
+
+export const logoutCommand = new Command('logout')
+  .description('Sign out of WorkDynamite')
+  .action(async () => {
+    if (!isAuthenticated()) {
+      console.log(chalk.yellow('Not currently logged in.'));
+      return;
+    }
+
+    const config = getConfig();
+    const email = config.user?.email || 'unknown';
+    
+    clearConfig();
+    
+    console.log(chalk.green(`✓ Logged out from ${email}`));
+    console.log(chalk.dim('Your API token has been removed from local storage.'));
+    console.log(chalk.dim('To revoke the token entirely, visit Workspace Settings in the web app.'));
+  });

package/src/commands/pick.ts

@@ -0,0 +1,80 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import clipboard from 'clipboardy';
+import { getTasks } from '../lib/api.js';
+import { isAuthenticated, getConfig } from '../lib/config.js';
+
+export const pickCommand = new Command('pick')
+  .description('Copy a task reference to clipboard for commit messages')
+  .argument('<number>', 'Task number to pick')
+  .option('-w, --wip', 'Use WIP prefix')
+  .option('-f, --fixes', 'Use Fixes prefix (default)')
+  .option('-c, --closes', 'Use Closes prefix')
+  .option('-r, --refs', 'Use Refs prefix')
+  .action(async (taskNumber, options) => {
+    if (!isAuthenticated()) {
+      console.log(chalk.red('Not logged in. Run "workdynamite login" first.'));
+      return;
+    }
+
+    const spinner = ora('Finding task...').start();
+
+    const config = getConfig();
+    
+    // Fetch tasks to find the one matching the number
+    const { data, error } = await getTasks({
+      project: config.default_project || undefined,
+      limit: 100,
+    });
+
+    if (error) {
+      spinner.fail(chalk.red(`Failed to fetch tasks: ${error}`));
+      return;
+    }
+
+    const task = data!.tasks.find(t => t.number === parseInt(taskNumber, 10));
+
+    if (!task) {
+      spinner.fail(chalk.red(`Task #${taskNumber} not found in your assigned tasks.`));
+      console.log(chalk.dim('Make sure you\'re looking at the right project.'));
+      console.log(chalk.dim('Run "workdynamite tasks" to see available tasks.'));
+      return;
+    }
+
+    // Determine which prefix to use
+    let refType: 'wip' | 'fixes' | 'closes' | 'refs' = 'fixes';
+    if (options.wip) refType = 'wip';
+    else if (options.closes) refType = 'closes';
+    else if (options.refs) refType = 'refs';
+    // else default to fixes
+
+    const reference = task.refs[refType];
+
+    try {
+      await clipboard.write(reference);
+      spinner.succeed(chalk.green('Copied to clipboard!'));
+      
+      console.log('\n' + chalk.dim('─'.repeat(50)));
+      console.log('\n  ' + chalk.bold(reference));
+      console.log('\n' + chalk.dim('─'.repeat(50)));
+      
+      console.log(chalk.dim('\nPaste this in your commit message or PR title.'));
+      console.log(chalk.dim('The webhook will automatically update the task.\n'));
+
+      // Show other options
+      console.log(chalk.dim('Other formats:'));
+      if (refType !== 'wip') console.log(chalk.dim(`  -w, --wip    → ${task.refs.wip}`));
+      if (refType !== 'fixes') console.log(chalk.dim(`  -f, --fixes  → ${task.refs.fixes}`));
+      if (refType !== 'closes') console.log(chalk.dim(`  -c, --closes → ${task.refs.closes}`));
+      if (refType !== 'refs') console.log(chalk.dim(`  -r, --refs   → ${task.refs.refs}`));
+      console.log('');
+
+    } catch (clipboardError) {
+      spinner.warn(chalk.yellow('Could not copy to clipboard.'));
+      console.log('\n' + chalk.dim('─'.repeat(50)));
+      console.log('\n  ' + chalk.bold(reference));
+      console.log('\n' + chalk.dim('─'.repeat(50)));
+      console.log(chalk.dim('\nCopy the text above manually.\n'));
+    }
+  });

package/src/commands/projects.ts

@@ -0,0 +1,139 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { getProjects } from '../lib/api.js';
+import { isAuthenticated, getConfig, setDefaultProject } from '../lib/config.js';
+
+export const projectsCommand = new Command('projects')
+  .description('List and manage projects')
+  .option('--set', 'Interactively set the default project')
+  .action(async (options) => {
+    if (!isAuthenticated()) {
+      console.log(chalk.red('Not logged in. Run "workdynamite login" first.'));
+      return;
+    }
+
+    const spinner = ora('Fetching projects...').start();
+
+    const { data, error } = await getProjects();
+
+    if (error) {
+      spinner.fail(chalk.red(`Failed to fetch projects: ${error}`));
+      return;
+    }
+
+    spinner.stop();
+
+    const projects = data!.projects;
+    const config = getConfig();
+
+    if (projects.length === 0) {
+      console.log(chalk.yellow('\nNo projects found.'));
+      console.log(chalk.dim('Create a project in the web app to see it here.'));
+      return;
+    }
+
+    if (options.set) {
+      // Interactive project selection
+      const { selectedProject } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'selectedProject',
+          message: 'Select default project:',
+          choices: [
+            { name: '(None - show all projects)', value: null },
+            ...projects.map(p => ({
+              name: `${p.name} (${p.status})`,
+              value: p.id,
+            })),
+          ],
+        },
+      ]);
+
+      setDefaultProject(selectedProject);
+      
+      if (selectedProject) {
+        const project = projects.find(p => p.id === selectedProject);
+        console.log(chalk.green(`\n✓ Default project set to: ${project?.name}`));
+      } else {
+        console.log(chalk.green('\n✓ Default project cleared. Tasks from all projects will be shown.'));
+      }
+      return;
+    }
+
+    // List projects
+    console.log(chalk.bold('\n📁 Your Projects\n'));
+    console.log(chalk.dim('─'.repeat(60)));
+
+    for (const project of projects) {
+      const isDefault = project.id === config.default_project;
+      const statusColor = getStatusColor(project.status);
+      
+      console.log(
+        `  ${isDefault ? chalk.green('→') : ' '} ` +
+        `${chalk.bold(project.name.padEnd(30))} ` +
+        `${statusColor(project.status.padEnd(12))} ` +
+        `${chalk.dim(`${project.progress}%`)} ` +
+        `${chalk.dim(`[${project.role}]`)}`
+      );
+    }
+
+    console.log(chalk.dim('─'.repeat(60)));
+    console.log(chalk.dim(`\n${projects.length} project(s)`));
+    
+    if (config.default_project) {
+      const defaultProject = projects.find(p => p.id === config.default_project);
+      console.log(chalk.dim(`Default: ${defaultProject?.name || 'Unknown'}`));
+    }
+    
+    console.log(chalk.dim('\nRun "workdynamite projects --set" to change the default project.\n'));
+  });
+
+projectsCommand
+  .command('set <name>')
+  .description('Set default project by name')
+  .action(async (name) => {
+    if (!isAuthenticated()) {
+      console.log(chalk.red('Not logged in. Run "workdynamite login" first.'));
+      return;
+    }
+
+    const spinner = ora('Fetching projects...').start();
+
+    const { data, error } = await getProjects();
+
+    if (error) {
+      spinner.fail(chalk.red(`Failed to fetch projects: ${error}`));
+      return;
+    }
+
+    const project = data!.projects.find(
+      p => p.name.toLowerCase() === name.toLowerCase() || p.id === name
+    );
+
+    if (!project) {
+      spinner.fail(chalk.red(`Project "${name}" not found.`));
+      console.log(chalk.dim('Run "workdynamite projects" to see available projects.'));
+      return;
+    }
+
+    setDefaultProject(project.id);
+    spinner.succeed(chalk.green(`Default project set to: ${project.name}`));
+  });
+
+function getStatusColor(status: string): (text: string) => string {
+  switch (status.toLowerCase()) {
+    case 'active':
+    case 'in_progress':
+      return chalk.green;
+    case 'planning':
+      return chalk.blue;
+    case 'on_hold':
+      return chalk.yellow;
+    case 'completed':
+      return chalk.gray;
+    default:
+      return chalk.white;
+  }
+}

package/src/commands/status.ts

@@ -0,0 +1,87 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getMe, getProjects, getTasks } from '../lib/api.js';
+import { isAuthenticated, getConfig } from '../lib/config.js';
+
+export const statusCommand = new Command('status')
+  .description('Show current login status and context')
+  .action(async () => {
+    const config = getConfig();
+
+    console.log(chalk.bold('\n🔧 WorkDynamite CLI Status\n'));
+    console.log(chalk.dim('─'.repeat(50)));
+
+    if (!isAuthenticated()) {
+      console.log('\n  ' + chalk.red('✗') + ' Not logged in');
+      console.log(chalk.dim('\n  Run "workdynamite login" to authenticate.\n'));
+      return;
+    }
+
+    const spinner = ora('Fetching status...').start();
+
+    // Fetch user info
+    const { data: meData, error: meError } = await getMe();
+    
+    if (meError) {
+      spinner.fail(chalk.red(`Failed to fetch status: ${meError}`));
+      return;
+    }
+
+    // Fetch projects and tasks count
+    const { data: projectsData } = await getProjects();
+    const { data: tasksData } = await getTasks({ limit: 100 });
+
+    spinner.stop();
+
+    const user = meData!.user;
+    const projects = projectsData?.projects || [];
+    const tasks = tasksData?.tasks || [];
+
+    // Count tasks by state
+    const tasksByState = tasks.reduce((acc, task) => {
+      const state = task.state || 'unknown';
+      acc[state] = (acc[state] || 0) + 1;
+      return acc;
+    }, {} as Record<string, number>);
+
+    console.log('\n  ' + chalk.green('✓') + ' Logged in');
+    console.log('');
+    console.log('  ' + chalk.dim('User:     ') + chalk.bold(user.name || user.email));
+    console.log('  ' + chalk.dim('Email:    ') + user.email);
+    console.log('  ' + chalk.dim('Projects: ') + projects.length);
+    console.log('');
+
+    // Default project
+    if (config.default_project) {
+      const defaultProject = projects.find(p => p.id === config.default_project);
+      console.log('  ' + chalk.dim('Default Project: ') + chalk.cyan(defaultProject?.name || 'Unknown'));
+    } else {
+      console.log('  ' + chalk.dim('Default Project: ') + chalk.yellow('(none set)'));
+    }
+
+    console.log('');
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log(chalk.bold('\n📋 Task Summary\n'));
+
+    if (tasks.length === 0) {
+      console.log('  ' + chalk.dim('No tasks assigned'));
+    } else {
+      const inProgress = tasksByState['in_progress'] || 0;
+      const open = tasksByState['open'] || tasksByState['todo'] || 0;
+      const done = tasksByState['done'] || tasksByState['completed'] || 0;
+
+      console.log('  ' + chalk.yellow(`In Progress: ${inProgress}`));
+      console.log('  ' + chalk.blue(`Open:        ${open}`));
+      console.log('  ' + chalk.green(`Done:        ${done}`));
+      console.log('  ' + chalk.dim(`Total:       ${tasks.length}`));
+    }
+
+    console.log('');
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log(chalk.dim('\nQuick commands:'));
+    console.log(chalk.dim('  workdynamite tasks      List your tasks'));
+    console.log(chalk.dim('  workdynamite pick <#>   Copy task ref to clipboard'));
+    console.log(chalk.dim('  workdynamite projects   List your projects'));
+    console.log('');
+  });

package/src/commands/tasks.ts

@@ -0,0 +1,112 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getTasks, Task } from '../lib/api.js';
+import { isAuthenticated, getConfig } from '../lib/config.js';
+
+export const tasksCommand = new Command('tasks')
+  .description('List your assigned tasks')
+  .option('-p, --project <id>', 'Filter by project ID')
+  .option('-s, --state <state>', 'Filter by state (open, in_progress, done)')
+  .option('-l, --limit <number>', 'Maximum number of tasks', '20')
+  .action(async (options) => {
+    if (!isAuthenticated()) {
+      console.log(chalk.red('Not logged in. Run "workdynamite login" first.'));
+      return;
+    }
+
+    const spinner = ora('Fetching tasks...').start();
+
+    const config = getConfig();
+    const projectId = options.project || config.default_project;
+
+    const { data, error } = await getTasks({
+      project: projectId,
+      state: options.state,
+      limit: parseInt(options.limit, 10),
+    });
+
+    if (error) {
+      spinner.fail(chalk.red(`Failed to fetch tasks: ${error}`));
+      return;
+    }
+
+    spinner.stop();
+
+    const tasks = data!.tasks;
+
+    if (tasks.length === 0) {
+      console.log(chalk.yellow('\nNo tasks assigned to you.'));
+      console.log(chalk.dim('Create tasks in the web app to see them here.'));
+      return;
+    }
+
+    // Group tasks by project
+    const tasksByProject = tasks.reduce((acc, task) => {
+      const project = task.project || 'No Project';
+      if (!acc[project]) acc[project] = [];
+      acc[project].push(task);
+      return acc;
+    }, {} as Record<string, Task[]>);
+
+    console.log(chalk.bold('\n📋 Your Assigned Tasks\n'));
+
+    for (const [project, projectTasks] of Object.entries(tasksByProject)) {
+      console.log(chalk.bold.blue(`${project}`));
+      console.log(chalk.dim('─'.repeat(50)));
+
+      for (const task of projectTasks) {
+        const stateColor = getStateColor(task.state);
+        const priorityBadge = getPriorityBadge(task.priority);
+        
+        console.log(
+          `  ${chalk.dim('#')}${chalk.bold(String(task.number).padEnd(5))} ` +
+          `${priorityBadge} ` +
+          `${task.title.substring(0, 40)}${task.title.length > 40 ? '...' : ''} ` +
+          `${stateColor(task.state)}`
+        );
+      }
+      console.log('');
+    }
+
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log(chalk.dim(`Showing ${tasks.length} task(s)`));
+    console.log(chalk.dim('\nCommands:'));
+    console.log(chalk.dim('  workdynamite pick <number>     Copy task ref to clipboard'));
+    console.log(chalk.dim('  workdynamite pick <number> -w  Copy as WIP'));
+    console.log('');
+  });
+
+function getStateColor(state: string): (text: string) => string {
+  switch (state.toLowerCase()) {
+    case 'open':
+    case 'todo':
+      return chalk.gray;
+    case 'in_progress':
+    case 'in progress':
+      return chalk.yellow;
+    case 'done':
+    case 'completed':
+      return chalk.green;
+    case 'blocked':
+      return chalk.red;
+    default:
+      return chalk.white;
+  }
+}
+
+function getPriorityBadge(priority: string): string {
+  switch (priority?.toLowerCase()) {
+    case 'critical':
+    case 'highest':
+      return chalk.bgRed.white(' !! ');
+    case 'high':
+      return chalk.red('[H]');
+    case 'medium':
+      return chalk.yellow('[M]');
+    case 'low':
+      return chalk.green('[L]');
+    default:
+      return chalk.dim('[–]');
+  }
+}

package/src/index.ts

@@ -0,0 +1,50 @@
+import { Command } from 'commander';
+import { loginCommand } from './commands/login.js';
+import { logoutCommand } from './commands/logout.js';
+import { tasksCommand } from './commands/tasks.js';
+import { pickCommand } from './commands/pick.js';
+import { projectsCommand } from './commands/projects.js';
+import { statusCommand } from './commands/status.js';
+import { configCommand } from './commands/config.js';
+
+const program = new Command();
+
+program
+  .name('workdynamite')
+  .description('WorkDynamite CLI - Manage tasks from your terminal')
+  .version('1.0.0');
+
+// Register commands
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(tasksCommand);
+program.addCommand(pickCommand);
+program.addCommand(projectsCommand);
+program.addCommand(statusCommand);
+program.addCommand(configCommand);
+
+// Aliases
+program
+  .command('ls')
+  .description('Alias for "tasks" - list your assigned tasks')
+  .action(async () => {
+    await tasksCommand.parseAsync(['tasks'], { from: 'user' });
+  });
+
+program
+  .command('p <number>')
+  .description('Alias for "pick" - copy task reference to clipboard')
+  .option('-w, --wip', 'Use WIP prefix')
+  .option('-f, --fixes', 'Use Fixes prefix (default)')
+  .option('-c, --closes', 'Use Closes prefix')
+  .option('-r, --refs', 'Use Refs prefix')
+  .action(async (number, options) => {
+    const args = ['pick', number];
+    if (options.wip) args.push('--wip');
+    if (options.fixes) args.push('--fixes');
+    if (options.closes) args.push('--closes');
+    if (options.refs) args.push('--refs');
+    await pickCommand.parseAsync(args, { from: 'user' });
+  });
+
+program.parse();

package/src/lib/api.ts

@@ -0,0 +1,128 @@
+import { getToken, getApiUrl, getConfig } from './config.js';
+
+interface ApiResponse<T = any> {
+  data?: T;
+  error?: string;
+}
+
+async function request<T>(
+  endpoint: string,
+  options: RequestInit = {}
+): Promise<ApiResponse<T>> {
+  const token = getToken();
+  const apiUrl = getApiUrl();
+
+  if (!token && !endpoint.startsWith('login/')) {
+    return { error: 'Not authenticated. Run "workdynamite login" first.' };
+  }
+
+  const url = `${apiUrl}/${endpoint}`;
+  
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    ...((options.headers as Record<string, string>) || {}),
+  };
+
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`;
+  }
+
+  try {
+    const response = await fetch(url, {
+      ...options,
+      headers,
+    });
+
+    const data = await response.json() as T & { error?: string };
+
+    if (!response.ok) {
+      return { error: data.error || `Request failed with status ${response.status}` };
+    }
+
+    return { data };
+  } catch (error: any) {
+    return { error: error.message || 'Network request failed' };
+  }
+}
+
+export async function initLogin(): Promise<ApiResponse<{
+  device_code: string;
+  user_code: string;
+  verification_uri: string;
+  verification_uri_complete: string;
+  expires_in: number;
+  interval: number;
+}>> {
+  return request('login/init', {
+    method: 'POST',
+    body: JSON.stringify({}),
+  });
+}
+
+export async function pollLogin(deviceCode: string): Promise<ApiResponse<{
+  access_token: string;
+  token_type: string;
+  user: { id: string; email: string; name: string };
+  message?: string;
+}>> {
+  return request('login/poll', {
+    method: 'POST',
+    body: JSON.stringify({ device_code: deviceCode }),
+  });
+}
+
+export async function getMe(): Promise<ApiResponse<{
+  user: { id: string; email: string; name: string; avatar_url?: string };
+  projects_count: number;
+}>> {
+  return request('me');
+}
+
+export async function getProjects(): Promise<ApiResponse<{
+  projects: Array<{
+    id: string;
+    name: string;
+    description?: string;
+    status: string;
+    progress: number;
+    role: string;
+  }>;
+}>> {
+  return request('projects');
+}
+
+export interface Task {
+  id: string;
+  number: number;
+  title: string;
+  state: string;
+  priority: string;
+  story_points?: number;
+  due_date?: string;
+  project: string;
+  project_id: string;
+  refs: {
+    wip: string;
+    fixes: string;
+    closes: string;
+    refs: string;
+  };
+}
+
+export async function getTasks(options: {
+  project?: string;
+  state?: string;
+  limit?: number;
+} = {}): Promise<ApiResponse<{ tasks: Task[] }>> {
+  const params = new URLSearchParams();
+  if (options.project) params.set('project', options.project);
+  if (options.state) params.set('state', options.state);
+  if (options.limit) params.set('limit', options.limit.toString());
+  
+  const query = params.toString();
+  return request(`tasks${query ? `?${query}` : ''}`);
+}
+
+export async function getTask(taskId: string): Promise<ApiResponse<{ task: Task }>> {
+  return request(`tasks/${taskId}`);
+}

package/src/lib/config.ts

@@ -0,0 +1,61 @@
+import Conf from 'conf';
+
+interface ConfigSchema {
+  api_url: string;
+  token: string | null;
+  default_project: string | null;
+  user: {
+    id: string;
+    email: string;
+    name: string;
+  } | null;
+}
+
+const config = new Conf<ConfigSchema>({
+  projectName: 'workdynamite',
+  defaults: {
+    api_url: 'https://tovgfzknrookxgmvibsk.supabase.co/functions/v1/cli-api',
+    token: null,
+    default_project: null,
+    user: null,
+  },
+});
+
+export function getConfig(): ConfigSchema {
+  return {
+    api_url: config.get('api_url'),
+    token: config.get('token'),
+    default_project: config.get('default_project'),
+    user: config.get('user'),
+  };
+}
+
+export function setToken(token: string): void {
+  config.set('token', token);
+}
+
+export function setUser(user: ConfigSchema['user']): void {
+  config.set('user', user);
+}
+
+export function setDefaultProject(projectId: string | null): void {
+  config.set('default_project', projectId);
+}
+
+export function clearConfig(): void {
+  config.set('token', null);
+  config.set('user', null);
+  config.set('default_project', null);
+}
+
+export function isAuthenticated(): boolean {
+  return !!config.get('token');
+}
+
+export function getToken(): string | null {
+  return config.get('token');
+}
+
+export function getApiUrl(): string {
+  return config.get('api_url');
+}