@oomerevren/tryforge 0.1.2 → 0.1.3

package/dist/cli/src/adapters/claude.js

@@ -1,31 +1,60 @@
-// cli/src/adapters/claude.ts — Claude Code harness
+// cli/src/adapters/claude.ts — Claude Code harness (2026 format)
+//
+// Skills/agents: type-aware dirs under ~/.claude/ (skills/, agents/, ...).
+// Rules (declarative): merged forge blocks in <project>/CLAUDE.md — user
+// content outside markers is never touched (see core/merge.ts).
+// MCP: user-scope ~/.claude.json (mcpServers key — behavior config in
+// settings.json is left alone).
 import { existsSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
-import { installSkillFiles, uninstallSkillFiles, removeLinkOrDir, listDirNames, targetDirFor } from "./types.js";
+import { removeLinkOrDir, targetDirFor, uninstallSkillFiles, installSkillFiles } from "./types.js";
+import { testHome, pointerBody, sharedList, sharedIsInstalled, syncBlockFile, unsyncBlockFile, shouldSyncRules, } from "./base.js";
+function skillPaths() {
+    const base = join(testHome(), ".claude");
+    return {
+        skillBases: () => [join(base, "skills")],
+        installBase: () => join(base, "skills"),
+    };
+}
+function claudeMdPath(projectDir) {
+    return join(projectDir, "CLAUDE.md");
+}
+function syncClaudeMd(projectDir, pkgSlug, meta) {
+    const file = claudeMdPath(projectDir);
+    if (!shouldSyncRules(projectDir, file))
+        return;
+    syncBlockFile(file, pkgSlug, meta?.version ?? "0.0.0", pointerBody({
+        slug: pkgSlug,
+        version: meta?.version ?? "",
+        description: meta?.description ?? `${pkgSlug} (installed via Forge)`,
+        skillPath: join(testHome(), ".claude", "skills", pkgSlug),
+    }));
+}
 export const claudeAdapter = {
     name: "claude-code",
     displayName: "Claude Code",
-    version: "0.1.0",
-    detect: () => existsSync(join(homedir(), ".claude")),
-    skillDir: (slug) => join(homedir(), ".claude", "skills", slug),
+    version: "0.2.0",
+    detect: () => existsSync(join(testHome(), ".claude")),
+    skillDir: (slug) => join(testHome(), ".claude", "skills", slug),
     // Epoch 1c: Claude user-scope MCP = ~/.claude.json (not settings.json which is behavior config)
-    mcpConfigPath: () => join(homedir(), ".claude.json"),
-    async install(pkgSlug, srcDir, type) {
-        // Epoch 1d: type-aware install — her tip kendi dizinine gider
-        const base = join(homedir(), ".claude");
+    mcpConfigPath: () => join(testHome(), ".claude.json"),
+    async install(pkgSlug, srcDir, type, meta) {
+        // Epoch 1d: type-aware install — each type goes to its own directory
+        const base = join(testHome(), ".claude");
         installSkillFiles("claude-code", pkgSlug, srcDir, targetDirFor(base, type));
+        syncClaudeMd(process.cwd(), pkgSlug, meta);
     },
     async uninstall(pkgSlug, type) {
         void type;
-        uninstallSkillFiles(pkgSlug, join(homedir(), ".claude", "skills"));
-        const agentPath = join(homedir(), ".claude", "agents", pkgSlug);
+        uninstallSkillFiles(pkgSlug, join(testHome(), ".claude", "skills"));
+        const agentPath = join(testHome(), ".claude", "agents", pkgSlug);
         removeLinkOrDir(agentPath);
+        unsyncBlockFile(claudeMdPath(process.cwd()), pkgSlug);
     },
     async list() {
-        return listDirNames(join(homedir(), ".claude", "skills"));
+        return sharedList(skillPaths());
     },
     async isInstalled(pkgSlug) {
-        return existsSync(join(homedir(), ".claude", "skills", pkgSlug));
+        return sharedIsInstalled(skillPaths(), pkgSlug);
     },
 };

package/dist/cli/src/adapters/codex.js

@@ -1,30 +1,31 @@
-// cli/src/adapters/codex.ts — Codex harness
+// cli/src/adapters/codex.ts — Codex harness (shared file-adapter base)
 import { existsSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
-import { installSkillFiles, uninstallSkillFiles } from "./types.js";
+import { testHome, sharedList, sharedIsInstalled, sharedUninstall, sharedInstall, } from "./base.js";
+import { syncAgentsMd, unsyncAgentsMd } from "./agents-md.js";
+function paths() {
+    const base = join(testHome(), ".codex", "skills");
+    return { skillBases: () => [base], installBase: () => base };
+}
 export const codexAdapter = {
     name: "codex",
     displayName: "Codex",
-    version: "0.1.0",
-    detect: () => existsSync(join(homedir(), ".codex")),
-    skillDir: (slug) => join(homedir(), ".codex", "skills", slug),
-    mcpConfigPath: () => join(homedir(), ".codex", "mcp.json"),
-    async install(pkgSlug, srcDir, type) {
-        void type;
-        installSkillFiles("codex", pkgSlug, srcDir, join(homedir(), ".codex", "skills"));
+    version: "0.2.0",
+    detect: () => existsSync(join(testHome(), ".codex")),
+    skillDir: (slug) => join(paths().installBase(), slug),
+    mcpConfigPath: () => join(testHome(), ".codex", "mcp.json"),
+    async install(pkgSlug, srcDir, _type, meta) {
+        sharedInstall(paths(), pkgSlug, srcDir);
+        syncAgentsMd(process.cwd(), pkgSlug, join(paths().installBase(), pkgSlug), meta);
     },
     async uninstall(pkgSlug, _type) {
-        uninstallSkillFiles(pkgSlug, join(homedir(), ".codex", "skills"));
+        sharedUninstall(paths(), pkgSlug);
+        unsyncAgentsMd(process.cwd(), pkgSlug);
     },
     async list() {
-        const dir = join(homedir(), ".codex", "skills");
-        if (!existsSync(dir))
-            return [];
-        const { readdirSync } = await import("fs");
-        return readdirSync(dir, { withFileTypes: true }).filter((d) => (d.isDirectory() || d.isSymbolicLink()) && !d.name.startsWith(".")).map((d) => d.name);
+        return sharedList(paths());
     },
     async isInstalled(pkgSlug) {
-        return existsSync(join(homedir(), ".codex", "skills", pkgSlug));
+        return sharedIsInstalled(paths(), pkgSlug);
     },
 };

package/dist/cli/src/adapters/cursor.js

@@ -1,42 +1,56 @@
-// cli/src/adapters/cursor.ts — Cursor harness
-import { existsSync } from "fs";
+// cli/src/adapters/cursor.ts — Cursor harness (2026 format)
+//
+// Skills: <scope>/skills/<slug>/ (legacy dir, kept for back-compat).
+// Rules (modern): <scope>/rules/<slug>.mdc with frontmatter
+//   (description, globs, alwaysApply) — Cursor reads these natively.
+// MCP: injected into <scope>/mcp.json (via mcpConfigPath).
+// Scope = project .cursor/ when present, else ~/.cursor/.
+import { existsSync, rmSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
-import { installSkillFiles, uninstallSkillFiles, listDirNames } from "./types.js";
+import { testHome, instructionBody, sharedList, sharedIsInstalled, sharedUninstall, sharedInstall, writeManagedFile, } from "./base.js";
+function scopeBase() {
+    const proj = join(process.cwd(), ".cursor");
+    if (existsSync(proj))
+        return proj;
+    return join(testHome(), ".cursor");
+}
+function paths() {
+    const base = scopeBase();
+    return {
+        skillBases: () => [join(process.cwd(), ".cursor", "skills"), join(testHome(), ".cursor", "skills")],
+        installBase: () => join(base, "skills"),
+    };
+}
+function ruleFile(scope, pkgSlug) {
+    return join(scope, "rules", `${pkgSlug}.mdc`);
+}
+function ruleContent(pkgSlug, srcDir, meta) {
+    const description = meta?.description ?? `${pkgSlug} (installed via Forge)`;
+    const version = meta?.version ?? "0.0.0";
+    const body = instructionBody(srcDir, `${pkgSlug}@${version} — ${description}`);
+    return `---\ndescription: ${description}\nglobs:\nalwaysApply: false\n---\n<!-- FORGE:START id="${pkgSlug}" version="${version}" -->\n${body}<!-- FORGE:END id="${pkgSlug}" -->\n`;
+}
 export const cursorAdapter = {
     name: "cursor",
     displayName: "Cursor",
-    version: "0.1.0",
-    detect: () => existsSync(join(process.cwd(), ".cursor")) || existsSync(join(homedir(), ".cursor")),
-    skillDir: (slug) => {
-        if (existsSync(join(process.cwd(), ".cursor")))
-            return join(process.cwd(), ".cursor", "skills", slug);
-        return join(homedir(), ".cursor", "skills", slug);
-    },
-    mcpConfigPath: () => {
-        if (existsSync(join(process.cwd(), ".cursor")))
-            return join(process.cwd(), ".cursor", "mcp.json");
-        return join(homedir(), ".cursor", "mcp.json");
-    },
-    async install(pkgSlug, srcDir, type) {
-        void type;
-        const base = existsSync(join(process.cwd(), ".cursor")) ? join(process.cwd(), ".cursor", "skills") : join(homedir(), ".cursor", "skills");
-        installSkillFiles("cursor", pkgSlug, srcDir, base);
+    version: "0.2.0",
+    detect: () => existsSync(join(process.cwd(), ".cursor")) || existsSync(join(testHome(), ".cursor")),
+    skillDir: (slug) => join(paths().installBase(), slug),
+    mcpConfigPath: () => join(scopeBase(), "mcp.json"),
+    async install(pkgSlug, srcDir, _type, meta) {
+        sharedInstall(paths(), pkgSlug, srcDir);
+        // Modern multi-rule format alongside the legacy skills dir.
+        writeManagedFile(ruleFile(scopeBase(), pkgSlug), pkgSlug, ruleContent(pkgSlug, srcDir, meta));
     },
     async uninstall(pkgSlug, _type) {
-        const base = existsSync(join(process.cwd(), ".cursor")) ? join(process.cwd(), ".cursor", "skills") : join(homedir(), ".cursor", "skills");
-        uninstallSkillFiles(pkgSlug, base);
+        sharedUninstall(paths(), pkgSlug);
+        rmSync(ruleFile(join(process.cwd(), ".cursor"), pkgSlug), { force: true });
+        rmSync(ruleFile(join(testHome(), ".cursor"), pkgSlug), { force: true });
     },
     async list() {
-        const bases = [join(process.cwd(), ".cursor", "skills"), join(homedir(), ".cursor", "skills")];
-        for (const b of bases) {
-            if (existsSync(b))
-                return listDirNames(b);
-        }
-        return [];
+        return sharedList(paths());
     },
     async isInstalled(pkgSlug) {
-        const bases = [join(process.cwd(), ".cursor", "skills"), join(homedir(), ".cursor", "skills")];
-        return bases.some((b) => existsSync(join(b, pkgSlug)));
+        return sharedIsInstalled(paths(), pkgSlug);
     },
 };

package/dist/cli/src/adapters/dsh.js

@@ -1,46 +1,44 @@
-// cli/src/adapters/dsh.ts — DeepSeek harness
+// cli/src/adapters/dsh.ts — DeepSeek harness (shared file-adapter base)
+//
+// Epoch 1c: DSH adapter is marked deprecated/legacy.
+// The DeepSeek harness has no "skills" concept; it uses a cordis.yml + TS plugin model.
+// Kept for backwards compatibility, surfaced as "community-maintained, untested".
 import { existsSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
-import { installSkillFiles, uninstallSkillFiles, listDirNames } from "./types.js";
-// Epoch 1c: DSH adapter artık deprecated/legacy olarak işaretlenmiş.
-// DeepSeek Harness'ında "skills" kavramı yok; cordis.yml + TS plugin modeli kullanılır.
-// Adapter'ı tutuyoruz (geriye uyumluluk) ama "community-maintained, untested" olarak gösteriyoruz.
+import { testHome, sharedList, sharedIsInstalled, sharedUninstall, sharedInstall, } from "./base.js";
+import { syncAgentsMd, unsyncAgentsMd } from "./agents-md.js";
+function inProject() {
+    return existsSync(join(process.cwd(), ".dsh"));
+}
+function paths() {
+    return {
+        skillBases: () => [join(process.cwd(), ".dsh", "skills"), join(testHome(), ".dsh", "skills")],
+        installBase: () => (inProject() ? join(process.cwd(), ".dsh", "skills") : join(testHome(), ".dsh", "skills")),
+    };
+}
 export const dshAdapter = {
     name: "dsh",
     displayName: "DeepSeek (DSH, community/untested)",
-    version: "0.1.0",
-    detect: () => existsSync(join(homedir(), ".dsh")) || existsSync(join(process.cwd(), ".dsh")),
-    skillDir: (slug) => {
-        if (existsSync(join(process.cwd(), ".dsh")))
-            return join(process.cwd(), ".dsh", "skills", slug);
-        return join(homedir(), ".dsh", "skills", slug);
-    },
+    version: "0.2.0",
+    detect: () => existsSync(join(testHome(), ".dsh")) || inProject(),
+    skillDir: (slug) => join(paths().installBase(), slug),
     mcpConfigPath: () => {
-        if (existsSync(join(process.cwd(), ".dsh")))
+        if (inProject())
             return join(process.cwd(), ".dsh", "mcp.json");
-        return join(homedir(), ".dsh", "mcp.json");
+        return join(testHome(), ".dsh", "mcp.json");
     },
-    async install(pkgSlug, srcDir, type) {
-        void type;
-        const base = existsSync(join(process.cwd(), ".dsh")) ? join(process.cwd(), ".dsh", "skills") : join(homedir(), ".dsh", "skills");
-        installSkillFiles("dsh", pkgSlug, srcDir, base);
+    async install(pkgSlug, srcDir, _type, meta) {
+        sharedInstall(paths(), pkgSlug, srcDir);
+        syncAgentsMd(process.cwd(), pkgSlug, join(paths().installBase(), pkgSlug), meta);
     },
     async uninstall(pkgSlug, _type) {
-        const bases = [join(process.cwd(), ".dsh", "skills"), join(homedir(), ".dsh", "skills")];
-        for (const b of bases)
-            uninstallSkillFiles(pkgSlug, b);
+        sharedUninstall(paths(), pkgSlug);
+        unsyncAgentsMd(process.cwd(), pkgSlug);
     },
     async list() {
-        const bases = [join(process.cwd(), ".dsh", "skills"), join(homedir(), ".dsh", "skills")];
-        for (const b of bases) {
-            if (existsSync(b))
-                return listDirNames(b);
-        }
-        return [];
+        return sharedList(paths());
     },
     async isInstalled(pkgSlug) {
-        const bases = [join(process.cwd(), ".dsh", "skills"), join(homedir(), ".dsh", "skills")];
-        return bases.some((b) => existsSync(join(b, pkgSlug)));
+        return sharedIsInstalled(paths(), pkgSlug);
     },
 };

package/dist/cli/src/adapters/generic.js

@@ -1,23 +1,26 @@
 // cli/src/adapters/generic.ts — Generic fallback (./.forge/packages)
 import { join } from "path";
-import { installSkillFiles, uninstallSkillFiles, listDirNames } from "./types.js";
-import { existsSync } from "fs";
+import { sharedList, sharedIsInstalled, sharedUninstall, sharedInstall, } from "./base.js";
+function paths() {
+    const base = join(process.cwd(), ".forge", "packages");
+    return { skillBases: () => [base], installBase: () => base };
+}
 export const genericAdapter = {
     name: "generic",
     displayName: "Generic (.forge)",
     detect: () => true, // always as fallback
     skillDir: (slug) => join(process.cwd(), ".forge", "packages", slug),
     mcpConfigPath: () => join(process.cwd(), ".forge", "mcp.json"),
-    async install(pkgSlug, srcDir, _type) {
-        installSkillFiles("generic", pkgSlug, srcDir, join(process.cwd(), ".forge", "packages"));
+    async install(pkgSlug, srcDir, _type, _meta) {
+        sharedInstall(paths(), pkgSlug, srcDir);
     },
     async uninstall(pkgSlug, _type) {
-        uninstallSkillFiles(pkgSlug, join(process.cwd(), ".forge", "packages"));
+        sharedUninstall(paths(), pkgSlug);
     },
     async list() {
-        return listDirNames(join(process.cwd(), ".forge", "packages"));
+        return sharedList(paths());
     },
     async isInstalled(pkgSlug) {
-        return existsSync(join(process.cwd(), ".forge", "packages", pkgSlug));
+        return sharedIsInstalled(paths(), pkgSlug);
     },
 };

package/dist/cli/src/adapters/opencode.js

@@ -1,41 +1,41 @@
-// cli/src/adapters/opencode.ts — OpenCode harness
+// cli/src/adapters/opencode.ts — OpenCode harness (shared file-adapter base)
 import { existsSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
-import { installSkillFiles, uninstallSkillFiles, listDirNames } from "./types.js";
+import { testHome, sharedList, sharedIsInstalled, sharedUninstall, sharedInstall, } from "./base.js";
+import { syncAgentsMd, unsyncAgentsMd } from "./agents-md.js";
+function inProject() {
+    return existsSync(join(process.cwd(), "opencode.json"));
+}
+function paths() {
+    return {
+        skillBases: () => [join(process.cwd(), ".opencode", "skills"), join(testHome(), ".config", "opencode", "skills")],
+        installBase: () => inProject() ? join(process.cwd(), ".opencode", "skills") : join(testHome(), ".config", "opencode", "skills"),
+    };
+}
 export const opencodeAdapter = {
     name: "opencode",
     displayName: "OpenCode",
-    version: "0.1.0",
-    detect: () => existsSync(join(process.cwd(), "opencode.json")) || existsSync(join(homedir(), ".config", "opencode", "opencode.json")),
-    skillDir: (slug) => join(process.cwd(), ".opencode", "skills", slug),
+    version: "0.2.0",
+    detect: () => inProject() || existsSync(join(testHome(), ".config", "opencode", "opencode.json")),
+    skillDir: (slug) => join(paths().installBase(), slug),
     mcpConfigPath: () => {
         const proj = join(process.cwd(), "opencode.json");
         if (existsSync(proj))
             return proj;
-        return join(homedir(), ".config", "opencode", "opencode.json");
+        return join(testHome(), ".config", "opencode", "opencode.json");
     },
-    async install(pkgSlug, srcDir, type) {
-        void type;
-        const isProject = existsSync(join(process.cwd(), "opencode.json"));
-        const base = isProject ? join(process.cwd(), ".opencode", "skills") : join(homedir(), ".config", "opencode", "skills");
-        installSkillFiles("opencode", pkgSlug, srcDir, base);
+    async install(pkgSlug, srcDir, _type, meta) {
+        sharedInstall(paths(), pkgSlug, srcDir);
+        syncAgentsMd(process.cwd(), pkgSlug, join(paths().installBase(), pkgSlug), meta);
     },
     async uninstall(pkgSlug, _type) {
-        const isProject = existsSync(join(process.cwd(), "opencode.json"));
-        const base = isProject ? join(process.cwd(), ".opencode", "skills") : join(homedir(), ".config", "opencode", "skills");
-        uninstallSkillFiles(pkgSlug, base);
+        sharedUninstall(paths(), pkgSlug);
+        unsyncAgentsMd(process.cwd(), pkgSlug);
     },
     async list() {
-        const bases = [join(process.cwd(), ".opencode", "skills"), join(homedir(), ".config", "opencode", "skills")];
-        for (const b of bases) {
-            if (existsSync(b))
-                return listDirNames(b);
-        }
-        return [];
+        return sharedList(paths());
     },
     async isInstalled(pkgSlug) {
-        const bases = [join(process.cwd(), ".opencode", "skills"), join(homedir(), ".config", "opencode", "skills")];
-        return bases.some((b) => existsSync(join(b, pkgSlug)));
+        return sharedIsInstalled(paths(), pkgSlug);
     },
 };

package/dist/cli/src/adapters/types.js

@@ -1,6 +1,7 @@
 // cli/src/adapters/types.ts — Epoch 1c: fail-closed MCP config, Windows junction, skill files
-import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, cpSync, copyFileSync, symlinkSync, lstatSync, unlinkSync, renameSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, copyFileSync, symlinkSync, lstatSync, unlinkSync, renameSync } from "fs";
 import { join, dirname } from "path";
+import { copyDirRecursive } from "../core/fsutil.js";
 export { forgeHome, packagesDir, packageDir, toSlug } from "../core/store.js";
 export function ensureDir(dir) {
     if (!existsSync(dir))
@@ -26,7 +27,9 @@ export function trySymlinkOrCopy(src, dest) {
         return;
     }
     catch {
-        cpSync(src, dest, { recursive: true });
+        // NOTE: raw fs.cpSync silently yields empty dirs under non-ASCII
+        // Windows home paths — always use copyDirRecursive (see fsutil.ts).
+        copyDirRecursive(src, dest);
     }
 }
 export function removeLinkOrDir(target) {
@@ -59,13 +62,13 @@ export function readMcpConfig(configPath) {
     }
     catch (e) {
         throw new Error(`[forge] MCP config at ${configPath} contains invalid JSON: ${e.message}\n` +
-            `[forge] Refusing to modify. Fix the config manually or rename it, then retry.`);
+            `[forge] Refusing to modify. Fix the config manually or rename it, then retry.`, { cause: e });
     }
 }
-export function writeMcpConfig(configPath, data, opts = {}) {
+export function writeMcpConfig(configPath, data) {
     ensureDir(dirname(configPath));
     backupFileIfExists(configPath);
-    // Epoch 1d: Atomic write — temp dosyaya yaz, sonra rename (crash-safe)
+    // Epoch 1d: atomic write — write to temp file, then rename (crash-safe)
     const tmp = configPath + ".tmp." + Date.now();
     writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
     renameSync(tmp, configPath);
@@ -87,10 +90,10 @@ export function backupFileIfExists(configPath) {
     }
 }
 export function addMcpServerToConfig(configPath, name, mcp) {
-    // Epoch 1e: dosya yoksa oluştur (taze makine desteği)
+    // Epoch 1e: create the file when missing (fresh-machine support)
     let cfg = readMcpConfig(configPath);
     if (cfg === null) {
-        // Dosya yok veya boş — yeni config oluştur
+        // File missing or empty — create a fresh config
         cfg = {};
     }
     if (!cfg["mcpServers"])
@@ -109,11 +112,11 @@ export function removeMcpServerFromConfig(configPath, name) {
         return; // file doesn't exist or invalid — nothing to remove
     const servers = cfg["mcpServers"];
     if (servers && name in servers) {
-        delete servers[name];
+        Reflect.deleteProperty(servers, name);
         writeMcpConfig(configPath, cfg);
     }
 }
-// Epoch 1d: type-aware hedef dizin
+// Epoch 1d: type-aware target directory
 export function targetDirFor(base, type) {
     const dirMap = {
         skill: "skills",

package/dist/cli/src/adapters/windsurf.js

@@ -1,43 +1,63 @@
-// cli/src/adapters/windsurf.ts — Windsurf harness (Faz 12 yeni)
-import { existsSync } from "fs";
+// cli/src/adapters/windsurf.ts — Windsurf harness (2026 format)
+//
+// Skills: <scope>/skills/<slug>/ (kept for back-compat).
+// Rules (Cascade AI): merged forge blocks in <project>/.windsurfrules —
+// user content outside markers is never touched (see core/merge.ts).
+// MCP: synced to <project>/.windsurf/mcp_config.json, else the global
+// ~/.codeium/windsurf/mcp_config.json (via mcpConfigPath).
+import { existsSync, rmSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
-import { installSkillFiles, uninstallSkillFiles, listDirNames } from "./types.js";
+import { testHome, pointerBody, sharedList, sharedIsInstalled, sharedUninstall, sharedInstall, syncBlockFile, unsyncBlockFile, shouldSyncRules, } from "./base.js";
+function inProject() {
+    return existsSync(join(process.cwd(), ".windsurf"));
+}
+function paths() {
+    return {
+        skillBases: () => [join(process.cwd(), ".windsurf", "skills"), join(testHome(), ".windsurf", "skills")],
+        installBase: () => inProject() ? join(process.cwd(), ".windsurf", "skills") : join(testHome(), ".windsurf", "skills"),
+    };
+}
+function rulesPath() {
+    return join(process.cwd(), ".windsurfrules");
+}
+function syncRules(projectDir, pkgSlug, meta) {
+    const file = join(projectDir, ".windsurfrules");
+    if (!shouldSyncRules(projectDir, file))
+        return;
+    syncBlockFile(file, pkgSlug, meta?.version ?? "0.0.0", pointerBody({
+        slug: pkgSlug,
+        version: meta?.version ?? "",
+        description: meta?.description ?? `${pkgSlug} (installed via Forge)`,
+        skillPath: join(paths().installBase(), pkgSlug),
+    }));
+}
 export const windsurfAdapter = {
     name: "windsurf",
     displayName: "Windsurf",
-    version: "0.1.0",
-    detect: () => existsSync(join(process.cwd(), ".windsurf")) || existsSync(join(homedir(), ".windsurf")) || existsSync(join(homedir(), ".codeium", "windsurf")),
-    skillDir: (slug) => {
-        if (existsSync(join(process.cwd(), ".windsurf")))
-            return join(process.cwd(), ".windsurf", "skills", slug);
-        return join(homedir(), ".windsurf", "skills", slug);
-    },
+    version: "0.2.0",
+    detect: () => existsSync(join(process.cwd(), ".windsurf")) ||
+        existsSync(join(testHome(), ".windsurf")) ||
+        existsSync(join(testHome(), ".codeium", "windsurf")),
+    skillDir: (slug) => join(paths().installBase(), slug),
     mcpConfigPath: () => {
-        if (existsSync(join(process.cwd(), ".windsurf")))
+        if (inProject())
             return join(process.cwd(), ".windsurf", "mcp_config.json");
-        return join(homedir(), ".codeium", "windsurf", "mcp_config.json");
+        return join(testHome(), ".codeium", "windsurf", "mcp_config.json");
     },
-    async install(pkgSlug, srcDir, type) {
-        void type;
-        const base = existsSync(join(process.cwd(), ".windsurf")) ? join(process.cwd(), ".windsurf", "skills") : join(homedir(), ".windsurf", "skills");
-        installSkillFiles("windsurf", pkgSlug, srcDir, base);
+    async install(pkgSlug, srcDir, _type, meta) {
+        sharedInstall(paths(), pkgSlug, srcDir);
+        syncRules(process.cwd(), pkgSlug, meta);
     },
     async uninstall(pkgSlug, _type) {
-        const bases = [join(process.cwd(), ".windsurf", "skills"), join(homedir(), ".windsurf", "skills")];
-        for (const b of bases)
-            uninstallSkillFiles(pkgSlug, b);
+        sharedUninstall(paths(), pkgSlug);
+        unsyncBlockFile(rulesPath(), pkgSlug);
+        // Per-package Cascade rule files, if a previous version created them.
+        rmSync(join(process.cwd(), ".windsurf", "rules", `${pkgSlug}.md`), { force: true });
     },
     async list() {
-        const bases = [join(process.cwd(), ".windsurf", "skills"), join(homedir(), ".windsurf", "skills")];
-        for (const b of bases) {
-            if (existsSync(b))
-                return listDirNames(b);
-        }
-        return [];
+        return sharedList(paths());
     },
     async isInstalled(pkgSlug) {
-        const bases = [join(process.cwd(), ".windsurf", "skills"), join(homedir(), ".windsurf", "skills")];
-        return bases.some((b) => existsSync(join(b, pkgSlug)));
+        return sharedIsInstalled(paths(), pkgSlug);
     },
 };