@moskala/oneagent-core 0.4.0 → 0.4.2

package/src/detect.ts

@@ -1,64 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import type { DetectedFile } from "./types.ts";
-import { AGENT_DEFINITIONS } from "./agents.ts";
-import { ONEAGENT_DIR } from "./constants.ts";
-
-export const AGENT_FILES = [
-  "CLAUDE.md",
-  "AGENTS.md",
-  ".cursorrules",
-  ".windsurfrules",
-  ".github/copilot-instructions.md",
-];
-
-export async function readDetectedFile(root: string, rel: string): Promise<DetectedFile | null> {
-  const absolutePath = path.join(root, rel);
-
-  try {
-    const stat = await fs.lstat(absolutePath);
-
-    if (stat.isSymbolicLink()) {
-      const linkTarget = await fs.readlink(absolutePath);
-      const resolved = path.resolve(path.dirname(absolutePath), linkTarget);
-      if (resolved.startsWith(path.join(root, ONEAGENT_DIR))) return null;
-    }
-
-    const content = await fs.readFile(absolutePath, "utf-8");
-    return {
-      relativePath: rel,
-      absolutePath,
-      sizeBytes: stat.size,
-      modifiedAt: stat.mtime,
-      content,
-    };
-  } catch {
-    return null;
-  }
-}
-
-export async function detectExistingFiles(root: string): Promise<DetectedFile[]> {
-  const results = await Promise.all(AGENT_FILES.map((rel) => readDetectedFile(root, rel)));
-  return results.filter((f): f is DetectedFile => f !== null);
-}
-
-export function filesHaveSameContent(files: DetectedFile[]): boolean {
-  if (files.length <= 1) return true;
-  const first = files[0]!.content;
-  return files.every((f) => f.content === first);
-}
-
-const DEPRECATED_FILES = AGENT_DEFINITIONS.flatMap((d) => d.deprecatedFiles ?? []);
-
-export async function removeDeprecatedFiles(root: string): Promise<void> {
-  for (const rel of DEPRECATED_FILES) {
-    const absPath = path.join(root, rel);
-    try {
-      const stat = await fs.lstat(absPath);
-      if (!stat.isSymbolicLink()) await fs.unlink(absPath);
-    } catch {
-      // doesn't exist — no-op
-    }
-  }
-}
-

package/src/generate.ts

@@ -1,92 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import type { Config, DetectedFile } from "./types.ts";
-import { activeTargets } from "./config.ts";
-import { readRules } from "./rules.ts";
-import { readSkills } from "./skills.ts";
-import { buildMainSymlinks, buildRulesSymlinks, buildSkillSymlinks, buildCommandSymlinks, buildAgentsDirSymlinks, createAllSymlinks, migrateRuleAndSkillFiles } from "./symlinks.ts";
-import { copilotFilePath, buildCopilotPromptContent, copilotPromptFilePath, generateCopilotRules, generateCopilotSkills } from "./copilot.ts";
-import { writeOpencode } from "./opencode.ts";
-import { readDetectedFile } from "./detect.ts";
-
-export interface GenerateCollisions {
-  mainFiles: DetectedFile[];
-  ruleSkillFiles: DetectedFile[];
-}
-
-export async function detectGenerateCollisions(root: string, config: Config): Promise<GenerateCollisions> {
-  const [rules, skills] = await Promise.all([readRules(root), readSkills(root)]);
-  const targets = activeTargets(config);
-
-  // 1. Main instruction file symlinks (CLAUDE.md, AGENTS.md, .windsurfrules, etc.)
-  const mainEntries = buildMainSymlinks(root, targets);
-  // 2. Rule/skill symlink paths
-  const ruleSkillEntries = [
-    ...buildRulesSymlinks(root, targets),
-    ...buildSkillSymlinks(root, targets),
-    ...buildCommandSymlinks(root, targets),
-    // .agents/skills skipped — handled by migrateAgentsSkillsDir
-  ];
-
-  const [mainCollisions, ruleSkillSymlinkCollisions] = await Promise.all([
-    Promise.all(mainEntries.map((entry) => readDetectedFile(root, path.relative(root, entry.symlinkPath))))
-      .then((files) => files.filter((f): f is DetectedFile => f !== null)),
-    Promise.all(ruleSkillEntries.map((entry) => readDetectedFile(root, path.relative(root, entry.symlinkPath))))
-      .then((files) => files.filter((f): f is DetectedFile => f !== null)),
-  ]);
-
-  // 3. Copilot generated files — collision only if content differs (idempotent-safe)
-  const copilotCollisions: DetectedFile[] = [];
-  if (targets.includes("copilot")) {
-    const checks = await Promise.all([
-      ...rules.map(async (rule): Promise<DetectedFile | null> => {
-        const filePath = copilotFilePath(root, rule.name);
-        try {
-          const [source, dest] = await Promise.all([
-            fs.readFile(rule.path, "utf-8"),
-            fs.readFile(filePath, "utf-8"),
-          ]);
-          if (source === dest) return null;
-          const stat = await fs.lstat(filePath);
-          return { relativePath: path.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content: dest };
-        } catch { return null; }
-      }),
-      ...skills.map(async (skill): Promise<DetectedFile | null> => {
-        const filePath = copilotPromptFilePath(root, skill.name);
-        try {
-          const content = await fs.readFile(filePath, "utf-8");
-          if (content === buildCopilotPromptContent(skill)) return null;
-          const stat = await fs.lstat(filePath);
-          return { relativePath: path.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content };
-        } catch { return null; }
-      }),
-    ]);
-    copilotCollisions.push(...checks.filter((c): c is DetectedFile => c !== null));
-  }
-
-  return {
-    mainFiles: mainCollisions,
-    ruleSkillFiles: [...ruleSkillSymlinkCollisions, ...copilotCollisions],
-  };
-}
-
-export async function generate(root: string, config: Config): Promise<void> {
-  const [rules, skills] = await Promise.all([readRules(root), readSkills(root)]);
-  const targets = activeTargets(config);
-
-  await migrateRuleAndSkillFiles(root);
-
-  const mainSymlinks = buildMainSymlinks(root, targets);
-  const rulesSymlinks = buildRulesSymlinks(root, targets);
-  const skillSymlinks = await buildSkillSymlinks(root, targets);
-  const commandSymlinks = buildCommandSymlinks(root, targets);
-  await createAllSymlinks([...mainSymlinks, ...rulesSymlinks, ...skillSymlinks, ...commandSymlinks, ...buildAgentsDirSymlinks(root)]);
-
-  if (targets.includes("copilot")) {
-    await Promise.all([generateCopilotRules(root, rules), generateCopilotSkills(root, skills)]);
-  }
-
-  if (targets.includes("opencode")) {
-    await writeOpencode(root, rules);
-  }
-}

package/src/opencode.ts

@@ -1,40 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import type { RuleFile } from "./types.ts";
-import { ONEAGENT_DIR } from "./constants.ts";
-
-export async function readOpencode(root: string): Promise<Record<string, unknown> | null> {
-  try {
-    const content = await fs.readFile(path.join(root, "opencode.json"), "utf-8");
-    return JSON.parse(content) as Record<string, unknown>;
-  } catch {
-    return null;
-  }
-}
-
-export function buildOpencodeConfig(existing: Record<string, unknown> | null): object {
-  return {
-    ...existing,
-    instructions: `${ONEAGENT_DIR}/instructions.md`,
-  };
-}
-
-export async function addOpenCodePlugin(root: string, id: string): Promise<void> {
-  const filePath = path.join(root, "opencode.json");
-  let existing: Record<string, unknown>;
-  try {
-    existing = JSON.parse(await fs.readFile(filePath, "utf-8")) as Record<string, unknown>;
-  } catch {
-    return; // no opencode.json — no-op
-  }
-  const current = Array.isArray(existing.plugin) ? (existing.plugin as string[]) : [];
-  if (current.includes(id)) return;
-  existing.plugin = [...current, id];
-  await fs.writeFile(filePath, JSON.stringify(existing, null, 2) + "\n");
-}
-
-export async function writeOpencode(root: string, _rules: RuleFile[]): Promise<void> {
-  const existing = await readOpencode(root);
-  const config = buildOpencodeConfig(existing);
-  await fs.writeFile(path.join(root, "opencode.json"), JSON.stringify(config, null, 2) + "\n");
-}

package/src/rules.ts

@@ -1,17 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import type { RuleFile } from "./types.ts";
-import { ONEAGENT_DIR } from "./constants.ts";
-
-export async function readRules(root: string): Promise<RuleFile[]> {
-  const rulesDir = path.join(root, ONEAGENT_DIR, "rules");
-  try {
-    const files = await fs.readdir(rulesDir);
-    return files
-      .filter((f) => f.endsWith(".md"))
-      .map((f) => ({ name: path.basename(f, ".md"), path: path.join(rulesDir, f) }))
-      .sort((a, b) => a.name.localeCompare(b.name));
-  } catch {
-    return [];
-  }
-}

package/src/skills.ts

@@ -1,43 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import type { SkillFile } from "./types.ts";
-import { ONEAGENT_DIR } from "./constants.ts";
-
-const VALID_MODES = ["ask", "edit", "agent"] as const;
-type SkillMode = (typeof VALID_MODES)[number];
-
-export function parseSkillFrontmatter(raw: string): { description: string; mode: SkillMode; content: string } {
-  const match = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
-  if (!match) return { description: "", mode: "agent", content: raw };
-
-  const frontmatter = match[1] ?? "";
-  const content = match[2] ?? "";
-
-  const descMatch = frontmatter.match(/description:\s*["']?([^"'\n]+)["']?/);
-  const description = descMatch?.[1]?.trim() ?? "";
-
-  const modeMatch = frontmatter.match(/mode:\s*["']?([^"'\n]+)["']?/);
-  const modeRaw = modeMatch?.[1]?.trim() ?? "agent";
-  const mode: SkillMode = (VALID_MODES as readonly string[]).includes(modeRaw) ? (modeRaw as SkillMode) : "agent";
-
-  return { description, mode, content };
-}
-
-export async function readSkillFile(filePath: string): Promise<SkillFile> {
-  const raw = await fs.readFile(filePath, "utf-8");
-  const { description, mode, content } = parseSkillFrontmatter(raw);
-  return { name: path.basename(filePath, ".md"), path: filePath, description, mode, content };
-}
-
-export async function readSkills(root: string): Promise<SkillFile[]> {
-  const skillsDir = path.join(root, ONEAGENT_DIR, "skills");
-  try {
-    const files = await fs.readdir(skillsDir);
-    const mdFiles = files.filter((f) => f.endsWith(".md"));
-    const skills = await Promise.all(mdFiles.map((f) => readSkillFile(path.join(skillsDir, f))));
-    return skills.sort((a, b) => a.name.localeCompare(b.name));
-  } catch {
-    return [];
-  }
-}
-

package/src/status.ts

@@ -1,68 +0,0 @@
-import fs from "fs/promises";
-import type { Config, GeneratedFileCheck, OpenCodeCheck, RuleFile, StatusResult } from "./types.ts";
-import { activeTargets } from "./config.ts";
-import { ONEAGENT_DIR } from "./constants.ts";
-import { readRules } from "./rules.ts";
-import { readSkills } from "./skills.ts";
-import { buildMainSymlinks, buildRulesSymlinks, buildSkillSymlinks, buildCommandSymlinks, buildAgentsDirSymlinks, checkSymlink } from "./symlinks.ts";
-import { buildCopilotPromptContent, copilotFilePath, copilotPromptFilePath } from "./copilot.ts";
-import { readOpencode } from "./opencode.ts";
-
-export async function checkGeneratedFile(root: string, rule: RuleFile): Promise<GeneratedFileCheck> {
-  const filePath = copilotFilePath(root, rule.name);
-  try {
-    const [source, dest] = await Promise.all([
-      fs.readFile(rule.path, "utf-8"),
-      fs.readFile(filePath, "utf-8"),
-    ]);
-    return { path: filePath, exists: true, upToDate: source === dest };
-  } catch {
-    return { path: filePath, exists: false, upToDate: false };
-  }
-}
-
-export async function checkOpencodeStatus(
-  root: string,
-  _rules: RuleFile[],
-): Promise<OpenCodeCheck> {
-  const existing = await readOpencode(root);
-  if (!existing) return { exists: false, valid: false };
-  return { exists: true, valid: existing["instructions"] === `${ONEAGENT_DIR}/instructions.md` };
-}
-
-export async function checkCopilotPrompt(root: string, skill: import("./types.ts").SkillFile): Promise<GeneratedFileCheck> {
-  const filePath = copilotPromptFilePath(root, skill.name);
-  const expected = buildCopilotPromptContent(skill);
-  try {
-    const content = await fs.readFile(filePath, "utf-8");
-    return { path: filePath, exists: true, upToDate: content === expected };
-  } catch {
-    return { path: filePath, exists: false, upToDate: false };
-  }
-}
-
-export async function checkStatus(root: string, config: Config): Promise<StatusResult> {
-  const [rules, skills] = await Promise.all([readRules(root), readSkills(root)]);
-  const targets = activeTargets(config);
-
-  const allEntries = [
-    ...buildMainSymlinks(root, targets),
-    ...buildRulesSymlinks(root, targets),
-    ...buildSkillSymlinks(root, targets),
-    ...buildCommandSymlinks(root, targets),
-    ...buildAgentsDirSymlinks(root),
-  ];
-
-  const symlinks = await Promise.all(allEntries.map(checkSymlink));
-
-  const generatedFiles = targets.includes("copilot")
-    ? await Promise.all([
-        ...rules.map((rule) => checkGeneratedFile(root, rule)),
-        ...skills.map((skill) => checkCopilotPrompt(root, skill)),
-      ])
-    : [];
-
-  const opencode = await checkOpencodeStatus(root, rules);
-
-  return { symlinks, generatedFiles, opencode };
-}

package/src/symlinks.ts

@@ -1,245 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import type { AgentTarget, SymlinkCheck, SymlinkEntry } from "./types.ts";
-import { AGENT_DEFINITIONS } from "./agents.ts";
-import { ONEAGENT_DIR } from "./constants.ts";
-
-export async function ensureDir(dirPath: string): Promise<void> {
-  await fs.mkdir(dirPath, { recursive: true });
-}
-
-export async function createSymlink(symlinkPath: string, target: string): Promise<void> {
-  await ensureDir(path.dirname(symlinkPath));
-
-  // Skip if already a correct symlink — avoids unnecessary rm/create that can
-  // race with external filesystem watchers (e.g. Cursor IDE recreating .cursor/rules)
-  try {
-    const stat = await fs.lstat(symlinkPath);
-    if (stat.isSymbolicLink() && (await fs.readlink(symlinkPath)) === target) return;
-  } catch {
-    // path doesn't exist — proceed
-  }
-
-  // Retry up to 3 times: external tools can recreate the path between our rm
-  // and symlink calls, causing EEXIST and macOS conflict copies (e.g. "rules 2")
-  for (let attempt = 0; attempt < 3; attempt++) {
-    await fs.rm(symlinkPath, { recursive: true, force: true });
-    try {
-      await fs.symlink(target, symlinkPath);
-      return;
-    } catch (err) {
-      if ((err as NodeJS.ErrnoException).code !== "EEXIST" || attempt === 2) throw err;
-    }
-  }
-}
-
-function relativeTarget(symlinkPath: string, targetAbsPath: string): string {
-  return path.relative(path.dirname(symlinkPath), targetAbsPath);
-}
-
-export function buildMainSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[] {
-  const instructionsAbs = path.join(root, ONEAGENT_DIR, "instructions.md");
-  const seen = new Map<string, SymlinkEntry>();
-
-  for (const target of targets) {
-    const def = AGENT_DEFINITIONS.find((d) => d.target === target)!;
-    const symlinkPath = path.join(root, def.mainFile);
-    if (!seen.has(symlinkPath)) {
-      seen.set(symlinkPath, {
-        symlinkPath,
-        target: relativeTarget(symlinkPath, instructionsAbs),
-        label: path.relative(root, symlinkPath),
-      });
-    }
-  }
-
-  return Array.from(seen.values());
-}
-
-export function buildRulesSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[] {
-  const targetAbs = path.join(root, ONEAGENT_DIR, "rules");
-  return AGENT_DEFINITIONS
-    .filter((d) => targets.includes(d.target) && d.rulesDir)
-    .map((d) => {
-      const symlinkPath = path.join(root, d.rulesDir!);
-      return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d.rulesDir! };
-    });
-}
-
-export function buildSkillSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[] {
-  const targetAbs = path.join(root, ONEAGENT_DIR, "skills");
-  return AGENT_DEFINITIONS
-    .filter((d) => targets.includes(d.target) && d.skillsDir)
-    .map((d) => {
-      const symlinkPath = path.join(root, d.skillsDir!);
-      return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d.skillsDir! };
-    });
-}
-
-export function buildCommandSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[] {
-  const targetAbs = path.join(root, ONEAGENT_DIR, "commands");
-  return AGENT_DEFINITIONS
-    .filter((d) => targets.includes(d.target) && d.commandsDir)
-    .map((d) => {
-      const symlinkPath = path.join(root, d.commandsDir!);
-      return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d.commandsDir! };
-    });
-}
-
-export function buildAgentsDirSymlinks(root: string): SymlinkEntry[] {
-  const symlinkPath = path.join(root, ".agents/skills");
-  const targetAbs = path.join(root, ONEAGENT_DIR, "skills");
-  return [{ symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: ".agents/skills" }];
-}
-
-async function migrateFilesFromDir(srcDir: string, destDir: string, root: string): Promise<void> {
-  await fs.mkdir(destDir, { recursive: true });
-  let entries: import("fs").Dirent[];
-  try {
-    entries = await fs.readdir(srcDir, { withFileTypes: true });
-  } catch {
-    return; // srcDir doesn't exist — no-op
-  }
-  for (const entry of entries) {
-    const srcFile = path.join(srcDir, entry.name);
-    const fileStat = await fs.lstat(srcFile);
-    if (fileStat.isSymbolicLink()) continue;
-
-    // Move subdirectories as whole units (e.g. skills.sh skill packages)
-    if (fileStat.isDirectory()) {
-      const destSub = path.join(destDir, entry.name);
-      try { await fs.access(destSub); } catch {
-        await fs.mkdir(destDir, { recursive: true });
-        await fs.rename(srcFile, destSub);
-      }
-      continue;
-    }
-
-    if (!fileStat.isFile()) continue;
-    const destFile = path.join(destDir, entry.name);
-
-    let destExists = false;
-    try {
-      await fs.access(destFile);
-      destExists = true;
-    } catch {
-      // dest doesn't exist
-    }
-
-    if (destExists) {
-      // dest exists — compare content before deleting source
-      const [srcContent, destContent] = await Promise.all([
-        fs.readFile(srcFile, "utf-8"),
-        fs.readFile(destFile, "utf-8"),
-      ]);
-      if (srcContent !== destContent) {
-        // Different content — backup source before deleting
-        const backupDir = path.join(root, ONEAGENT_DIR, "backup");
-        await fs.mkdir(backupDir, { recursive: true });
-        const safeName = path.relative(root, srcFile).replace(/\//g, "_");
-        await fs.writeFile(path.join(backupDir, safeName), srcContent);
-      }
-      await fs.unlink(srcFile); // safe to delete — dest has the content (or backup was created)
-    } else {
-      await fs.rename(srcFile, destFile);
-    }
-  }
-}
-
-async function migrateAndRemoveDir(src: string, dest: string, root: string): Promise<void> {
-  let stat;
-  try {
-    stat = await fs.lstat(src);
-  } catch {
-    return; // doesn't exist — no-op
-  }
-  if (stat.isSymbolicLink() || !stat.isDirectory()) return;
-  await migrateFilesFromDir(src, dest, root);
-  await fs.rm(src, { recursive: true, force: true });
-}
-
-export async function migrateRuleAndSkillFiles(root: string): Promise<void> {
-  const destRules = path.join(root, ONEAGENT_DIR, "rules");
-  const destSkills = path.join(root, ONEAGENT_DIR, "skills");
-  const destCommands = path.join(root, ONEAGENT_DIR, "commands");
-  // Derive migration sources from agent definitions — sequential to avoid same-name conflicts.
-  for (const def of AGENT_DEFINITIONS) {
-    if (def.rulesDir) await migrateAndRemoveDir(path.join(root, def.rulesDir), destRules, root);
-  }
-  for (const def of AGENT_DEFINITIONS) {
-    if (def.skillsDir) await migrateAndRemoveDir(path.join(root, def.skillsDir), destSkills, root);
-  }
-  // .agents/skills — standard skills.sh path, not represented in agent definitions
-  await migrateAndRemoveDir(path.join(root, ".agents/skills"), destSkills, root);
-  for (const def of AGENT_DEFINITIONS) {
-    if (def.commandsDir) await migrateAndRemoveDir(path.join(root, def.commandsDir), destCommands, root);
-  }
-}
-
-async function backupDirRecursive(srcDir: string, backupDir: string, prefix: string): Promise<void> {
-  let entries: import("fs").Dirent[];
-  try { entries = await fs.readdir(srcDir, { withFileTypes: true }); } catch { return; }
-  for (const entry of entries) {
-    const srcPath = path.join(srcDir, entry.name);
-    const lstat = await fs.lstat(srcPath);
-    if (lstat.isSymbolicLink()) continue;
-    if (lstat.isDirectory()) {
-      await backupDirRecursive(srcPath, backupDir, `${prefix}_${entry.name}`);
-    } else if (lstat.isFile()) {
-      await fs.mkdir(backupDir, { recursive: true });
-      await fs.copyFile(srcPath, path.join(backupDir, `${prefix}_${entry.name}`));
-    }
-  }
-}
-
-export async function cleanupAgentDir(root: string, target: import("./types.ts").AgentTarget): Promise<void> {
-  const def = AGENT_DEFINITIONS.find((d) => d.target === target)!;
-  const backupDir = path.join(root, ONEAGENT_DIR, "backup");
-
-  const agentDir = [def.rulesDir, def.skillsDir, def.commandsDir]
-    .filter(Boolean)
-    .map((d) => d!.split("/")[0]!)
-    .find((d) => d !== ".github");
-
-  if (agentDir) {
-    const agentDirAbs = path.join(root, agentDir);
-    let stat;
-    try { stat = await fs.lstat(agentDirAbs); } catch {}
-    if (stat && stat.isDirectory() && !stat.isSymbolicLink()) {
-      await backupDirRecursive(agentDirAbs, backupDir, agentDir);
-      await fs.rm(agentDirAbs, { recursive: true, force: true });
-    }
-  }
-
-  if (target === "opencode") {
-    const opPath = path.join(root, "opencode.json");
-    try {
-      const content = await fs.readFile(opPath, "utf-8");
-      await fs.mkdir(backupDir, { recursive: true });
-      await fs.writeFile(path.join(backupDir, "opencode.json"), content);
-    } catch {}
-    try { await fs.unlink(opPath); } catch {}
-  }
-}
-
-export async function createAllSymlinks(entries: SymlinkEntry[]): Promise<void> {
-  // Deduplicate by symlink path — last entry wins
-  const deduped = new Map<string, SymlinkEntry>();
-  for (const e of entries) deduped.set(e.symlinkPath, e);
-  for (const e of deduped.values()) {
-    await createSymlink(e.symlinkPath, e.target);
-  }
-}
-
-export async function checkSymlink(entry: SymlinkEntry): Promise<SymlinkCheck> {
-  try {
-    const stat = await fs.lstat(entry.symlinkPath);
-    if (!stat.isSymbolicLink()) {
-      return { ...entry, exists: true, valid: false };
-    }
-    const linkTarget = await fs.readlink(entry.symlinkPath);
-    return { ...entry, exists: true, valid: linkTarget === entry.target };
-  } catch {
-    return { ...entry, exists: false, valid: false };
-  }
-}

package/src/types.ts

@@ -1,60 +0,0 @@
-export type AgentTarget = "claude" | "cursor" | "windsurf" | "opencode" | "copilot";
-
-export interface Config {
-  version: 1;
-  targets: Record<AgentTarget, boolean>;
-}
-
-export interface DetectedFile {
-  relativePath: string;
-  absolutePath: string;
-  sizeBytes: number;
-  modifiedAt: Date;
-  content: string;
-}
-
-export interface RuleFile {
-  name: string;
-  path: string;
-}
-
-export interface CommandFile {
-  name: string;
-  path: string;
-}
-
-export interface SkillFile {
-  name: string;
-  path: string;
-  description: string;
-  mode: "ask" | "edit" | "agent";
-  content: string;
-}
-
-export interface SymlinkEntry {
-  symlinkPath: string;
-  target: string;
-  label: string;
-}
-
-export interface SymlinkCheck extends SymlinkEntry {
-  exists: boolean;
-  valid: boolean;
-}
-
-export interface StatusResult {
-  symlinks: SymlinkCheck[];
-  generatedFiles: GeneratedFileCheck[];
-  opencode: OpenCodeCheck;
-}
-
-export interface GeneratedFileCheck {
-  path: string;
-  exists: boolean;
-  upToDate: boolean;
-}
-
-export interface OpenCodeCheck {
-  exists: boolean;
-  valid: boolean;
-}