rbin-task-flow 1.19.4 → 1.23.0

package/lib/install.js

@@ -3,21 +3,66 @@ const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
 const { showHeader, showSuccess, showError, showWarning, showInfo, showNextSteps } = require('./utils');
+const { setupGraphifyIntegration } = require('./graphify');
+const { copySkillsToProject } = require('./skills');
+const { setupCodexIntegration } = require('./codex');
+const { setupCursorIntegration } = require('./cursor');
+const {
+  PROFILE_MINIMAL,
+  PROFILE_STANDARD,
+  resolveProfile,
+  resolveShareAiConfig,
+  writeInstallMeta,
+  copyCursorRules,
+} = require('./profiles');
+const { updateGitignore } = require('./gitignore');
+
+const PROFILES = { STANDARD: PROFILE_STANDARD, MINIMAL: PROFILE_MINIMAL };
 
 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;
+  let shareAiConfig;
+  try {
+    profile = await resolveProfile(targetPath, { profile: options.profile });
+    shareAiConfig = await resolveShareAiConfig(targetPath, {
+      shareAiConfig: options.shareAiConfig,
+    });
+  } catch (error) {
+    showError(error.message);
+    process.exit(1);
+  }
 
   showHeader();
 
-  if (isUpdate) {
+  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...'));
   }
 
-  console.log(chalk.blue('📁 Target:'), targetPath, '\n');
+  console.log(chalk.blue('📁 Target:'), targetPath);
+  console.log(
+    chalk.blue('📦 Profile:'),
+    profile === PROFILES.MINIMAL ? chalk.yellow('minimal') : chalk.green('standard'),
+    profile === PROFILES.MINIMAL
+      ? chalk.gray('(2 always-on rules + skills; workflows via @task-flow-*)')
+      : chalk.gray('(all Cursor rules + skills)')
+  );
+  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)')
+  );
+  console.log('');
 
   const spinner = ora('Processing...').start();
 
@@ -36,10 +81,17 @@ async function installInProject(targetPath, options = {}) {
 
     spinner.text = 'Creating directories...';
 
+    if (isReset) {
+      await fs.remove(path.join(targetPath, '.task-flow'));
+    }
+
     const dirs = [
       '.cursor/rules',
+      '.cursor/skills',
       '.claude',
-      '.task-flow'
+      '.claude/skills',
+      '.task-flow',
+      '.codex'
     ];
 
     for (const dir of dirs) {
@@ -48,11 +100,33 @@ async function installInProject(targetPath, options = {}) {
 
     spinner.text = 'Copying configuration files...';
 
-    await copyConfigs(targetPath, isUpdate);
+    await copyConfigs(targetPath, { update: isUpdate, reset: isReset, profile });
 
     spinner.text = 'Updating .gitignore...';
 
-    await updateGitignore(targetPath);
+    await updateGitignore(targetPath, { shareAiConfig });
+    showSuccess('.gitignore updated');
+    if (shareAiConfig) {
+      showInfo('Git: .cursor/skills/ and .cursor/rules/ can be committed (see .gitignore comment)');
+    }
+
+    spinner.text = 'Installing agent skills...';
+    await copySkillsToProject(targetPath);
+
+    spinner.text = 'Configuring Cursor (rules + skills)...';
+    await setupCursorIntegration(targetPath, { profile });
+
+    await writeInstallMeta(targetPath, {
+      profile,
+      packageVersion: PACKAGE_VERSION,
+      shareAiConfig,
+    });
+
+    spinner.text = 'Configuring Codex (AGENTS.md + .codex/config.toml)...';
+    await setupCodexIntegration(targetPath);
+
+    spinner.text = 'Configuring Graphify coexistence...';
+    await setupGraphifyIntegration(targetPath, { extract: options.graphify === true });
 
     spinner.succeed(chalk.green('Installation completed!'));
 
@@ -69,15 +143,21 @@ async function installInProject(targetPath, options = {}) {
   }
 }
 
-async function copyConfigs(targetPath, isUpdate = false) {
-  const cursorRulesPath = path.join(TEMPLATE_DIR, '.cursor/rules');
-  const cursorRulesDest = path.join(targetPath, '.cursor/rules');
-  if (fs.existsSync(cursorRulesPath)) {
-    if (isUpdate && fs.existsSync(cursorRulesDest)) {
-      await fs.emptyDir(cursorRulesDest);
-    }
-    await fs.copy(cursorRulesPath, cursorRulesDest, { overwrite: true });
-    showSuccess('Cursor rules');
+async function copyConfigs(targetPath, options = {}) {
+  const isUpdate = options.update || false;
+  const isReset = options.reset || false;
+  const profile = options.profile;
+
+  const rulesResult = await copyCursorRules(targetPath, TEMPLATE_DIR, {
+    profile,
+    update: isUpdate,
+    reset: isReset,
+  });
+  if (rulesResult?.mode === PROFILE_MINIMAL) {
+    showSuccess(`Cursor rules (minimal: ${rulesResult.count} files, always-on only)`);
+    showInfo('Use @task-flow-* skills for sync, run, audit — omit heavy .mdc rules to save tokens');
+  } else if (rulesResult) {
+    showSuccess(`Cursor rules (${rulesResult.count} files)`);
   }
 
   const cursorSettingsPath = path.join(TEMPLATE_DIR, '.cursor/settings.json');
@@ -120,10 +200,12 @@ async function copyConfigs(targetPath, isUpdate = false) {
     showSuccess('Codex instructions (AGENTS.md)');
   }
 
-  await copyTaskFlow(targetPath, isUpdate);
+  await copyTaskFlow(targetPath, { update: isUpdate, reset: isReset });
 }
 
-async function copyTaskFlow(targetPath, isUpdate = false) {
+async function copyTaskFlow(targetPath, options = {}) {
+  const isUpdate = options.update || false;
+  const isReset = options.reset || false;
   const taskFlowSrc = path.join(TEMPLATE_DIR, '.task-flow');
   const taskFlowDest = path.join(targetPath, '.task-flow');
 
@@ -136,11 +218,16 @@ async function copyTaskFlow(targetPath, isUpdate = false) {
     path.join(taskFlowDest, 'tasks.input.txt'),
     path.join(taskFlowDest, 'tasks.status.md'),
     path.join(taskFlowDest, 'tasks.flow.md'),
+    path.join(taskFlowDest, 'install-meta.json'),
   ];
 
   await fs.copy(taskFlowSrc, taskFlowDest, {
     overwrite: true,
     filter: (src, dest) => {
+      if (isReset) {
+        return true;
+      }
+
       if (PROTECTED.some((p) => src.startsWith(p) || dest.startsWith(p))) {
         return false;
       }
@@ -168,48 +255,15 @@ async function copyTaskFlow(targetPath, isUpdate = false) {
   }
 
   showSuccess('Task Flow directory');
-  if (isUpdate) {
+  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, tasks.flow.md');
   }
 }
 
-async function updateGitignore(targetPath) {
-  const gitignorePath = path.join(targetPath, '.gitignore');
-
-  if (!fs.existsSync(gitignorePath)) {
-    await fs.writeFile(gitignorePath, '');
-  }
-
-  let content = await fs.readFile(gitignorePath, 'utf8');
-
-  const entries = [
-    '.claude/',
-    '.cursor/',
-    '.task-flow/',
-    'CLAUDE.md',
-    'AGENTS.md'
-  ];
-
-  for (const entry of entries) {
-    const regex = new RegExp(`^${entry.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`, 'gm');
-    content = content.replace(regex, '');
-  }
-
-  content = content.replace(/\n{3,}/g, '\n\n');
-
-  if (!content.endsWith('\n')) {
-    content += '\n';
-  }
-
-  content += '\n' + entries.join('\n') + '\n';
-
-  await fs.writeFile(gitignorePath, content);
-
-  showSuccess('.gitignore updated');
-}
-
 async function showModelVersions(targetPath) {
   console.log(chalk.cyan('═'.repeat(60)));
   console.log(chalk.magenta('📋 Model Versions Configured:'));

package/lib/profiles.js

@@ -0,0 +1,110 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const PROFILE_STANDARD = 'standard';
+const PROFILE_MINIMAL = 'minimal';
+
+const MINIMAL_RULE_FILES = ['task-flow-cursor.mdc', 'rbin-git-policy.mdc'];
+
+function normalizeProfile(profile) {
+  const value = String(profile || PROFILE_STANDARD).trim().toLowerCase();
+  if (value !== PROFILE_STANDARD && value !== PROFILE_MINIMAL) {
+    throw new Error(`Invalid profile "${profile}". Use "minimal" or "standard".`);
+  }
+  return value;
+}
+
+function parseProfileOption(value) {
+  return normalizeProfile(value || PROFILE_STANDARD);
+}
+
+async function readInstallMeta(targetPath) {
+  const metaPath = path.join(targetPath, '.task-flow', 'install-meta.json');
+  if (!fs.existsSync(metaPath)) {
+    return null;
+  }
+  try {
+    return await fs.readJson(metaPath);
+  } catch {
+    return null;
+  }
+}
+
+async function writeInstallMeta(targetPath, { profile, packageVersion, shareAiConfig }) {
+  const metaPath = path.join(targetPath, '.task-flow', 'install-meta.json');
+  await fs.ensureDir(path.dirname(metaPath));
+  const existing = (await readInstallMeta(targetPath)) || {};
+  const meta = {
+    ...existing,
+    profile: normalizeProfile(profile),
+    packageVersion,
+    updatedAt: new Date().toISOString(),
+  };
+  if (shareAiConfig !== undefined) {
+    meta.shareAiConfig = Boolean(shareAiConfig);
+  }
+  await fs.writeJson(metaPath, meta, { spaces: 2 });
+}
+
+async function resolveShareAiConfig(targetPath, options = {}) {
+  if (options.shareAiConfig !== undefined) {
+    return Boolean(options.shareAiConfig);
+  }
+  const meta = await readInstallMeta(targetPath);
+  if (meta && typeof meta.shareAiConfig === 'boolean') {
+    return meta.shareAiConfig;
+  }
+  return false;
+}
+
+async function resolveProfile(targetPath, options = {}) {
+  if (options.profile) {
+    return normalizeProfile(options.profile);
+  }
+  const meta = await readInstallMeta(targetPath);
+  if (meta?.profile) {
+    return normalizeProfile(meta.profile);
+  }
+  return PROFILE_STANDARD;
+}
+
+async function copyCursorRules(targetPath, templateDir, { profile, update, reset }) {
+  const src = path.join(templateDir, '.cursor', 'rules');
+  const dest = path.join(targetPath, '.cursor', 'rules');
+
+  if (!fs.existsSync(src)) {
+    return;
+  }
+
+  if ((update || reset) && fs.existsSync(dest)) {
+    await fs.emptyDir(dest);
+  }
+  await fs.ensureDir(dest);
+
+  if (profile === PROFILE_MINIMAL) {
+    for (const file of MINIMAL_RULE_FILES) {
+      const from = path.join(src, file);
+      if (fs.existsSync(from)) {
+        await fs.copy(from, path.join(dest, file), { overwrite: true });
+      }
+    }
+    return { mode: PROFILE_MINIMAL, count: MINIMAL_RULE_FILES.length };
+  }
+
+  await fs.copy(src, dest, { overwrite: true });
+  const count = (await fs.readdir(dest)).filter((name) => name.endsWith('.mdc')).length;
+  return { mode: PROFILE_STANDARD, count };
+}
+
+module.exports = {
+  PROFILE_STANDARD,
+  PROFILE_MINIMAL,
+  MINIMAL_RULE_FILES,
+  normalizeProfile,
+  parseProfileOption,
+  readInstallMeta,
+  writeInstallMeta,
+  resolveProfile,
+  resolveShareAiConfig,
+  copyCursorRules,
+};

package/lib/skills.js

@@ -0,0 +1,34 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { showSuccess, showInfo } = require('./utils');
+
+const TEMPLATE_DIR = path.join(__dirname, '..');
+const SKILLS_SRC = path.join(TEMPLATE_DIR, '.claude', 'skills');
+
+async function copySkillsToProject(targetPath) {
+  if (!fs.existsSync(SKILLS_SRC)) {
+    return false;
+  }
+
+  const destinations = [
+    path.join(targetPath, '.claude', 'skills'),
+    path.join(targetPath, '.cursor', 'skills'),
+  ];
+
+  for (const dest of destinations) {
+    await fs.ensureDir(dest);
+    await fs.copy(SKILLS_SRC, dest, { overwrite: true });
+  }
+
+  const count = (await fs.readdir(SKILLS_SRC)).filter((name) =>
+    fs.statSync(path.join(SKILLS_SRC, name)).isDirectory()
+  ).length;
+
+  showSuccess(`Agent skills (${count} skills → .claude/skills/ and .cursor/skills/)`);
+  showInfo('Claude Code: restart session if .claude/skills/ was created for the first time');
+  showInfo('Claude: /task-flow-run · Cursor: @task-flow-run in Agent (or task-flow: run next X)');
+
+  return true;
+}
+
+module.exports = { copySkillsToProject, SKILLS_SRC };

package/lib/utils.js

@@ -36,14 +36,49 @@ function showInfo(message) {
   console.log(chalk.blue('ℹ️  ' + message));
 }
 
+function measureAlwaysOnRules(targetPath) {
+  const rulesDir = path.join(targetPath, '.cursor', 'rules');
+  if (!fs.existsSync(rulesDir)) return null;
+
+  let totalBytes = 0;
+  const files = fs.readdirSync(rulesDir).filter((name) => name.endsWith('.mdc'));
+
+  for (const name of files) {
+    const filePath = path.join(rulesDir, name);
+    const content = fs.readFileSync(filePath, 'utf8');
+    if (/alwaysApply:\s*true\b/.test(content)) {
+      totalBytes += Buffer.byteLength(content, 'utf8');
+    }
+  }
+
+  if (totalBytes === 0) return null;
+  return {
+    bytes: totalBytes,
+    kb: totalBytes / 1024,
+    approxTokens: Math.round(totalBytes / 4),
+  };
+}
+
 function showNextSteps(targetPath) {
+  const alwaysOn = measureAlwaysOnRules(targetPath);
+
   console.log('\n' + chalk.cyan('═'.repeat(60)));
   console.log(chalk.magenta.bold('  Next Steps:'));
   console.log(chalk.cyan('═'.repeat(60)));
+  if (alwaysOn) {
+    const kbLabel = alwaysOn.kb < 10 ? alwaysOn.kb.toFixed(1) : String(Math.round(alwaysOn.kb));
+    console.log(
+      chalk.gray('  Always-on rules:'),
+      chalk.yellow(`~${kbLabel} KB`),
+      chalk.gray(`(~${alwaysOn.approxTokens.toLocaleString('en-US')} tokens est.)`)
+    );
+  }
   console.log(chalk.blue('  1.'), 'Edit', chalk.yellow('.task-flow/tasks.input.txt'));
-  console.log(chalk.blue('  2.'), 'Use AI command:', chalk.cyan('task-flow: sync'));
-  console.log(chalk.blue('  3.'), 'Work on tasks:', chalk.cyan('task-flow: run next X'));
+  console.log(chalk.blue('  2.'), 'Sync:', chalk.cyan('task-flow: sync'), chalk.gray('· Cursor/Claude: @task-flow-sync or /task-flow-sync'));
+  console.log(chalk.blue('  3.'), 'Run:', chalk.cyan('task-flow: run next X'), chalk.gray('· @task-flow-run'));
   console.log(chalk.blue('  4.'), 'Check status:', chalk.cyan('task-flow: status'));
+  console.log(chalk.blue('  5.'), 'Codex:', chalk.gray('AGENTS.md + .task-flow/CODEX.md on demand'));
+  console.log(chalk.blue('  6.'), 'Optional Graphify:', chalk.yellow('graphify extract .'), chalk.gray('— .task-flow/GRAPHIFY.md'));
   console.log(chalk.cyan('═'.repeat(60)));
   console.log(chalk.blue('\n  See'), chalk.yellow('.task-flow/README.md'), chalk.blue('for all available commands\n'));
 }
@@ -69,5 +104,6 @@ module.exports = {
   showWarning,
   showInfo,
   showNextSteps,
+  measureAlwaysOnRules,
   parseTaskIds
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rbin-task-flow",
-  "version": "1.19.4",
+  "version": "1.23.0",
   "description": "AI-powered task management for Claude and Cursor",
   "main": "index.js",
   "bin": {
@@ -9,7 +9,8 @@
   },
   "scripts": {
     "test": "echo \"No tests yet\"",
-    "prepublishOnly": "chmod +x bin/cli.js"
+    "measure:rules": "node scripts/measure-rule-bytes.js",
+    "prepublishOnly": "npm run measure:rules && chmod +x bin/cli.js scripts/measure-rule-bytes.js"
   },
   "keywords": [
     "task-flow",
@@ -32,10 +33,13 @@
     "bin/",
     ".cursor/",
     ".claude/",
+    ".claude/skills/",
+    ".cursor/skills/",
     ".task-flow/",
     ".model-versions.json",
     "CLAUDE.md",
     "AGENTS.md",
+    ".codex/",
     "lib/"
   ],
   "preferGlobal": true,