@maccesar/titools 2.0.7 → 2.2.0

package/lib/commands/uninstall.js

@@ -3,116 +3,27 @@
  * Removes installed skills and agents
  */
 
-import inquirer from 'inquirer';
 import chalk from 'chalk';
 import ora from 'ora';
-import { SKILLS, AGENTS } from '../config.js';
+import { SKILLS } from '../config.js';
 import {
   detectPlatforms,
 } from '../platform.js';
-import { remove } from 'fs-extra';
-import { existsSync, rmSync } from 'fs';
-import { join } from 'path';
 import {
-  getAgentsSkillsDir,
-  getClaudeAgentsDir,
-  getClaudeSkillsDir,
-  getGeminiSkillsDir,
-  getCodexSkillsDir,
-} from '../config.js';
-
-/**
- * Remove skill symlinks from a platform directory
- * @param {string} platformSkillsDir - Platform skills directory
- * @returns {Object} Results object with success/failure counts
- */
-function removeSkillSymlinks(platformSkillsDir) {
-  const results = {
-    removed: [],
-    failed: [],
-  };
-
-  if (!existsSync(platformSkillsDir)) {
-    return results;
-  }
-
-  for (const skill of SKILLS) {
-    const linkPath = join(platformSkillsDir, skill);
-
-    if (existsSync(linkPath)) {
-      try {
-        rmSync(linkPath, { recursive: true, force: true });
-        results.removed.push(skill);
-      } catch (error) {
-        results.failed.push(skill);
-      }
-    }
-  }
-
-  return results;
-}
-
-/**
- * Remove skills from central directory
- * @returns {Object} Results object
- */
-function removeSkills() {
-  const skillsDir = getAgentsSkillsDir();
-  const results = {
-    removed: [],
-    failed: [],
-  };
-
-  if (!existsSync(skillsDir)) {
-    return results;
-  }
-
-  for (const skill of SKILLS) {
-    const skillPath = join(skillsDir, skill);
-
-    if (existsSync(skillPath)) {
-      try {
-        rmSync(skillPath, { recursive: true, force: true });
-        results.removed.push(skill);
-      } catch (error) {
-        results.failed.push(skill);
-      }
-    }
-  }
-
-  return results;
-}
-
-/**
- * Remove agents from Claude Code
- * @returns {Object} Results object
- */
-function removeAgents() {
-  const agentsDir = getClaudeAgentsDir();
-  const results = {
-    removed: [],
-    failed: [],
-  };
-
-  if (!existsSync(agentsDir)) {
-    return results;
-  }
-
-  for (const agent of AGENTS) {
-    const agentPath = join(agentsDir, `${agent}.md`);
-
-    if (existsSync(agentPath)) {
-      try {
-        rmSync(agentPath);
-        results.removed.push(agent);
-      } catch (error) {
-        results.failed.push(agent);
-      }
-    }
-  }
-
-  return results;
-}
+  removeSkillSymlinks,
+  removeSkills,
+  removeAgents,
+} from '../cleanup.js';
+import checkbox, { Separator } from '../prompts/checkboxCancel.js';
+import {
+  isTitaniumProject,
+  blockExists,
+  removeOldBlock,
+} from '../utils.js';
+import { existsSync } from 'fs';
+import { join, resolve } from 'path';
+import { getAgentsSkillsDir, getClaudeAgentsDir } from '../config.js';
+import { getSkillList, getAgentList } from '../cleanup.js';
 
 /**
  * Uninstall command handler
@@ -123,93 +34,217 @@ export async function uninstallCommand(options) {
   console.log(chalk.bold.blue('Titanium SDK Skills Uninstaller'));
   console.log('');
 
-  // Detect installed platforms
-  const detectedPlatforms = detectPlatforms();
-
-  if (detectedPlatforms.length === 0) {
-    console.log(chalk.yellow('No AI coding assistants detected.'));
-    console.log('However, you can still remove skills from the central directory.');
+  const projectDir = resolve(process.cwd());
+  const isProject = isTitaniumProject(projectDir);
+  const baseDir = options.local ? projectDir : undefined;
+  if (options.local) {
+    console.log(chalk.cyan('Mode: Local uninstallation (current project)'));
     console.log('');
   }
 
-  // Show detected platforms
-  for (const platform of detectedPlatforms) {
-    console.log(chalk.green('✓'), `${platform.displayName} detected`);
+  // Detect installed platforms
+  const detectedPlatforms = detectPlatforms(baseDir);
+
+  const knowledgeFiles = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md'];
+  const existingKnowledgeFiles = knowledgeFiles
+    .map((file) => ({ file, path: join(projectDir, file) }))
+    .filter(({ path }) => existsSync(path));
+  const hasKnowledgeBlocks = isProject && existingKnowledgeFiles.some(({ path }) => blockExists(path));
+
+  const skillList = getSkillList();
+  const agentList = getAgentList().map((agent) => `${agent}.md`);
+  const homeSkillsDir = getAgentsSkillsDir();
+  const projectSkillsDir = getAgentsSkillsDir(projectDir);
+  const homeAgentsDir = getClaudeAgentsDir();
+  const projectAgentsDir = getClaudeAgentsDir(projectDir);
+
+  const hasAnyInDir = (dir, names) =>
+    !!dir && existsSync(dir) && names.some((name) => existsSync(join(dir, name)));
+
+  const hasHomeSkills = hasAnyInDir(homeSkillsDir, skillList);
+  const hasProjectSkills = isProject && hasAnyInDir(projectSkillsDir, skillList);
+  const hasHomeAgents = hasAnyInDir(homeAgentsDir, agentList);
+  const hasProjectAgents = isProject && hasAnyInDir(projectAgentsDir, agentList);
+
+  const hasHomeSymlinks = detectedPlatforms.some((platform) =>
+    hasAnyInDir(platform.skillsDir, skillList)
+  );
+  const hasProjectSymlinks = isProject && detectPlatforms(projectDir).some((platform) =>
+    hasAnyInDir(platform.skillsDir, skillList)
+  );
+
+  const choices = [];
+  if (hasHomeAgents || hasProjectAgents) {
+    choices.push({ name: '`ti-pro` for Claude Code', value: 'agents', checked: true });
+  }
+  if (hasKnowledgeBlocks) {
+    choices.push({ name: 'Knowledge index from context files', value: 'knowledge', checked: true });
+  }
+  if (hasHomeSkills) {
+    choices.push({ name: 'Skills from the `home` directory', value: 'skills-home', checked: false });
+  }
+  if (hasProjectSkills) {
+    choices.push({ name: 'Skills from the `project` directory', value: 'skills-project', checked: false });
+  }
+  if (hasHomeSymlinks) {
+    choices.push({ name: 'Skill symlinks from `home` directory', value: 'symlinks-home', checked: false });
+  }
+  if (hasProjectSymlinks) {
+    choices.push({ name: 'Skill symlinks from `project` directory', value: 'symlinks-project', checked: false });
   }
-  console.log('');
 
-  // Select what to uninstall
-  const answers = await inquirer.prompt([
-    {
-      type: 'checkbox',
-      name: 'targets',
-      message: 'What do you want to uninstall?',
+  if (choices.length === 0) {
+    console.log(chalk.yellow('No skills, agents, symlinks, or knowledge index blocks found.'));
+    console.log('');
+    return;
+  }
+
+  // Modern functional checkbox selection
+  let targets = [];
+  try {
+    targets = await checkbox({
+      message: 'What do you want to uninstall:',
       choices: [
-        { name: 'Skill symlinks from all platforms', value: 'symlinks', checked: true },
-        { name: 'Skills from central directory (~/.agents/skills/)', value: 'skills', checked: false },
-        { name: 'Agents from Claude Code', value: 'agents', checked: false },
+        ...choices,
+        new Separator(' '),
       ],
-      validate: (answer) => answer.length > 0 || 'Please select at least one option',
-    },
-  ]);
+      shortcuts: { invert: null },
+      theme: {
+        style: {
+          renderSelectedChoices: () => '',
+        },
+      },
+    });
+  } catch (error) {
+    console.log('\nCancelled.');
+    process.exit(0);
+  }
 
-  if (answers.targets.includes('symlinks') && detectedPlatforms.length === 0) {
-    console.log(chalk.yellow('No platforms detected, skipping symlink removal.'));
-    answers.targets = answers.targets.filter((t) => t !== 'symlinks');
+  // Handle cancellation (by 'q')
+  if (targets.includes('cancel')) {
+    console.log('Cancelled.');
+    return;
   }
 
-  if (answers.targets.length === 0) {
-    console.log('Nothing to uninstall.');
-    process.exit(0);
+  if (targets.length === 0) {
+    console.log(chalk.yellow('Nothing to uninstall. Cancelled.'));
+    return;
   }
 
   const spinner = ora();
+  let actionTaken = false;
 
-  // Remove symlinks from platforms
-  if (answers.targets.includes('symlinks')) {
+  if (targets.includes('symlinks-home')) {
     for (const platform of detectedPlatforms) {
       spinner.start(`Removing ${platform.displayName} symlinks...`);
       const symlinkResult = removeSkillSymlinks(platform.skillsDir);
 
       if (symlinkResult.removed.length > 0) {
-        spinner.succeed(`${platform.displayName}: ${symlinkResult.removed.length} removed`);
+        spinner.succeed(`${platform.displayName}: Skills unlinked`);
+        actionTaken = true;
+      } else {
+        spinner.info(`${platform.displayName}: No symlinks found`);
+      }
+    }
+  }
+
+  if (targets.includes('symlinks-project')) {
+    const projectPlatforms = detectPlatforms(projectDir);
+    for (const platform of projectPlatforms) {
+      spinner.start(`Removing ${platform.displayName} symlinks...`);
+      const symlinkResult = removeSkillSymlinks(platform.skillsDir);
+
+      if (symlinkResult.removed.length > 0) {
+        spinner.succeed(`${platform.displayName}: Skills unlinked`);
+        actionTaken = true;
       } else {
         spinner.info(`${platform.displayName}: No symlinks found`);
       }
     }
   }
 
-  // Remove skills from central directory
-  if (answers.targets.includes('skills')) {
-    spinner.start('Removing skills from central directory...');
-    const skillsResult = removeSkills();
+  if (targets.includes('skills-home')) {
+    spinner.start('Removing skills...');
+    const skillsResult = removeSkills(undefined);
+
+    if (skillsResult.removed.length > 0) {
+      spinner.succeed(`${SKILLS.length} skills removed`);
+      actionTaken = true;
+    } else {
+      spinner.info('No skills to remove');
+    }
+  }
+
+  if (targets.includes('skills-project')) {
+    spinner.start('Removing skills...');
+    const skillsResult = removeSkills(projectDir);
 
     if (skillsResult.removed.length > 0) {
-      spinner.succeed(`Skills: ${skillsResult.removed.join(', ')}`);
+      spinner.succeed(`${SKILLS.length} skills removed`);
+      actionTaken = true;
     } else {
-      spinner.info('No skills found in central directory');
+      spinner.info('No skills to remove');
     }
   }
 
-  // Remove agents
-  if (answers.targets.includes('agents')) {
+  if (targets.includes('agents')) {
     spinner.start('Removing agents...');
-    const agentsResult = removeAgents();
+    const results = [];
+    results.push(removeAgents(undefined));
+    if (isProject) {
+      results.push(removeAgents(projectDir));
+    }
 
-    if (agentsResult.removed.length > 0) {
-      spinner.succeed(`Agents: ${agentsResult.removed.join(', ')}`);
+    const removed = results.flatMap((r) => r.removed);
+    if (removed.length > 0) {
+      spinner.succeed('Platform agents removed');
+      actionTaken = true;
     } else {
-      spinner.info('No agents found');
+      spinner.info('No agents to remove');
     }
   }
 
-  console.log('');
-  console.log(chalk.green('✓ Uninstallation complete!'));
-  console.log('');
-  console.log(chalk.gray('Note: AGENTS.md/CLAUDE.md/GEMINI.md files in your projects were NOT removed.'));
-  console.log(chalk.gray('To remove them manually:'));
-  console.log(chalk.gray('  rm -f /path/to/your/project/AGENTS.md'));
-  console.log('');
+  // Remove knowledge index blocks from project files
+  if (targets.includes('knowledge')) {
+    if (!isProject) {
+      spinner.info('Not a Titanium project, skipping knowledge cleanup');
+    } else {
+      spinner.start('Removing knowledge index...');
+      const cleaned = [];
+      for (const { file, path } of existingKnowledgeFiles) {
+        if (blockExists(path)) {
+          try {
+            removeOldBlock(path);
+            cleaned.push(file);
+          } catch {
+            // Ignore; we only report if no files were cleaned
+          }
+        }
+      }
+
+      if (cleaned.length > 0) {
+        spinner.succeed(`Knowledge index removed from: ${cleaned.join(', ')}`);
+        actionTaken = true;
+      } else {
+        spinner.info('No knowledge index blocks to remove');
+      }
+    }
+  }
+
+  if (actionTaken) {
+    console.log('');
+    console.log(chalk.green('✓ Uninstallation complete!'));
+    console.log('');
+    if (isProject && !targets.includes('knowledge')) {
+      console.log(chalk.gray('Note: Knowledge index blocks were not removed.'));
+      console.log('');
+    }
+    console.log('');
+  } else {
+    console.log('');
+    console.log(chalk.yellow('No changes were necessary.'));
+    console.log('');
+  }
 }
 
 export default uninstallCommand;

package/lib/commands/update.js

@@ -8,39 +8,104 @@ import ora from 'ora';
 import {
   PACKAGE_VERSION,
   REPO_URL,
-  REPO_API_URL,
   SKILLS,
-  AGENTS,
 } from '../config.js';
+import select from '../prompts/selectCancel.js';
 import {
   detectPlatforms,
 } from '../platform.js';
+import { cleanupLegacyArtifacts } from '../cleanup.js';
 import {
   installSkills,
   installAgents,
-  installAgentsTemplate,
   getLocalRepoDir,
 } from '../installer.js';
+import { agentsCommand } from './agents.js';
 import {
   downloadRepoArchive,
   checkForUpdate,
 } from '../downloader.js';
 import { createSkillSymlinks } from '../symlink.js';
-import { formatList } from '../utils.js';
+import { formatList, isTitaniumProject } from '../utils.js';
+import { getAgentsSkillsDir } from '../config.js';
 import { mkdtemp } from 'fs/promises';
-import { join } from 'path';
+import { existsSync } from 'fs';
+import { join, resolve } from 'path';
 import { tmpdir } from 'os';
 
 /**
  * Update command handler
+ * @param {Object} options - Command options
  */
-export async function updateCommand() {
+export async function updateCommand(options) {
   console.log('');
   console.log(chalk.bold.blue('Titanium SDK Skills Updater'));
   console.log('');
 
   const spinner = ora();
 
+  // Determine base directory
+  let baseDir = options.local ? process.cwd() : undefined;
+  const hasSkillsAt = (dir) =>
+    SKILLS.some((skill) => existsSync(join(getAgentsSkillsDir(dir), skill)));
+
+  // If not explicitly local, check if local skills exist to ask user
+  if (!options.local) {
+    const projectDir = process.cwd();
+    const isProject = isTitaniumProject(projectDir);
+    const localPlatforms = detectPlatforms(projectDir);
+    const hasLocalSkills = isProject && hasSkillsAt(projectDir);
+    const hasGlobalSkills = hasSkillsAt(undefined);
+    if (hasLocalSkills && !hasGlobalSkills) {
+      baseDir = projectDir;
+    } else if (isProject && localPlatforms.length > 0) {
+      try {
+        const scope = await select({
+          message: 'Local installation detected. What do you want to update:',
+          choices: [
+            { name: 'Global skills (user home)', value: 'global' },
+            { name: 'Local skills (current project)', value: 'local' },
+          ],
+          theme: {
+            style: {
+              answer: () => '',
+              prefix: () => chalk.cyan('?'),
+            },
+          },
+        });
+        if (scope === 'cancel') {
+          console.log('Cancelled.');
+          process.exit(0);
+        }
+        if (scope === 'local') {
+          baseDir = process.cwd();
+        }
+      } catch (error) {
+        console.log('\nCancelled.');
+        process.exit(0);
+      }
+    }
+  }
+
+  if (baseDir) {
+    console.log(chalk.cyan('Mode: Local update (current project)'));
+  } else {
+    console.log(chalk.cyan('Mode: Global update (user home)'));
+  }
+  console.log('');
+
+  const skillsDir = getAgentsSkillsDir(baseDir);
+  const hasSkillsInstalled = skillsDir && SKILLS.some((skill) => existsSync(join(skillsDir, skill)));
+  if (!hasSkillsInstalled) {
+    console.log(chalk.yellow('No skills installed at this location.'));
+    console.log('Install them first with:');
+    console.log('  titools install');
+    console.log('');
+    console.log('Looked for skills in:');
+    console.log(`  ${baseDir ? 'Local' : 'Global'}: ${skillsDir}`);
+    return;
+  }
+
   // Check for updates
   spinner.start('Checking for updates...');
 
@@ -49,8 +114,17 @@ export async function updateCommand() {
 
     if (!hasUpdate) {
       spinner.info(`Already up to date (v${PACKAGE_VERSION})`);
+      cleanupLegacyArtifacts(baseDir);
       console.log('');
       console.log(chalk.green('✓'), 'Skills and agents are already at the latest version');
+      const projectDir = resolve(process.cwd());
+      if (isTitaniumProject(projectDir)) {
+        const aiFiles = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md'];
+        const hasAnyAiFile = aiFiles.some((file) => existsSync(join(projectDir, file)));
+        if (hasAnyAiFile) {
+          await agentsCommand(projectDir, { onlyExisting: true, force: true });
+        }
+      }
       console.log('');
       return;
     }
@@ -61,12 +135,16 @@ export async function updateCommand() {
     console.log(chalk.gray(`Latest:  (from GitHub)`));
     console.log('');
 
-    // Detect installed platforms
-    const detectedPlatforms = detectPlatforms();
+    // Detect installed platforms at target
+    const detectedPlatforms = detectPlatforms(baseDir);
 
     if (detectedPlatforms.length === 0) {
       console.log(chalk.yellow('No AI coding assistants detected.'));
-      console.log('Update will install skills to ~/.agents/skills/');
+      if (baseDir) {
+        console.log('Update will install skills to ./.agents/skills/');
+      } else {
+        console.log('Update will install skills to ~/.agents/skills/');
+      }
       console.log('');
     } else {
       for (const platform of detectedPlatforms) {
@@ -91,14 +169,14 @@ export async function updateCommand() {
     try {
       // Install skills
       spinner.start('Updating skills...');
-      const skillsResult = await installSkills(repoDir);
+      const skillsResult = await installSkills(repoDir, baseDir);
       spinner.succeed(
         `Skills: ${formatList(skillsResult.installed)}`
       );
 
       // Install agents
       spinner.start('Updating agents...');
-      const agentsResult = await installAgents(repoDir);
+      const agentsResult = await installAgents(repoDir, baseDir);
       if (agentsResult.installed.length > 0) {
         spinner.succeed(
           `Agents: ${formatList(agentsResult.installed)}`
@@ -107,21 +185,15 @@ export async function updateCommand() {
         spinner.info('No agents to update');
       }
 
-      // Install AGENTS-TEMPLATE.md
-      spinner.start('Updating AGENTS-TEMPLATE.md...');
-      const templateInstalled = await installAgentsTemplate(repoDir);
-      if (templateInstalled) {
-        spinner.succeed('AGENTS-TEMPLATE.md updated');
-      } else {
-        spinner.warn('AGENTS-TEMPLATE.md not found');
-      }
+      cleanupLegacyArtifacts(baseDir);
 
       // Update symlinks for detected platforms
       for (const platform of detectedPlatforms) {
         spinner.start(`Updating ${platform.displayName} symlinks...`);
         const symlinkResult = await createSkillSymlinks(
           platform.skillsDir,
-          SKILLS
+          SKILLS,
+          baseDir
         );
         if (symlinkResult.linked.length === SKILLS.length) {
           spinner.succeed(`${platform.displayName} linked`);
@@ -136,7 +208,18 @@ export async function updateCommand() {
       console.log('');
       console.log(chalk.green('✓ Update complete!'));
       console.log('');
-      console.log(chalk.bold('▸'), 'Run in your Titanium project:', chalk.cyan('titools agents'));
+      const projectDir = resolve(process.cwd());
+      if (isTitaniumProject(projectDir)) {
+        const aiFiles = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md'];
+        const hasAnyAiFile = aiFiles.some((file) => existsSync(join(projectDir, file)));
+        if (hasAnyAiFile) {
+          await agentsCommand(projectDir, { onlyExisting: true, force: true });
+        } else {
+          console.log(chalk.bold('▸'), 'Run in the Titanium project:', chalk.cyan('titools sync'));
+        }
+      } else {
+        console.log(chalk.bold('▸'), 'Run in the Titanium project:', chalk.cyan('titools sync'));
+      }
       console.log('');
 
     } finally {