op-tasks-cli 1.0.0

package/bin/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/index.js');

package/dist/commands/init.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInitCommand = registerInitCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const fileSync_1 = require("../utils/fileSync");
+function registerInitCommand(program) {
+    program
+        .command('init')
+        .description('Inicializar o diretório de tarefas (.tasksOP) no diretório atual')
+        .action(() => {
+        const created = (0, fileSync_1.initTasksDir)();
+        if (created) {
+            console.log(chalk_1.default.green('✔ Diretório .tasksOP criado com sucesso!'));
+        }
+        else {
+            console.log(chalk_1.default.yellow('⚠ Diretório .tasksOP já existe neste local.'));
+        }
+    });
+}

package/dist/commands/login.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLoginCommand = registerLoginCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../utils/config");
+function registerLoginCommand(program) {
+    program
+        .command('login')
+        .description('Configurar a URL e o Token do Open Project')
+        .argument('<url>', 'A URL base do seu servidor Open Project (ex: https://openproject.empresa.com)')
+        .argument('<token>', 'O token de API (apikey) gerado no Open Project')
+        .action((url, token) => {
+        (0, config_1.saveConfig)({ url, token });
+        console.log(chalk_1.default.green('✔ Configuração salva com sucesso!'));
+        console.log(chalk_1.default.gray(`URL: ${url}`));
+        console.log(chalk_1.default.gray('Token salvo de forma segura.'));
+    });
+}

package/dist/commands/sync.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSyncCommand = registerSyncCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const config_1 = require("../utils/config");
+const fileSync_1 = require("../utils/fileSync");
+const openProject_1 = require("../services/openProject");
+function registerSyncCommand(program) {
+    program
+        .command('sync')
+        .description('Sincroniza tarefas do Open Project com a pasta local .tasksOP')
+        .action(async () => {
+        const config = (0, config_1.getConfig)();
+        if (!config) {
+            console.log(chalk_1.default.red('✖ Nenhuma configuração encontrada. Execute "op-tasks login <url> <token>" primeiro.'));
+            return;
+        }
+        if (!(0, fileSync_1.checkTasksDir)()) {
+            console.log(chalk_1.default.yellow('⚠ Diretório .tasksOP não encontrado. Execute "op-tasks init" primeiro.'));
+            return;
+        }
+        const spinner = (0, ora_1.default)('Iniciando sincronização...').start();
+        const opService = new openProject_1.OpenProjectService(config);
+        try {
+            // 1. Check local tasks for updates (e.g. status changes)
+            spinner.text = 'Verificando tarefas locais...';
+            const localTasks = (0, fileSync_1.getLocalTasks)();
+            const localTasksMap = new Map(localTasks.map(t => [t.id, t]));
+            spinner.text = 'Buscando tarefas do Open Project...';
+            const userId = await opService.getCurrentUserId();
+            const remoteTasks = await opService.getMyWorkPackages(userId);
+            const remoteTasksMap = new Map(remoteTasks.map(t => [t.id, t]));
+            // Sync logic:
+            // Se uma tarefa local tem um status diferente da remota, a local vence se estivermos atualizando o OP.
+            // O caso de uso especifica: "marcar como concluida as que foram dadas como concluidas no open project"
+            // Wait, "as que foram dadas como concluidas no open project" - if the user meant:
+            // "marcar como concluidas (no OP) as que foram dadas como concluidas (localmente)" - that's upload.
+            // "ou marcar como concluidas (localmente) as que foram dadas como concluidas no open project" - that's download.
+            // We'll update the Open Project status if the local status changed and the local updatedAt is newer? 
+            // Actually, markdown doesn't track local updatedAt automatically unless we use fs.stat.
+            // Let's do a simple approach: if local status != remote status, we update OP if we assume local changes have priority during sync, OR we just download remote changes.
+            // Let's update OP if local status is "Concluída", "Closed", "Fechada", "Done" and remote is not.
+            const completedStatuses = ['closed', 'concluída', 'concluida', 'fechada', 'done'];
+            let updatedRemoteCount = 0;
+            for (const localTask of localTasks) {
+                const remoteTask = remoteTasksMap.get(localTask.id);
+                if (remoteTask) {
+                    const localIsCompleted = completedStatuses.includes(localTask.status.toLowerCase());
+                    const remoteIsCompleted = completedStatuses.includes(remoteTask.status.toLowerCase());
+                    if (localIsCompleted && !remoteIsCompleted) {
+                        spinner.text = `Atualizando status da tarefa #${localTask.id} no Open Project...`;
+                        await opService.updateWorkPackageStatus(localTask.id, remoteTask.lockVersion, localTask.status);
+                        updatedRemoteCount++;
+                        // After updating, update our local copy of remoteTask to have the new status so we don't overwrite it locally in the next step
+                        remoteTask.status = localTask.status;
+                    }
+                    else if (localTask.status !== remoteTask.status) {
+                        // If there's another difference, we can choose to push local status or pull remote status.
+                        // To be safe, we'll push local status to OP if they differ and we want local to be the source of truth for status.
+                        spinner.text = `Atualizando status da tarefa #${localTask.id} no Open Project...`;
+                        try {
+                            await opService.updateWorkPackageStatus(localTask.id, remoteTask.lockVersion, localTask.status);
+                            updatedRemoteCount++;
+                            remoteTask.status = localTask.status;
+                        }
+                        catch (e) {
+                            // Ignore if status is not valid
+                        }
+                    }
+                }
+            }
+            // 2. Download remote tasks to local (Creates new ones and updates existing ones)
+            spinner.text = 'Sincronizando tarefas para o diretório local...';
+            let updatedLocalCount = 0;
+            let createdLocalCount = 0;
+            for (const remoteTask of remoteTasks) {
+                const localTask = localTasksMap.get(remoteTask.id);
+                if (!localTask) {
+                    (0, fileSync_1.saveTaskLocally)(remoteTask);
+                    createdLocalCount++;
+                }
+                else {
+                    // Se a tarefa remota for mais nova, ou se a gente acabou de atualizar o remoteTask, salvamos.
+                    (0, fileSync_1.saveTaskLocally)(remoteTask);
+                    updatedLocalCount++;
+                }
+            }
+            spinner.succeed(chalk_1.default.green('Sincronização concluída com sucesso!'));
+            console.log(chalk_1.default.gray(`Tarefas baixadas/atualizadas localmente: ${createdLocalCount + updatedLocalCount}`));
+            console.log(chalk_1.default.gray(`Tarefas atualizadas no Open Project: ${updatedRemoteCount}`));
+        }
+        catch (error) {
+            spinner.fail(chalk_1.default.red('Erro durante a sincronização.'));
+            console.error(chalk_1.default.red(error.message || error));
+            if (error.response) {
+                console.error(chalk_1.default.gray(`Status: ${error.response.status}`));
+                console.error(chalk_1.default.gray(JSON.stringify(error.response.data)));
+            }
+        }
+    });
+}

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const login_1 = require("./commands/login");
+const init_1 = require("./commands/init");
+const sync_1 = require("./commands/sync");
+const program = new commander_1.Command();
+program
+    .name('op-tasks')
+    .description('CLI para sincronizar tarefas do Open Project localmente')
+    .version('1.0.0');
+(0, login_1.registerLoginCommand)(program);
+(0, init_1.registerInitCommand)(program);
+(0, sync_1.registerSyncCommand)(program);
+program.parse();

package/dist/services/openProject.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenProjectService = void 0;
+const axios_1 = __importDefault(require("axios"));
+class OpenProjectService {
+    constructor(config) {
+        this.client = axios_1.default.create({
+            baseURL: config.url.endsWith('/') ? config.url.slice(0, -1) : config.url,
+            headers: {
+                Authorization: `Basic ${Buffer.from(`apikey:${config.token}`).toString('base64')}`,
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    async getCurrentUserId() {
+        const response = await this.client.get('/api/v3/users/me');
+        return response.data.id;
+    }
+    async getMyWorkPackages(userId) {
+        const filters = encodeURIComponent(JSON.stringify([{ assignee: { operator: '=', values: [String(userId)] } }]));
+        // Fetch more per page if needed, default is usually 20, let's set pageSize=100
+        const response = await this.client.get(`/api/v3/work_packages?pageSize=100&filters=${filters}`);
+        return response.data._embedded.elements.map((item) => {
+            var _a;
+            return ({
+                id: item.id,
+                subject: item.subject,
+                description: ((_a = item.description) === null || _a === void 0 ? void 0 : _a.raw) || '',
+                status: item._links.status.title,
+                lockVersion: item.lockVersion,
+                updatedAt: item.updatedAt,
+            });
+        });
+    }
+    async updateWorkPackageStatus(id, lockVersion, statusName) {
+        // First, we need to find the status ID for the given status name
+        // A more robust way is to fetch all statuses and find the id
+        const statusesResponse = await this.client.get('/api/v3/statuses');
+        const statuses = statusesResponse.data._embedded.elements;
+        const targetStatus = statuses.find((s) => s.name.toLowerCase() === statusName.toLowerCase());
+        if (!targetStatus) {
+            throw new Error(`Status "${statusName}" not found in OpenProject.`);
+        }
+        await this.client.patch(`/api/v3/work_packages/${id}`, {
+            lockVersion,
+            _links: {
+                status: {
+                    href: targetStatus._links.self.href,
+                },
+            },
+        });
+    }
+}
+exports.OpenProjectService = OpenProjectService;

package/dist/utils/config.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = getConfig;
+exports.saveConfig = saveConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const configFilePath = path_1.default.join(os_1.default.homedir(), '.op-tasks-config.json');
+function getConfig() {
+    if (!fs_1.default.existsSync(configFilePath)) {
+        return null;
+    }
+    try {
+        const data = fs_1.default.readFileSync(configFilePath, 'utf8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        return null;
+    }
+}
+function saveConfig(config) {
+    fs_1.default.writeFileSync(configFilePath, JSON.stringify(config, null, 2), 'utf8');
+}

package/dist/utils/fileSync.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTasksDir = initTasksDir;
+exports.checkTasksDir = checkTasksDir;
+exports.saveTaskLocally = saveTaskLocally;
+exports.getLocalTasks = getLocalTasks;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const gray_matter_1 = __importDefault(require("gray-matter"));
+const TASKS_DIR = path_1.default.join(process.cwd(), '.tasksOP');
+function initTasksDir() {
+    if (!fs_1.default.existsSync(TASKS_DIR)) {
+        fs_1.default.mkdirSync(TASKS_DIR, { recursive: true });
+        return true; // Created
+    }
+    return false; // Already exists
+}
+function checkTasksDir() {
+    return fs_1.default.existsSync(TASKS_DIR);
+}
+function sanitizeFileName(name) {
+    return name.replace(/[^a-z0-9]/gi, '_').toLowerCase();
+}
+function saveTaskLocally(task) {
+    initTasksDir();
+    const fileName = `${task.id}-${sanitizeFileName(task.subject)}.md`;
+    const filePath = path_1.default.join(TASKS_DIR, fileName);
+    const content = gray_matter_1.default.stringify(task.description || 'Nenhuma descrição fornecida.', {
+        id: task.id,
+        subject: task.subject,
+        status: task.status,
+        lockVersion: task.lockVersion,
+        updatedAt: task.updatedAt,
+    });
+    fs_1.default.writeFileSync(filePath, content, 'utf8');
+}
+function getLocalTasks() {
+    if (!fs_1.default.existsSync(TASKS_DIR)) {
+        return [];
+    }
+    const files = fs_1.default.readdirSync(TASKS_DIR).filter((file) => file.endsWith('.md'));
+    const tasks = [];
+    for (const file of files) {
+        const filePath = path_1.default.join(TASKS_DIR, file);
+        const content = fs_1.default.readFileSync(filePath, 'utf8');
+        const parsed = (0, gray_matter_1.default)(content);
+        if (parsed.data.id) {
+            tasks.push({
+                id: parsed.data.id,
+                subject: parsed.data.subject,
+                status: parsed.data.status,
+                lockVersion: parsed.data.lockVersion,
+                updatedAt: parsed.data.updatedAt,
+                description: parsed.content.trim(),
+                filePath,
+            });
+        }
+    }
+    return tasks;
+}

package/npm_recovery_codes.txt

@@ -0,0 +1,5 @@
+18c3852e3b2bd514a6de09f91598374f4a0bc53fb7dbba87549a8101e568405e
+23fc81570c930586fb139d4541548c5c843266429ab6ff1a72e891e50d9a8c1d
+751f6fef546c9638e840f3d2cb59f7a25ebd597d06ee4d832cf4e90e76080dea
+b2c4b475f52800defe158a21c20a40b28a733ef407229f556f1e76149b2c4715
+fe8a4329e0cf7ca2531de556381a3f64b873fa7653853c832a1c9a7ac4b3cd18

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "op-tasks-cli",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "bin": {
+    "op-tasks": "bin/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node ./bin/cli.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "axios": "^1.16.1",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.3",
+    "gray-matter": "^4.0.3",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.8.0",
+    "rimraf": "^6.1.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3"
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { initTasksDir } from '../utils/fileSync';
+
+export function registerInitCommand(program: Command) {
+  program
+    .command('init')
+    .description('Inicializar o diretório de tarefas (.tasksOP) no diretório atual')
+    .action(() => {
+      const created = initTasksDir();
+      if (created) {
+        console.log(chalk.green('✔ Diretório .tasksOP criado com sucesso!'));
+      } else {
+        console.log(chalk.yellow('⚠ Diretório .tasksOP já existe neste local.'));
+      }
+    });
+}

package/src/commands/login.ts

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { saveConfig } from '../utils/config';
+
+export function registerLoginCommand(program: Command) {
+  program
+    .command('login')
+    .description('Configurar a URL e o Token do Open Project')
+    .argument('<url>', 'A URL base do seu servidor Open Project (ex: https://openproject.empresa.com)')
+    .argument('<token>', 'O token de API (apikey) gerado no Open Project')
+    .action((url: string, token: string) => {
+      saveConfig({ url, token });
+      console.log(chalk.green('✔ Configuração salva com sucesso!'));
+      console.log(chalk.gray(`URL: ${url}`));
+      console.log(chalk.gray('Token salvo de forma segura.'));
+    });
+}

package/src/commands/sync.ts

@@ -0,0 +1,109 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getConfig } from '../utils/config';
+import { checkTasksDir, getLocalTasks, saveTaskLocally } from '../utils/fileSync';
+import { OpenProjectService, WorkPackage } from '../services/openProject';
+
+export function registerSyncCommand(program: Command) {
+  program
+    .command('sync')
+    .description('Sincroniza tarefas do Open Project com a pasta local .tasksOP')
+    .action(async () => {
+      const config = getConfig();
+      if (!config) {
+        console.log(chalk.red('✖ Nenhuma configuração encontrada. Execute "op-tasks login <url> <token>" primeiro.'));
+        return;
+      }
+
+      if (!checkTasksDir()) {
+        console.log(chalk.yellow('⚠ Diretório .tasksOP não encontrado. Execute "op-tasks init" primeiro.'));
+        return;
+      }
+
+      const spinner = ora('Iniciando sincronização...').start();
+      const opService = new OpenProjectService(config);
+
+      try {
+        // 1. Check local tasks for updates (e.g. status changes)
+        spinner.text = 'Verificando tarefas locais...';
+        const localTasks = getLocalTasks();
+        const localTasksMap = new Map(localTasks.map(t => [t.id, t]));
+
+        spinner.text = 'Buscando tarefas do Open Project...';
+        const userId = await opService.getCurrentUserId();
+        const remoteTasks = await opService.getMyWorkPackages(userId);
+        const remoteTasksMap = new Map(remoteTasks.map(t => [t.id, t]));
+
+        // Sync logic:
+        // Se uma tarefa local tem um status diferente da remota, a local vence se estivermos atualizando o OP.
+        // O caso de uso especifica: "marcar como concluida as que foram dadas como concluidas no open project"
+        // Wait, "as que foram dadas como concluidas no open project" - if the user meant:
+        // "marcar como concluidas (no OP) as que foram dadas como concluidas (localmente)" - that's upload.
+        // "ou marcar como concluidas (localmente) as que foram dadas como concluidas no open project" - that's download.
+        // We'll update the Open Project status if the local status changed and the local updatedAt is newer? 
+        // Actually, markdown doesn't track local updatedAt automatically unless we use fs.stat.
+        // Let's do a simple approach: if local status != remote status, we update OP if we assume local changes have priority during sync, OR we just download remote changes.
+        // Let's update OP if local status is "Concluída", "Closed", "Fechada", "Done" and remote is not.
+        
+        const completedStatuses = ['closed', 'concluída', 'concluida', 'fechada', 'done'];
+
+        let updatedRemoteCount = 0;
+        for (const localTask of localTasks) {
+          const remoteTask = remoteTasksMap.get(localTask.id);
+          if (remoteTask) {
+            const localIsCompleted = completedStatuses.includes(localTask.status.toLowerCase());
+            const remoteIsCompleted = completedStatuses.includes(remoteTask.status.toLowerCase());
+
+            if (localIsCompleted && !remoteIsCompleted) {
+              spinner.text = `Atualizando status da tarefa #${localTask.id} no Open Project...`;
+              await opService.updateWorkPackageStatus(localTask.id, remoteTask.lockVersion, localTask.status);
+              updatedRemoteCount++;
+              // After updating, update our local copy of remoteTask to have the new status so we don't overwrite it locally in the next step
+              remoteTask.status = localTask.status; 
+            } else if (localTask.status !== remoteTask.status) {
+              // If there's another difference, we can choose to push local status or pull remote status.
+              // To be safe, we'll push local status to OP if they differ and we want local to be the source of truth for status.
+              spinner.text = `Atualizando status da tarefa #${localTask.id} no Open Project...`;
+              try {
+                await opService.updateWorkPackageStatus(localTask.id, remoteTask.lockVersion, localTask.status);
+                updatedRemoteCount++;
+                remoteTask.status = localTask.status;
+              } catch (e: any) {
+                // Ignore if status is not valid
+              }
+            }
+          }
+        }
+
+        // 2. Download remote tasks to local (Creates new ones and updates existing ones)
+        spinner.text = 'Sincronizando tarefas para o diretório local...';
+        let updatedLocalCount = 0;
+        let createdLocalCount = 0;
+
+        for (const remoteTask of remoteTasks) {
+          const localTask = localTasksMap.get(remoteTask.id);
+          if (!localTask) {
+            saveTaskLocally(remoteTask);
+            createdLocalCount++;
+          } else {
+            // Se a tarefa remota for mais nova, ou se a gente acabou de atualizar o remoteTask, salvamos.
+            saveTaskLocally(remoteTask);
+            updatedLocalCount++;
+          }
+        }
+
+        spinner.succeed(chalk.green('Sincronização concluída com sucesso!'));
+        console.log(chalk.gray(`Tarefas baixadas/atualizadas localmente: ${createdLocalCount + updatedLocalCount}`));
+        console.log(chalk.gray(`Tarefas atualizadas no Open Project: ${updatedRemoteCount}`));
+
+      } catch (error: any) {
+        spinner.fail(chalk.red('Erro durante a sincronização.'));
+        console.error(chalk.red(error.message || error));
+        if (error.response) {
+            console.error(chalk.gray(`Status: ${error.response.status}`));
+            console.error(chalk.gray(JSON.stringify(error.response.data)));
+        }
+      }
+    });
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { registerLoginCommand } from './commands/login';
+import { registerInitCommand } from './commands/init';
+import { registerSyncCommand } from './commands/sync';
+
+const program = new Command();
+
+program
+  .name('op-tasks')
+  .description('CLI para sincronizar tarefas do Open Project localmente')
+  .version('1.0.0');
+
+registerLoginCommand(program);
+registerInitCommand(program);
+registerSyncCommand(program);
+
+program.parse();

package/src/services/openProject.ts

@@ -0,0 +1,68 @@
+import axios, { AxiosInstance } from 'axios';
+import { Config } from '../utils/config';
+
+export interface WorkPackage {
+  id: number;
+  subject: string;
+  description: string;
+  status: string;
+  lockVersion: number;
+  updatedAt: string;
+}
+
+export class OpenProjectService {
+  private client: AxiosInstance;
+
+  constructor(config: Config) {
+    this.client = axios.create({
+      baseURL: config.url.endsWith('/') ? config.url.slice(0, -1) : config.url,
+      headers: {
+        Authorization: `Basic ${Buffer.from(`apikey:${config.token}`).toString('base64')}`,
+        'Content-Type': 'application/json',
+      },
+    });
+  }
+
+  async getCurrentUserId(): Promise<number> {
+    const response = await this.client.get('/api/v3/users/me');
+    return response.data.id;
+  }
+
+  async getMyWorkPackages(userId: number): Promise<WorkPackage[]> {
+    const filters = encodeURIComponent(
+      JSON.stringify([{ assignee: { operator: '=', values: [String(userId)] } }])
+    );
+    // Fetch more per page if needed, default is usually 20, let's set pageSize=100
+    const response = await this.client.get(`/api/v3/work_packages?pageSize=100&filters=${filters}`);
+    
+    return response.data._embedded.elements.map((item: any) => ({
+      id: item.id,
+      subject: item.subject,
+      description: item.description?.raw || '',
+      status: item._links.status.title,
+      lockVersion: item.lockVersion,
+      updatedAt: item.updatedAt,
+    }));
+  }
+
+  async updateWorkPackageStatus(id: number, lockVersion: number, statusName: string): Promise<void> {
+    // First, we need to find the status ID for the given status name
+    // A more robust way is to fetch all statuses and find the id
+    const statusesResponse = await this.client.get('/api/v3/statuses');
+    const statuses = statusesResponse.data._embedded.elements;
+    const targetStatus = statuses.find((s: any) => s.name.toLowerCase() === statusName.toLowerCase());
+
+    if (!targetStatus) {
+      throw new Error(`Status "${statusName}" not found in OpenProject.`);
+    }
+
+    await this.client.patch(`/api/v3/work_packages/${id}`, {
+      lockVersion,
+      _links: {
+        status: {
+          href: targetStatus._links.self.href,
+        },
+      },
+    });
+  }
+}

package/src/utils/config.ts

@@ -0,0 +1,26 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const configFilePath = path.join(os.homedir(), '.op-tasks-config.json');
+
+export interface Config {
+  url: string;
+  token: string;
+}
+
+export function getConfig(): Config | null {
+  if (!fs.existsSync(configFilePath)) {
+    return null;
+  }
+  try {
+    const data = fs.readFileSync(configFilePath, 'utf8');
+    return JSON.parse(data) as Config;
+  } catch (error) {
+    return null;
+  }
+}
+
+export function saveConfig(config: Config): void {
+  fs.writeFileSync(configFilePath, JSON.stringify(config, null, 2), 'utf8');
+}

package/src/utils/fileSync.ts

@@ -0,0 +1,71 @@
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { WorkPackage } from '../services/openProject';
+
+const TASKS_DIR = path.join(process.cwd(), '.tasksOP');
+
+export interface LocalTask extends WorkPackage {
+  filePath: string;
+}
+
+export function initTasksDir(): boolean {
+  if (!fs.existsSync(TASKS_DIR)) {
+    fs.mkdirSync(TASKS_DIR, { recursive: true });
+    return true; // Created
+  }
+  return false; // Already exists
+}
+
+export function checkTasksDir(): boolean {
+  return fs.existsSync(TASKS_DIR);
+}
+
+function sanitizeFileName(name: string): string {
+  return name.replace(/[^a-z0-9]/gi, '_').toLowerCase();
+}
+
+export function saveTaskLocally(task: WorkPackage): void {
+  initTasksDir();
+  const fileName = `${task.id}-${sanitizeFileName(task.subject)}.md`;
+  const filePath = path.join(TASKS_DIR, fileName);
+
+  const content = matter.stringify(task.description || 'Nenhuma descrição fornecida.', {
+    id: task.id,
+    subject: task.subject,
+    status: task.status,
+    lockVersion: task.lockVersion,
+    updatedAt: task.updatedAt,
+  });
+
+  fs.writeFileSync(filePath, content, 'utf8');
+}
+
+export function getLocalTasks(): LocalTask[] {
+  if (!fs.existsSync(TASKS_DIR)) {
+    return [];
+  }
+
+  const files = fs.readdirSync(TASKS_DIR).filter((file: string) => file.endsWith('.md'));
+  const tasks: LocalTask[] = [];
+
+  for (const file of files) {
+    const filePath = path.join(TASKS_DIR, file);
+    const content = fs.readFileSync(filePath, 'utf8');
+    const parsed = matter(content);
+
+    if (parsed.data.id) {
+      tasks.push({
+        id: parsed.data.id,
+        subject: parsed.data.subject,
+        status: parsed.data.status,
+        lockVersion: parsed.data.lockVersion,
+        updatedAt: parsed.data.updatedAt,
+        description: parsed.content.trim(),
+        filePath,
+      });
+    }
+  }
+
+  return tasks;
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "types": ["node"],
+    "ignoreDeprecations": "6.0"
+  },
+  "include": ["src/**/*"]
+}