agent-skill-manager 1.0.0

package/src/index.ts

@@ -0,0 +1,324 @@
+import { createCliRenderer } from "@opentui/core";
+import type {
+  SkillInfo,
+  Scope,
+  SortBy,
+  ViewState,
+  AppConfig,
+} from "./utils/types";
+import { loadConfig, saveConfig, getConfigPath } from "./config";
+import { scanAllSkills, searchSkills, sortSkills } from "./scanner";
+import {
+  buildFullRemovalPlan,
+  executeRemoval,
+  getExistingTargets,
+} from "./uninstaller";
+import { createDashboard } from "./views/dashboard";
+import { createSkillList } from "./views/skill-list";
+import { createDetailView } from "./views/skill-detail";
+import { createConfirmView } from "./views/confirm";
+import { createHelpView } from "./views/help";
+import { createConfigView } from "./views/config";
+
+// ─── State ──────────────────────────────────────────────────────────────────
+let currentConfig: AppConfig;
+let allSkills: SkillInfo[] = [];
+let filteredSkills: SkillInfo[] = [];
+let currentScope: Scope = "both";
+let currentSort: SortBy = "name";
+let searchQuery = "";
+let viewState: ViewState = "dashboard";
+let selectedSkill: SkillInfo | null = null;
+let searchMode = false;
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+async function main() {
+  // Load config before anything else
+  currentConfig = await loadConfig();
+  currentScope = currentConfig.preferences.defaultScope;
+  currentSort = currentConfig.preferences.defaultSort;
+
+  const renderer = await createCliRenderer({
+    exitOnCtrlC: true,
+    useAlternateScreen: true,
+  });
+
+  // ── Build Dashboard ─────────────────────────────────────────────────────
+  const dashboard = createDashboard(
+    renderer,
+    currentConfig,
+    async (scope: Scope) => {
+      currentScope = scope;
+      await refreshSkills();
+    },
+  );
+
+  // ── Skill List ──────────────────────────────────────────────────────────
+  const skillList = createSkillList(
+    renderer,
+    [],
+    (skill: SkillInfo) => {
+      showDetail(skill);
+    },
+    renderer.width,
+  );
+  dashboard.contentArea.add(skillList.container);
+
+  // ── Overlay containers ────────────────────────────────────────────────
+  let overlayContainer: any = null;
+
+  // ── Helpers ───────────────────────────────────────────────────────────
+  async function refreshSkills() {
+    allSkills = await scanAllSkills(currentConfig, currentScope);
+    applyFilters();
+  }
+
+  function applyFilters() {
+    let skills = searchSkills(allSkills, searchQuery);
+    skills = sortSkills(skills, currentSort);
+    filteredSkills = skills;
+    skillList.update(filteredSkills);
+    dashboard.updateStats(allSkills);
+    dashboard.updateSortLabel(currentSort);
+  }
+
+  function removeOverlay() {
+    if (overlayContainer) {
+      renderer.root.remove(overlayContainer.id);
+      overlayContainer = null;
+    }
+    viewState = "dashboard";
+    skillList.select.focus();
+  }
+
+  function showDetail(skill: SkillInfo) {
+    removeOverlay();
+    selectedSkill = skill;
+    viewState = "detail";
+    overlayContainer = createDetailView(renderer, skill);
+    renderer.root.add(overlayContainer);
+  }
+
+  async function showConfirm(skill: SkillInfo) {
+    removeOverlay();
+    selectedSkill = skill;
+    viewState = "confirm";
+
+    const plan = buildFullRemovalPlan(skill.dirName, allSkills, currentConfig);
+    const targets = await getExistingTargets(plan);
+
+    overlayContainer = createConfirmView(
+      renderer,
+      skill,
+      targets,
+      async (result) => {
+        if (result.confirmed) {
+          await executeRemoval(plan);
+          removeOverlay();
+          await refreshSkills();
+        } else {
+          removeOverlay();
+        }
+      },
+    );
+    renderer.root.add(overlayContainer);
+  }
+
+  function showHelp() {
+    removeOverlay();
+    viewState = "help";
+    overlayContainer = createHelpView(renderer);
+    renderer.root.add(overlayContainer);
+  }
+
+  async function showConfig() {
+    removeOverlay();
+    viewState = "config";
+    overlayContainer = createConfigView(
+      renderer,
+      currentConfig,
+      async (updatedConfig) => {
+        currentConfig = updatedConfig;
+        await saveConfig(updatedConfig);
+        dashboard.updateProviderInfo(updatedConfig);
+        removeOverlay();
+        await refreshSkills();
+      },
+    );
+    renderer.root.add(overlayContainer);
+  }
+
+  function cycleSortOrder() {
+    const orders: SortBy[] = ["name", "version", "location"];
+    const idx = orders.indexOf(currentSort);
+    currentSort = orders[(idx + 1) % orders.length];
+    applyFilters();
+  }
+
+  function enterSearchMode() {
+    searchMode = true;
+    dashboard.searchInput.focus();
+  }
+
+  function exitSearchMode() {
+    searchMode = false;
+    searchQuery = "";
+    dashboard.searchInput.initialValue = "";
+    applyFilters();
+    skillList.select.focus();
+  }
+
+  // ── Keyboard Handling ───────────────────────────────────────────────────
+  (renderer.keyInput as any).on("keypress", async (key: any) => {
+    // In search mode, handle Esc to exit and Enter to confirm
+    if (searchMode) {
+      if (key.name === "escape") {
+        exitSearchMode();
+        return;
+      }
+      if (key.name === "return") {
+        searchQuery = dashboard.searchInput.plainText || "";
+        searchMode = false;
+        applyFilters();
+        skillList.select.focus();
+        return;
+      }
+      // Live filtering as user types
+      setTimeout(() => {
+        searchQuery = dashboard.searchInput.plainText || "";
+        applyFilters();
+      }, 10);
+      return;
+    }
+
+    // Global keys
+    if (key.name === "q" && viewState === "dashboard") {
+      renderer.destroy();
+      process.exit(0);
+    }
+
+    if (key.name === "escape") {
+      if (viewState === "config" && overlayContainer) {
+        // Save config and close
+        const editConfig = (overlayContainer as any).__editConfig;
+        const onClose = (overlayContainer as any).__onClose;
+        if (onClose && editConfig) {
+          onClose(editConfig);
+        } else {
+          removeOverlay();
+        }
+        return;
+      }
+      if (viewState !== "dashboard") {
+        removeOverlay();
+      }
+      return;
+    }
+
+    // Help overlay
+    if (key.sequence === "?") {
+      if (viewState === "help") {
+        removeOverlay();
+      } else if (viewState === "dashboard") {
+        showHelp();
+      }
+      return;
+    }
+
+    // Config view keys
+    if (viewState === "config") {
+      if (key.name === "e") {
+        // Open config in $EDITOR
+        const editorCmd = process.env.EDITOR || process.env.VISUAL || "vi";
+        const parts = editorCmd.split(/\s+/);
+        const configPath = getConfigPath();
+        renderer.destroy();
+        const proc = Bun.spawn([...parts, configPath], {
+          stdin: "inherit",
+          stdout: "inherit",
+          stderr: "inherit",
+        });
+        await proc.exited;
+        // Reload config and restart
+        currentConfig = await loadConfig();
+        process.exit(0); // User needs to restart after external edit
+      }
+      return;
+    }
+
+    // Dashboard-specific keys
+    if (viewState === "dashboard") {
+      if (key.name === "/" || key.sequence === "/") {
+        enterSearchMode();
+        return;
+      }
+
+      if (key.name === "s" && !key.ctrl) {
+        cycleSortOrder();
+        return;
+      }
+
+      if (key.name === "r" && !key.ctrl) {
+        await refreshSkills();
+        return;
+      }
+
+      if (key.name === "c" && !key.ctrl) {
+        await showConfig();
+        return;
+      }
+
+      if (key.name === "tab") {
+        const scopes: Scope[] = ["global", "project", "both"];
+        const idx = scopes.indexOf(currentScope);
+        currentScope = scopes[(idx + 1) % scopes.length];
+        const tabMap: Record<Scope, number> = {
+          global: 0,
+          project: 1,
+          both: 2,
+        };
+        dashboard.scopeTabs.setSelectedIndex(tabMap[currentScope]);
+        refreshSkills();
+        return;
+      }
+
+      if (key.name === "d") {
+        const skill = getSelectedSkill();
+        if (skill) {
+          showConfirm(skill);
+        }
+        return;
+      }
+    }
+
+    // Detail view keys
+    if (viewState === "detail") {
+      if (key.name === "d") {
+        if (selectedSkill) {
+          showConfirm(selectedSkill);
+        }
+        return;
+      }
+    }
+  });
+
+  function getSelectedSkill(): SkillInfo | null {
+    const idx = skillList.select.getSelectedIndex();
+    if (idx >= 0 && idx < filteredSkills.length) {
+      return filteredSkills[idx];
+    }
+    return null;
+  }
+
+  // ── Mount & Start ─────────────────────────────────────────────────────
+  renderer.root.add(dashboard.root);
+
+  // Initial load
+  await refreshSkills();
+  skillList.select.focus();
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/src/scanner.ts

@@ -0,0 +1,165 @@
+import { readdir, stat, lstat, readlink, readFile } from "fs/promises";
+import { join, resolve } from "path";
+import { parseFrontmatter } from "./utils/frontmatter";
+import { resolveProviderPath } from "./config";
+import type { SkillInfo, Scope, SortBy, AppConfig } from "./utils/types";
+
+interface ScanLocation {
+  dir: string;
+  location: string;
+  scope: "global" | "project";
+  providerName: string;
+  providerLabel: string;
+}
+
+function buildScanLocations(config: AppConfig, scope: Scope): ScanLocation[] {
+  const locations: ScanLocation[] = [];
+
+  for (const provider of config.providers) {
+    if (!provider.enabled) continue;
+
+    if (scope === "global" || scope === "both") {
+      locations.push({
+        dir: resolveProviderPath(provider.global),
+        location: `global-${provider.name}`,
+        scope: "global",
+        providerName: provider.name,
+        providerLabel: provider.label,
+      });
+    }
+
+    if (scope === "project" || scope === "both") {
+      locations.push({
+        dir: resolveProviderPath(provider.project),
+        location: `project-${provider.name}`,
+        scope: "project",
+        providerName: provider.name,
+        providerLabel: provider.label,
+      });
+    }
+  }
+
+  for (const custom of config.customPaths) {
+    if (scope === custom.scope || scope === "both") {
+      locations.push({
+        dir: resolveProviderPath(custom.path),
+        location: `${custom.scope}-custom`,
+        scope: custom.scope,
+        providerName: "custom",
+        providerLabel: custom.label,
+      });
+    }
+  }
+
+  return locations;
+}
+
+async function countFiles(dir: string): Promise<number> {
+  try {
+    const entries = await readdir(dir, { recursive: true } as any);
+    return entries.length;
+  } catch {
+    return 0;
+  }
+}
+
+async function scanDirectory(loc: ScanLocation): Promise<SkillInfo[]> {
+  const skills: SkillInfo[] = [];
+
+  let entries: string[];
+  try {
+    entries = await readdir(loc.dir);
+  } catch {
+    return skills;
+  }
+
+  for (const entry of entries) {
+    const entryPath = join(loc.dir, entry);
+
+    try {
+      const entryStat = await stat(entryPath);
+      if (!entryStat.isDirectory()) continue;
+    } catch {
+      continue;
+    }
+
+    const skillMdPath = join(entryPath, "SKILL.md");
+    let content: string;
+    try {
+      content = await readFile(skillMdPath, "utf-8");
+    } catch {
+      continue;
+    }
+
+    const fm = parseFrontmatter(content);
+
+    let isSymlink = false;
+    let symlinkTarget: string | null = null;
+    try {
+      const lstats = await lstat(entryPath);
+      if (lstats.isSymbolicLink()) {
+        isSymlink = true;
+        symlinkTarget = await readlink(entryPath);
+      }
+    } catch {
+      // not a symlink
+    }
+
+    const fileCount = await countFiles(entryPath);
+
+    skills.push({
+      name: fm.name || entry,
+      version: fm.version || "0.0.0",
+      description: (fm.description || "").replace(/\s*\n\s*/g, " ").trim(),
+      dirName: entry,
+      path: resolve(entryPath),
+      originalPath: entryPath,
+      location: loc.location,
+      scope: loc.scope,
+      provider: loc.providerName,
+      providerLabel: loc.providerLabel,
+      isSymlink,
+      symlinkTarget,
+      fileCount,
+    });
+  }
+
+  return skills;
+}
+
+export async function scanAllSkills(
+  config: AppConfig,
+  scope: Scope,
+): Promise<SkillInfo[]> {
+  const locations = buildScanLocations(config, scope);
+  const results = await Promise.all(locations.map(scanDirectory));
+  return results.flat();
+}
+
+export function searchSkills(skills: SkillInfo[], query: string): SkillInfo[] {
+  if (!query.trim()) return skills;
+  const q = query.toLowerCase();
+  return skills.filter(
+    (s) =>
+      s.name.toLowerCase().includes(q) ||
+      s.description.toLowerCase().includes(q) ||
+      s.location.toLowerCase().includes(q) ||
+      s.providerLabel.toLowerCase().includes(q),
+  );
+}
+
+export function sortSkills(skills: SkillInfo[], by: SortBy): SkillInfo[] {
+  const sorted = [...skills];
+  switch (by) {
+    case "name":
+      sorted.sort((a, b) => a.name.localeCompare(b.name));
+      break;
+    case "version":
+      sorted.sort((a, b) => a.version.localeCompare(b.version));
+      break;
+    case "location":
+      sorted.sort((a, b) => a.location.localeCompare(b.location));
+      break;
+  }
+  return sorted;
+}

package/src/uninstaller.ts

@@ -0,0 +1,225 @@
+import { rm, readFile, writeFile, access, lstat } from "fs/promises";
+import { join, resolve, dirname } from "path";
+import { homedir } from "os";
+import { resolveProviderPath } from "./config";
+import type { SkillInfo, RemovalPlan, AppConfig } from "./utils/types";
+
+const HOME = homedir();
+
+export function buildRemovalPlan(
+  skill: SkillInfo,
+  config: AppConfig,
+): RemovalPlan {
+  const plan: RemovalPlan = {
+    directories: [],
+    ruleFiles: [],
+    agentsBlocks: [],
+  };
+
+  // The skill directory itself
+  plan.directories.push({
+    path: skill.originalPath,
+    isSymlink: skill.isSymlink,
+  });
+
+  const name = skill.dirName;
+
+  // Check for tool-specific rule files (project scope only)
+  if (skill.scope === "project") {
+    plan.ruleFiles.push(
+      resolve(".cursor", "rules", `${name}.mdc`),
+      resolve(".windsurf", "rules", `${name}.md`),
+      resolve(".github", "instructions", `${name}.instructions.md`),
+    );
+    plan.agentsBlocks.push({ file: resolve("AGENTS.md"), skillName: name });
+  }
+
+  if (skill.scope === "global") {
+    // Check AGENTS.md for all enabled providers with global paths
+    for (const provider of config.providers) {
+      if (!provider.enabled) continue;
+      const globalDir = resolveProviderPath(provider.global);
+      const agentsMdPath = join(dirname(globalDir), "AGENTS.md");
+      plan.agentsBlocks.push({ file: agentsMdPath, skillName: name });
+    }
+    // Also check ~/.codex/AGENTS.md explicitly (common location)
+    const codexAgentsMd = join(HOME, ".codex", "AGENTS.md");
+    const alreadyIncluded = plan.agentsBlocks.some(
+      (b) => b.file === codexAgentsMd,
+    );
+    if (!alreadyIncluded) {
+      plan.agentsBlocks.push({ file: codexAgentsMd, skillName: name });
+    }
+  }
+
+  return plan;
+}
+
+export function buildFullRemovalPlan(
+  dirName: string,
+  allSkills: SkillInfo[],
+  config: AppConfig,
+): RemovalPlan {
+  const matching = allSkills.filter((s) => s.dirName === dirName);
+  if (matching.length === 0) {
+    return { directories: [], ruleFiles: [], agentsBlocks: [] };
+  }
+
+  const combined: RemovalPlan = {
+    directories: [],
+    ruleFiles: [],
+    agentsBlocks: [],
+  };
+
+  const seenDirs = new Set<string>();
+  const seenRules = new Set<string>();
+  const seenBlocks = new Set<string>();
+
+  for (const skill of matching) {
+    const plan = buildRemovalPlan(skill, config);
+
+    for (const dir of plan.directories) {
+      if (!seenDirs.has(dir.path)) {
+        seenDirs.add(dir.path);
+        combined.directories.push(dir);
+      }
+    }
+
+    for (const rule of plan.ruleFiles) {
+      if (!seenRules.has(rule)) {
+        seenRules.add(rule);
+        combined.ruleFiles.push(rule);
+      }
+    }
+
+    for (const block of plan.agentsBlocks) {
+      const key = `${block.file}::${block.skillName}`;
+      if (!seenBlocks.has(key)) {
+        seenBlocks.add(key);
+        combined.agentsBlocks.push(block);
+      }
+    }
+  }
+
+  return combined;
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function removeAgentsMdBlock(
+  filePath: string,
+  skillName: string,
+): Promise<void> {
+  if (!(await fileExists(filePath))) return;
+
+  let content = await readFile(filePath, "utf-8");
+
+  // Try both new and old marker formats for backward compatibility
+  for (const prefix of ["skill-manager", "pskills"]) {
+    const startMarker = `<!-- ${prefix}: ${skillName} -->`;
+    const endMarker = `<!-- /${prefix}: ${skillName} -->`;
+
+    const startIdx = content.indexOf(startMarker);
+    const endIdx = content.indexOf(endMarker);
+
+    if (startIdx === -1 || endIdx === -1) continue;
+
+    let removeStart = startIdx;
+    if (removeStart > 0 && content[removeStart - 1] === "\n") {
+      removeStart--;
+    }
+
+    const removeEnd = endIdx + endMarker.length;
+    let actualEnd = removeEnd;
+    if (actualEnd < content.length && content[actualEnd] === "\n") {
+      actualEnd++;
+    }
+
+    content = content.slice(0, removeStart) + content.slice(actualEnd);
+  }
+
+  await writeFile(filePath, content, "utf-8");
+}
+
+export async function executeRemoval(plan: RemovalPlan): Promise<string[]> {
+  const log: string[] = [];
+
+  // Remove directories/symlinks
+  for (const dir of plan.directories) {
+    try {
+      if (dir.isSymlink) {
+        await rm(dir.path);
+        log.push(`Removed symlink: ${dir.path}`);
+      } else {
+        await rm(dir.path, { recursive: true, force: true });
+        log.push(`Removed directory: ${dir.path}`);
+      }
+    } catch (err: any) {
+      log.push(`Failed to remove ${dir.path}: ${err.message}`);
+    }
+  }
+
+  // Remove rule files
+  for (const ruleFile of plan.ruleFiles) {
+    if (await fileExists(ruleFile)) {
+      try {
+        await rm(ruleFile);
+        log.push(`Removed rule file: ${ruleFile}`);
+      } catch (err: any) {
+        log.push(`Failed to remove ${ruleFile}: ${err.message}`);
+      }
+    }
+  }
+
+  // Remove AGENTS.md blocks
+  for (const block of plan.agentsBlocks) {
+    try {
+      await removeAgentsMdBlock(block.file, block.skillName);
+      log.push(`Cleaned AGENTS.md block in: ${block.file}`);
+    } catch (err: any) {
+      log.push(`Failed to clean AGENTS.md block: ${err.message}`);
+    }
+  }
+
+  return log;
+}
+
+export async function getExistingTargets(plan: RemovalPlan): Promise<string[]> {
+  const existing: string[] = [];
+
+  for (const dir of plan.directories) {
+    if (await fileExists(dir.path)) {
+      const lstats = await lstat(dir.path);
+      const type = lstats.isSymbolicLink() ? "symlink" : "directory";
+      existing.push(`${dir.path} (${type})`);
+    }
+  }
+
+  for (const ruleFile of plan.ruleFiles) {
+    if (await fileExists(ruleFile)) {
+      existing.push(ruleFile);
+    }
+  }
+
+  for (const block of plan.agentsBlocks) {
+    if (await fileExists(block.file)) {
+      const content = await readFile(block.file, "utf-8");
+      // Check both new and old marker formats
+      if (
+        content.includes(`<!-- skill-manager: ${block.skillName} -->`) ||
+        content.includes(`<!-- pskills: ${block.skillName} -->`)
+      ) {
+        existing.push(`${block.file} (AGENTS.md block)`);
+      }
+    }
+  }
+
+  return existing;
+}