takomi 2.1.26 → 2.1.28

package/src/skills-catalog.js

@@ -0,0 +1,245 @@
+import fs from 'fs-extra';
+import path from 'path';
+import pc from 'picocolors';
+import { PATHS } from './utils.js';
+
+export const CORE_SKILLS = [
+  'takomi',
+  'sync-docs',
+  'code-review',
+  'security-audit',
+  'optimize-agent-context',
+  'agent-recovery',
+  'avoid-feature-creep',
+  'ai-sdk',
+  'git-commit-generation',
+];
+
+export const SKILL_CATEGORIES = [
+  {
+    id: 'core',
+    title: 'Core / Recommended',
+    color: 'cyan',
+    description: 'Essential skills for efficient Takomi usage.',
+    skills: CORE_SKILLS,
+  },
+  {
+    id: 'developer',
+    title: 'Developer / Frameworks',
+    color: 'blue',
+    description: 'Framework, repo, and developer workflow helpers.',
+    skills: [
+      'ai-sdk',
+      'nextjs-standards',
+      'context7',
+      'monorepo-management',
+      'upgrading-expo',
+      'github-ops',
+      'git-worktree',
+      'git-commit-generation',
+      'pr-comment-fix',
+      'jules',
+      'gemini',
+      'anti-gravity',
+    ],
+  },
+  {
+    id: 'security',
+    title: 'Security / Review',
+    color: 'red',
+    description: 'Security, audit, and review workflows.',
+    skills: [
+      'security-audit',
+      'audit-website',
+      'code-review',
+      'jstar-reviewer',
+      'convex-security-audit',
+      'convex-security-check',
+    ],
+  },
+  {
+    id: 'convex',
+    title: 'Convex',
+    color: 'green',
+    description: 'Convex framework skills and best practices.',
+    skills: [
+      'convex',
+      'convex-agents',
+      'convex-best-practices',
+      'convex-component-authoring',
+      'convex-cron-jobs',
+      'convex-file-storage',
+      'convex-functions',
+      'convex-http-actions',
+      'convex-migrations',
+      'convex-realtime',
+      'convex-schema-validator',
+      'convex-security-audit',
+      'convex-security-check',
+    ],
+  },
+  {
+    id: 'frontend',
+    title: 'Frontend / UI',
+    color: 'magenta',
+    description: 'Frontend implementation, UI/UX, components, and testing.',
+    skills: [
+      'frontend-design',
+      'web-design-guidelines',
+      'building-native-ui',
+      'ui-ux-pro-max',
+      'component-analysis',
+      '21st-dev-components',
+      'stitch',
+      'webapp-testing',
+    ],
+  },
+  {
+    id: 'docs-office',
+    title: 'Docs / Office / Extraction',
+    color: 'yellow',
+    description: 'Document formats, extraction, and README support.',
+    skills: [
+      'pdf',
+      'docx',
+      'pptx',
+      'xlsx',
+      'high-fidelity-extraction',
+      'crafting-effective-readmes',
+    ],
+  },
+  {
+    id: 'marketing',
+    title: 'Marketing / SEO / Copy',
+    color: 'green',
+    description: 'Marketing, SEO, naming, pricing, and social strategy.',
+    skills: [
+      'copywriting',
+      'marketing-ideas',
+      'pricing-strategy',
+      'programmatic-seo',
+      'seo-ready',
+      'social-content',
+      'twitter-automation',
+      'google-trends',
+      'domain-name-brainstormer',
+      'global-brand-namer',
+      'youtube-pipeline',
+    ],
+  },
+  {
+    id: 'ai-media',
+    title: 'AI Media / Content Creation',
+    color: 'magenta',
+    description: 'Optional AI media/content skills. Not installed by default.',
+    skills: [
+      'ai-avatar-video',
+      'ai-marketing-videos',
+      'ai-podcast-creation',
+      'ai-product-photography',
+      'ai-social-media-content',
+      'ai-voice-cloning',
+    ],
+  },
+  {
+    id: 'creative-video',
+    title: 'Creative / Video / Art',
+    color: 'blue',
+    description: 'Creative visuals, video, animation, and art workflows.',
+    skills: [
+      'algorithmic-art',
+      'blender-mcp-scene-director',
+      'remotion',
+      'youtube-pipeline',
+      'ai-avatar-video',
+      'ai-marketing-videos',
+    ],
+  },
+  {
+    id: 'skill-building',
+    title: 'Skill Building / Prompting / Orchestration',
+    color: 'cyan',
+    description: 'Skill authoring, prompt engineering, and optional orchestration helpers.',
+    skills: [
+      'skill-creator',
+      'prompt-engineering',
+      'subagent-driven-development',
+      'spawn-task',
+    ],
+  },
+];
+
+const colorFns = {
+  cyan: pc.cyan,
+  blue: pc.blue,
+  red: pc.red,
+  green: pc.green,
+  magenta: pc.magenta,
+  yellow: pc.yellow,
+};
+
+export function colorCategory(category) {
+  const color = colorFns[category.color] || ((value) => value);
+  return color(`[${category.title}]`);
+}
+
+export async function listBundledSkillNames() {
+  const entries = await fs.readdir(PATHS.skills);
+  const skills = [];
+  for (const entry of entries) {
+    const stat = await fs.stat(path.join(PATHS.skills, entry));
+    if (stat.isDirectory()) skills.push(entry);
+  }
+  return skills.sort();
+}
+
+export async function readSkillDescription(skillName) {
+  try {
+    const skillPath = path.join(PATHS.skills, skillName, 'SKILL.md');
+    const content = await fs.readFile(skillPath, 'utf8');
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    const frontmatter = match?.[1] || '';
+    const descriptionMatch = frontmatter.match(/^description:\s*(.+)$/m);
+    if (!descriptionMatch) return '';
+    return descriptionMatch[1].trim().replace(/^['"]|['"]$/g, '');
+  } catch {
+    return '';
+  }
+}
+
+export async function getSkillChoices(skillNames, selected = []) {
+  const selectedSet = new Set(selected);
+  const choices = [];
+  for (const skillName of skillNames) {
+    choices.push({
+      title: skillName,
+      value: skillName,
+      selected: selectedSet.has(skillName),
+      description: await readSkillDescription(skillName),
+    });
+  }
+  return choices;
+}
+
+export async function getValidCoreSkills() {
+  const bundled = new Set(await listBundledSkillNames());
+  return CORE_SKILLS.filter((skill) => bundled.has(skill));
+}
+
+export async function getSkillsForCategories(categoryIds) {
+  const bundled = new Set(await listBundledSkillNames());
+  const selected = new Set();
+  for (const category of SKILL_CATEGORIES) {
+    if (!categoryIds.includes(category.id)) continue;
+    for (const skill of category.skills) {
+      if (bundled.has(skill)) selected.add(skill);
+    }
+  }
+  return [...selected].sort();
+}
+
+export async function getUncategorizedSkills() {
+  const bundled = await listBundledSkillNames();
+  const categorized = new Set(SKILL_CATEGORIES.flatMap((category) => category.skills));
+  return bundled.filter((skill) => !categorized.has(skill));
+}

package/src/skills-installer.js

@@ -1,101 +1,244 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import crypto from 'crypto';
-import pc from 'picocolors';
-import { PATHS } from './utils.js';
-
-const HOME = os.homedir();
-const TAKOMI_HOME = path.join(HOME, '.takomi');
-export const SKILLS_MANIFEST_PATH = path.join(TAKOMI_HOME, 'skills-manifest.json');
-export const SKILLS_ROOT = path.join(HOME, '.agents', 'skills');
-
-function sha256(value) {
-  return crypto.createHash('sha256').update(value).digest('hex');
-}
-
-async function hashDirectory(dir) {
-  if (!await fs.pathExists(dir)) return null;
-  const entries = [];
-  async function walk(current, prefix = '') {
-    const names = (await fs.readdir(current)).sort();
-    for (const name of names) {
-      const full = path.join(current, name);
-      const rel = path.join(prefix, name).replace(/\\/g, '/');
-      const stat = await fs.stat(full);
-      if (stat.isDirectory()) {
-        entries.push(`dir:${rel}`);
-        await walk(full, rel);
-      } else {
-        entries.push(`file:${rel}:${sha256(await fs.readFile(full))}`);
-      }
-    }
-  }
-  await walk(dir);
-  return sha256(entries.join('\n'));
-}
-
-async function listBundledSkills() {
-  const entries = await fs.readdir(PATHS.skills);
-  const skills = [];
-  for (const entry of entries) {
-    const stat = await fs.stat(path.join(PATHS.skills, entry));
-    if (stat.isDirectory()) skills.push(entry);
-  }
-  return skills.sort();
-}
-
-export async function readSkillsInstallManifest() {
-  try {
-    if (await fs.pathExists(SKILLS_MANIFEST_PATH)) return await fs.readJson(SKILLS_MANIFEST_PATH);
-  } catch {}
-  return null;
-}
-
-export async function writeSkillsInstallManifest(manifest) {
-  await fs.ensureDir(TAKOMI_HOME);
-  await fs.writeJson(SKILLS_MANIFEST_PATH, manifest, { spaces: 2 });
-}
-
-export async function installBundledSkills(version = 'unknown') {
-  const skillNames = await listBundledSkills();
-  await fs.ensureDir(SKILLS_ROOT);
-
-  const installed = {};
-  for (const name of skillNames) {
-    const src = path.join(PATHS.skills, name);
-    const dest = path.join(SKILLS_ROOT, name);
-    if (await fs.pathExists(dest)) {
-      await fs.remove(dest);
-    }
-    await fs.copy(src, dest, { overwrite: true, errorOnExist: false });
-    installed[name] = await hashDirectory(dest);
-  }
-
-  const manifest = {
-    takomiVersion: version,
-    installedAt: new Date().toISOString(),
-    targetRoot: SKILLS_ROOT,
-    owned: installed,
-  };
-
-  await writeSkillsInstallManifest(manifest);
-  return { targetRoot: SKILLS_ROOT, manifest, count: skillNames.length };
-}
-
-export async function validateSkillsInstall() {
-  const names = await listBundledSkills();
-  const missing = [];
-  for (const name of names) {
-    if (!await fs.pathExists(path.join(SKILLS_ROOT, name))) missing.push(name);
-  }
-  return { root: SKILLS_ROOT, expected: names.length, missing, ok: missing.length === 0 };
-}
-
-export function printSkillsInstallSummary(result, validation) {
-  console.log(pc.green('\n✔ Installed bundled Takomi skills'));
-  console.log(pc.white(`  Root:     ${result.targetRoot}`));
-  console.log(pc.white(`  Manifest: ${SKILLS_MANIFEST_PATH}`));
-  console.log(pc.white(`  Count:    ${result.count}`));
-  console.log(pc.white(`  Status:   ${validation.ok ? 'ok' : `missing ${validation.missing.length}`}`));
-}
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
+import pc from 'picocolors';
+import { PATHS } from './utils.js';
+import { getValidCoreSkills, listBundledSkillNames } from './skills-catalog.js';
+
+const HOME = os.homedir();
+const TAKOMI_HOME = process.env.TAKOMI_HOME_DIR || path.join(HOME, '.takomi');
+export const SKILLS_MANIFEST_PATH = path.join(TAKOMI_HOME, 'skills-manifest.json');
+export const SKILLS_ROOT = process.env.TAKOMI_SKILLS_ROOT || path.join(HOME, '.agents', 'skills');
+
+function sha256(value) {
+  return crypto.createHash('sha256').update(value).digest('hex');
+}
+
+async function hashDirectory(dir) {
+  if (!await fs.pathExists(dir)) return null;
+  const entries = [];
+  async function walk(current, prefix = '') {
+    const names = (await fs.readdir(current)).sort();
+    for (const name of names) {
+      const full = path.join(current, name);
+      const rel = path.join(prefix, name).replace(/\\/g, '/');
+      const stat = await fs.stat(full);
+      if (stat.isDirectory()) {
+        entries.push(`dir:${rel}`);
+        await walk(full, rel);
+      } else {
+        entries.push(`file:${rel}:${sha256(await fs.readFile(full))}`);
+      }
+    }
+  }
+  await walk(dir);
+  return sha256(entries.join('\n'));
+}
+
+function normalizeOwnedEntry(name, entry) {
+  if (!entry) return null;
+  if (typeof entry === 'string') {
+    return {
+      name,
+      hash: entry,
+      targetPath: path.join(SKILLS_ROOT, name),
+      installedAt: undefined,
+      takomiVersion: undefined,
+    };
+  }
+  return {
+    name,
+    hash: entry.hash,
+    targetPath: entry.targetPath || path.join(SKILLS_ROOT, name),
+    installedAt: entry.installedAt,
+    takomiVersion: entry.takomiVersion,
+  };
+}
+
+function getOwnedMap(manifest) {
+  const owned = {};
+  for (const [name, entry] of Object.entries(manifest?.owned || {})) {
+    const normalized = normalizeOwnedEntry(name, entry);
+    if (normalized?.hash) owned[name] = normalized;
+  }
+  return owned;
+}
+
+export async function readSkillsInstallManifest() {
+  try {
+    if (await fs.pathExists(SKILLS_MANIFEST_PATH)) return await fs.readJson(SKILLS_MANIFEST_PATH);
+  } catch {}
+  return null;
+}
+
+export async function writeSkillsInstallManifest(manifest) {
+  await fs.ensureDir(TAKOMI_HOME);
+  await fs.writeJson(SKILLS_MANIFEST_PATH, manifest, { spaces: 2 });
+}
+
+export async function getInstalledTakomiSkillNames() {
+  return Object.keys(getOwnedMap(await readSkillsInstallManifest())).sort();
+}
+
+export async function buildSkillsReconcilePlan(selectedSkills = []) {
+  const manifest = await readSkillsInstallManifest();
+  const owned = getOwnedMap(manifest);
+  const selected = new Set(selectedSkills);
+  return {
+    owned: Object.keys(owned).sort(),
+    selected: [...selected].sort(),
+    toInstall: [...selected].sort(),
+    toRemove: Object.keys(owned).filter((name) => !selected.has(name)).sort(),
+  };
+}
+
+export async function installBundledSkills(version = 'unknown', options = {}) {
+  const bundled = new Set(await listBundledSkillNames());
+  const selectedSkills = Array.isArray(options.selectedSkills)
+    ? options.selectedSkills
+    : await getValidCoreSkills();
+  const selected = [...new Set(selectedSkills)].filter((name) => bundled.has(name)).sort();
+  const selectedSet = new Set(selected);
+  const prune = options.prune !== false;
+  const mode = options.mode || 'core';
+
+  await fs.ensureDir(SKILLS_ROOT);
+
+  const previousManifest = await readSkillsInstallManifest();
+  const previousOwned = getOwnedMap(previousManifest);
+  const nextOwned = {};
+  const installed = [];
+  const pruned = [];
+  const missing = [];
+  const preservedManual = [];
+  const preservedModified = [];
+  const skippedUnknown = selectedSkills.filter((name) => !bundled.has(name)).sort();
+
+  if (prune) {
+    for (const [name, ownedEntry] of Object.entries(previousOwned)) {
+      if (selectedSet.has(name)) continue;
+      const dest = ownedEntry.targetPath || path.join(SKILLS_ROOT, name);
+      if (!await fs.pathExists(dest)) continue;
+      const currentHash = await hashDirectory(dest);
+      if (currentHash && currentHash === ownedEntry.hash) {
+        await fs.remove(dest);
+        pruned.push(name);
+      } else {
+        preservedModified.push(name);
+        nextOwned[name] = ownedEntry;
+      }
+    }
+  }
+
+  for (const name of selected) {
+    const src = path.join(PATHS.skills, name);
+    const dest = path.join(SKILLS_ROOT, name);
+    const previous = previousOwned[name];
+
+    if (!await fs.pathExists(src)) {
+      missing.push(name);
+      continue;
+    }
+
+    if (await fs.pathExists(dest)) {
+      const currentHash = await hashDirectory(dest);
+      if (!previous) {
+        preservedManual.push(name);
+        continue;
+      }
+      if (currentHash && previous.hash && currentHash !== previous.hash) {
+        preservedModified.push(name);
+        nextOwned[name] = previous;
+        continue;
+      }
+      await fs.remove(dest);
+    }
+
+    await fs.copy(src, dest, { overwrite: true, errorOnExist: false });
+    const hash = await hashDirectory(dest);
+    nextOwned[name] = {
+      name,
+      hash,
+      targetPath: dest,
+      installedAt: new Date().toISOString(),
+      takomiVersion: version,
+    };
+    installed.push(name);
+  }
+
+  // Keep selected, previously-owned modified resources tracked so future
+  // deselection still preserves them instead of treating them as manual files.
+  for (const name of selected) {
+    if (!nextOwned[name] && previousOwned[name]) nextOwned[name] = previousOwned[name];
+  }
+
+  const manifest = {
+    schemaVersion: 2,
+    takomiVersion: version,
+    installedAt: previousManifest?.installedAt || new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    targetRoot: SKILLS_ROOT,
+    mode,
+    selectedSkills: selected,
+    owned: Object.fromEntries(Object.entries(nextOwned).sort(([a], [b]) => a.localeCompare(b))),
+    lastRun: {
+      installed,
+      pruned,
+      preservedManual,
+      preservedModified,
+      skippedUnknown,
+      missing,
+    },
+  };
+
+  await writeSkillsInstallManifest(manifest);
+  return {
+    targetRoot: SKILLS_ROOT,
+    manifest,
+    count: installed.length,
+    selectedCount: selected.length,
+    installed,
+    pruned,
+    preservedManual,
+    preservedModified: [...new Set(preservedModified)].sort(),
+    skippedUnknown,
+    missing,
+  };
+}
+
+export async function validateSkillsInstall(selectedSkills = null) {
+  const expected = Array.isArray(selectedSkills) ? selectedSkills : (await readSkillsInstallManifest())?.selectedSkills || await getValidCoreSkills();
+  const missing = [];
+  for (const name of expected) {
+    if (!await fs.pathExists(path.join(SKILLS_ROOT, name))) missing.push(name);
+  }
+  return { root: SKILLS_ROOT, expected: expected.length, missing, ok: missing.length === 0 };
+}
+
+export function printSkillsInstallSummary(result, validation) {
+  if (result?.leaveAsIs) {
+    console.log(pc.green('\n✔ Left Takomi skills unchanged'));
+    console.log(pc.white(`  Root:     ${result.targetRoot}`));
+    console.log(pc.white(`  Manifest: ${SKILLS_MANIFEST_PATH}`));
+    console.log(pc.white(`  Owned:    ${result.ownedCount}`));
+    return;
+  }
+
+  console.log(pc.green('\n✔ Reconciled Takomi skills'));
+  console.log(pc.white(`  Root:      ${result.targetRoot}`));
+  console.log(pc.white(`  Manifest:  ${SKILLS_MANIFEST_PATH}`));
+  console.log(pc.white(`  Selected:  ${result.selectedCount}`));
+  console.log(pc.white(`  Installed: ${result.installed.length}`));
+  console.log(pc.white(`  Removed:   ${result.pruned.length}`));
+  if (result.preservedManual.length) {
+    console.log(pc.yellow(`  Preserved manual name collisions: ${result.preservedManual.join(', ')}`));
+  }
+  if (result.preservedModified.length) {
+    console.log(pc.yellow(`  Preserved modified Takomi skills: ${result.preservedModified.join(', ')}`));
+  }
+  if (result.skippedUnknown.length) {
+    console.log(pc.yellow(`  Skipped unknown bundled skills: ${result.skippedUnknown.join(', ')}`));
+  }
+  console.log(pc.white(`  Status:    ${validation.ok ? 'ok' : `missing ${validation.missing.length}`}`));
+}