rbin-task-flow 1.27.1 → 1.30.3

package/lib/install.js

@@ -1,4 +1,5 @@
 const fs = require('fs-extra');
+const os = require('os');
 const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
@@ -23,7 +24,6 @@ const TEMPLATE_DIR = path.join(__dirname, '..');
 const PACKAGE_VERSION = require('../package.json').version;
 
 async function installInProject(targetPath, options = {}) {
-  const isUpdate = options.update || false;
   const isReset = options.reset || false;
 
   let profile;
@@ -42,8 +42,6 @@ async function installInProject(targetPath, options = {}) {
 
   if (isReset) {
     console.log(chalk.blue('♻️  Resetting RBIN Task Flow...'));
-  } else if (isUpdate) {
-    console.log(chalk.blue('🔄 Updating RBIN Task Flow...'));
   } else {
     console.log(chalk.blue('🚀 Installing RBIN Task Flow...'));
   }
@@ -59,9 +57,15 @@ async function installInProject(targetPath, options = {}) {
   console.log(
     chalk.blue('🔗 Git:'),
     shareAiConfig
-      ? chalk.yellow('share-ai-config') + chalk.gray(' (.cursor/skills + .cursor/rules versionáveis)')
-      : chalk.gray('local .cursor/ gitignored (default)')
+      ? chalk.yellow('share-ai-config') + chalk.gray(' (flag saved in install-meta.json)')
+      : chalk.gray('appends .task-flow to .gitignore')
   );
+  if (options.keepTasks) {
+    console.log(
+      chalk.blue('📋 Tasks:'),
+      chalk.yellow('keep-tasks') + chalk.gray(' (tasks.input.txt, tasks.status.md, .internal/, dev-logs/)')
+    );
+  }
   console.log('');
 
   const spinner = ora('Processing...').start();
@@ -81,8 +85,14 @@ async function installInProject(targetPath, options = {}) {
 
     spinner.text = 'Creating directories...';
 
+    let taskBackup = null;
+    const taskFlowPath = path.join(targetPath, '.task-flow');
+    if (isReset && options.keepTasks && (await fs.pathExists(taskFlowPath))) {
+      taskBackup = await backupTaskFiles(taskFlowPath);
+    }
+
     if (isReset) {
-      await fs.remove(path.join(targetPath, '.task-flow'));
+      await fs.remove(taskFlowPath);
     }
 
     const dirs = [
@@ -100,15 +110,18 @@ async function installInProject(targetPath, options = {}) {
 
     spinner.text = 'Copying configuration files...';
 
-    await copyConfigs(targetPath, { update: isUpdate, reset: isReset, profile });
+    await copyConfigs(targetPath, {
+      reset: isReset,
+      profile,
+      keepTasks: options.keepTasks === true,
+      taskBackup,
+    });
 
     spinner.text = 'Updating .gitignore...';
 
-    await updateGitignore(targetPath, { shareAiConfig });
+    await updateGitignore(targetPath);
     showSuccess('.gitignore updated');
-    if (shareAiConfig) {
-      showInfo('Git: .cursor/skills/ and .cursor/rules/ can be committed (see .gitignore comment)');
-    }
+    showInfo('Git: appended .task-flow to .gitignore');
 
     spinner.text = 'Installing agent skills...';
     await copySkillsToProject(targetPath);
@@ -144,13 +157,12 @@ async function installInProject(targetPath, options = {}) {
 }
 
 async function copyConfigs(targetPath, options = {}) {
-  const isUpdate = options.update || false;
   const isReset = options.reset || false;
   const profile = options.profile;
+  const taskBackup = options.taskBackup || null;
 
   const rulesResult = await copyCursorRules(targetPath, TEMPLATE_DIR, {
     profile,
-    update: isUpdate,
     reset: isReset,
   });
   if (rulesResult?.mode === PROFILE_MINIMAL) {
@@ -200,7 +212,11 @@ async function copyConfigs(targetPath, options = {}) {
     showSuccess('Codex instructions (AGENTS.md)');
   }
 
-  await copyTaskFlow(targetPath, { update: isUpdate, reset: isReset });
+  await copyTaskFlow(targetPath, {
+    reset: isReset,
+    keepTasks: options.keepTasks === true,
+    taskBackup,
+  });
 }
 
 const LEGACY_TASK_FLOW_ROOT_FILES = [
@@ -255,9 +271,55 @@ async function migrateLegacyTaskFlowLayout(taskFlowDest) {
   }
 }
 
+async function backupTaskFiles(taskFlowDest) {
+  const backup = {};
+  const files = ['tasks.input.txt', 'tasks.status.md'];
+  for (const name of files) {
+    const filePath = path.join(taskFlowDest, name);
+    if (await fs.pathExists(filePath)) {
+      backup[name] = await fs.readFile(filePath, 'utf8');
+    }
+  }
+  const internalPath = path.join(taskFlowDest, '.internal');
+  if (await fs.pathExists(internalPath)) {
+    backup['.internal'] = await fs.mkdtemp(path.join(os.tmpdir(), 'rbin-task-flow-internal-'));
+    await fs.copy(internalPath, path.join(backup['.internal'], '.internal'));
+  }
+  const devLogsPath = path.join(taskFlowDest, 'dev-logs');
+  if (await fs.pathExists(devLogsPath)) {
+    backup['dev-logs'] = await fs.mkdtemp(path.join(os.tmpdir(), 'rbin-task-flow-dev-logs-'));
+    await fs.copy(devLogsPath, path.join(backup['dev-logs'], 'dev-logs'));
+  }
+  return backup;
+}
+
+async function restoreTaskFiles(taskFlowDest, backup) {
+  if (!backup) return;
+  for (const name of ['tasks.input.txt', 'tasks.status.md']) {
+    if (backup[name] !== undefined) {
+      await fs.writeFile(path.join(taskFlowDest, name), backup[name], 'utf8');
+    }
+  }
+  if (backup['.internal']) {
+    const src = path.join(backup['.internal'], '.internal');
+    if (await fs.pathExists(src)) {
+      await fs.copy(src, path.join(taskFlowDest, '.internal'), { overwrite: true });
+    }
+    await fs.remove(backup['.internal']);
+  }
+  if (backup['dev-logs']) {
+    const src = path.join(backup['dev-logs'], 'dev-logs');
+    if (await fs.pathExists(src)) {
+      await fs.copy(src, path.join(taskFlowDest, 'dev-logs'), { overwrite: true });
+    }
+    await fs.remove(backup['dev-logs']);
+  }
+}
+
 async function copyTaskFlow(targetPath, options = {}) {
-  const isUpdate = options.update || false;
   const isReset = options.reset || false;
+  const keepTasks = options.keepTasks === true;
+  const taskBackup = options.taskBackup || null;
   const taskFlowSrc = path.join(TEMPLATE_DIR, '.task-flow');
   const taskFlowDest = path.join(targetPath, '.task-flow');
 
@@ -271,11 +333,15 @@ async function copyTaskFlow(targetPath, options = {}) {
     path.join(taskFlowDest, 'tasks.status.md'),
     path.join(taskFlowDest, 'install-meta.json'),
   ];
+  const PRESERVED_KEEP_TASKS = [
+    path.join(taskFlowDest, 'tasks.input.txt'),
+    path.join(taskFlowDest, 'tasks.status.md'),
+  ];
 
   await fs.copy(taskFlowSrc, taskFlowDest, {
     overwrite: true,
     filter: (src, dest) => {
-      if (isReset) {
+      if (isReset && !keepTasks) {
         return true;
       }
 
@@ -283,7 +349,11 @@ async function copyTaskFlow(targetPath, options = {}) {
         return false;
       }
 
-      if (!isUpdate && PRESERVED_ON_INIT.includes(dest) && fs.existsSync(dest)) {
+      if (keepTasks && PRESERVED_KEEP_TASKS.includes(dest) && fs.existsSync(dest)) {
+        return false;
+      }
+
+      if (!isReset && !keepTasks && PRESERVED_ON_INIT.includes(dest) && fs.existsSync(dest)) {
         return false;
       }
 
@@ -291,15 +361,20 @@ async function copyTaskFlow(targetPath, options = {}) {
     },
   });
 
+  if (taskBackup) {
+    await restoreTaskFiles(taskFlowDest, taskBackup);
+  }
+
   await fs.ensureDir(path.join(taskFlowDest, 'contexts'));
+  await fs.ensureDir(path.join(taskFlowDest, 'dev-logs'));
   await fs.ensureDir(path.join(taskFlowDest, 'guides', 'reports'));
   await migrateLegacyTaskFlowLayout(taskFlowDest);
 
   showSuccess('Task Flow directory');
-  if (isReset) {
+  if (keepTasks) {
+    showInfo('Kept: tasks.input.txt, tasks.status.md, .internal/, dev-logs/');
+  } else if (isReset) {
     showWarning('Reset completed: .task-flow was recreated from scratch');
-  } else if (isUpdate) {
-    showInfo('Protected: .internal/ (your task data is safe)');
   } else {
     showInfo('Protected on init: .internal/, tasks.input.txt, tasks.status.md');
   }

package/lib/profiles.js

@@ -68,7 +68,7 @@ async function resolveProfile(targetPath, options = {}) {
   return PROFILE_STANDARD;
 }
 
-async function copyCursorRules(targetPath, templateDir, { profile, update, reset }) {
+async function copyCursorRules(targetPath, templateDir, { profile, reset }) {
   const src = path.join(templateDir, '.cursor', 'rules');
   const dest = path.join(targetPath, '.cursor', 'rules');
 
@@ -76,7 +76,7 @@ async function copyCursorRules(targetPath, templateDir, { profile, update, reset
     return;
   }
 
-  if ((update || reset) && fs.existsSync(dest)) {
+  if (reset && fs.existsSync(dest)) {
     await fs.emptyDir(dest);
   }
   await fs.ensureDir(dest);

package/lib/version.js

@@ -97,7 +97,7 @@ async function checkModelVersion(modelName, versionInfo, settingsPath, rl) {
         }
         await fs.writeJSON(fullSettingsPath, settings, { spaces: 2 });
         console.log(chalk.green(`  ✅ ${modelName} updated to ${versionInfo.latest}`));
-        console.log(chalk.cyan('     (Repository template updated - run init/update on projects to apply)'));
+        console.log(chalk.cyan('     (Repository template updated - run init/reset on projects to apply)'));
       } else {
         console.log(chalk.cyan('     Skipped update'));
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rbin-task-flow",
-  "version": "1.27.1",
+  "version": "1.30.3",
   "description": "AI-powered task management for Claude and Cursor",
   "main": "index.js",
   "bin": {