Fix Antigravity support

README.md

@@ -24,6 +24,20 @@ A CLI tool for downloading and managing [Point-Free Way](https://www.pointfree.c
     $ pfw install --tool codex
     ```
 
+## Installation Options
+
+By default, `pfw` creates symbolic links from your AI tool's skills directory to a central location (`~/.pfw/skills/`). This allows skills to be updated in one place and immediately available to all tools.
+
+### When to use `--copy`
+
+If skills aren't being detected by your AI tool after installation, the tool may not support symbolic links. In this case, use the `--copy` flag to create full copies instead:
+
+```sh
+$ pfw install --tool <tool> --copy
+```
+
+> **Note:** When using `--copy`, skills are duplicated for each tool (using more disk space), and you'll need to re-run `pfw install --copy` after each update to get the latest skill versions.
+
 ## Supported AI Tools
 
 | `pfw install --tool` | Install Path |

Sources/pfw/Dependencies/FileSystem.swift

@@ -12,6 +12,7 @@ protocol FileSystem: Sendable {
   func data(at url: URL) throws -> Data
   func createSymbolicLink(at url: URL, withDestinationURL destURL: URL) throws
   func moveItem(at srcURL: URL, to dstURL: URL) throws
+  func copyItem(at srcURL: URL, to dstURL: URL) throws
   func contentsOfDirectory(at url: URL) throws -> [URL]
   func unzipItem(at sourceURL: URL, to destinationURL: URL) throws
 }

Sources/pfw/Install.swift

@@ -225,7 +225,11 @@ struct Install: AsyncParsableCommand {
         (try? fileSystem.contentsOfDirectory(at: centralSkillsURL)) ?? []
       for directory in centralSkillDirectories {
         let toolDestination = skillsURL.appendingPathComponent("pfw-\(directory.lastPathComponent)")
-        try fileSystem.createSymbolicLink(at: toolDestination, withDestinationURL: directory)
+        if target.tool == .cursor {
+          try fileSystem.copyItem(at: directory, to: toolDestination)
+        } else {
+          try fileSystem.createSymbolicLink(at: toolDestination, withDestinationURL: directory)
+        }
       }
       if let tool = target.tool {
         print("  • \(tool.rawValue): \(skillsURL.path)")

Tests/pfwTests/InstallTests.swift

@@ -452,8 +452,12 @@ extension BaseSuite {
             blob/
               .cursor/
                 skills/
-                  pfw-ComposableArchitecture@ -> /Users/blob/.pfw/skills/ComposableArchitecture
-                  pfw-SQLiteData@ -> /Users/blob/.pfw/skills/SQLiteData
+                  pfw-ComposableArchitecture/
+                    SKILL.md "# Composable Architecture"
+                    references/
+                      navigation.md "# Navigation"
+                  pfw-SQLiteData/
+                    SKILL.md "# SQLiteData"
               .pfw/
                 machine "00000000-0000-0000-0000-000000000001"
                 sha "cafebeef"

Tests/pfwTests/Internal/InMemoryFileSystem.swift

@@ -303,6 +303,46 @@ final class InMemoryFileSystem: FileSystem {
       return children.sorted().map { url.appendingPathComponent($0) }
     }
   }
+
+  func copyItem(at srcURL: URL, to dstURL: URL) throws {
+    let sourcePath = normalize(srcURL)
+    let destinationPath = normalize(dstURL)
+    let destinationParent = normalize(dstURL.deletingLastPathComponent())
+    try state.withValue { state in
+      guard state.directories.contains(destinationParent) else {
+        throw Error.directoryNotFound(destinationParent)
+      }
+      guard state.files[destinationPath] == nil,
+        state.directories.contains(destinationPath) == false,
+        state.symbolicLinks[destinationPath] == nil
+      else {
+        throw Error.fileExists(destinationPath)
+      }
+
+      guard state.directories.contains(sourcePath) else {
+        throw Error.fileNotFound(sourcePath)
+      }
+
+      state.directories.insert(destinationPath)
+
+      let sourcePrefix = sourcePath.hasSuffix("/") ? sourcePath : sourcePath + "/"
+      let destinationPrefix = destinationPath.hasSuffix("/") ? destinationPath : destinationPath + "/"
+
+      for directory in state.directories {
+        if directory.hasPrefix(sourcePrefix) {
+          let suffix = directory.dropFirst(sourcePrefix.count)
+          state.directories.insert(destinationPrefix + suffix)
+        }
+      }
+
+      for (path, data) in state.files {
+        if path.hasPrefix(sourcePrefix) {
+          let suffix = path.dropFirst(sourcePrefix.count)
+          state.files[destinationPrefix + suffix] = data
+        }
+      }
+    }
+  }
 }
 
 extension InMemoryFileSystem: CustomStringConvertible {