feat(core): add Swift tree-sitter support

tests/skill/understand/test_extract_import_map.test.mjs

@@ -1200,6 +1200,96 @@ describe('extract-import-map.mjs — C/C++ resolver', () => {
   });
 });
 
+describe('extract-import-map.mjs — Swift resolver', () => {
+  let projectRoot;
+
+  afterEach(() => {
+    if (projectRoot) {
+      rmSync(projectRoot, { recursive: true, force: true });
+      projectRoot = null;
+    }
+  });
+
+  it('resolves SwiftPM target imports to all files in the imported module', () => {
+    projectRoot = setupTree({
+      'Sources/App/App.swift': `public struct AppRoot {}\n`,
+      'Sources/App/Feature.swift': `public struct Feature {}\n`,
+      'Tests/AppTests/AppTests.swift':
+        `import XCTest\n` +
+        `@testable import App\n` +
+        `final class AppTests: XCTestCase {}\n`,
+    });
+
+    const result = runScript(projectRoot, {
+      projectRoot,
+      files: [
+        { path: 'Sources/App/App.swift', language: 'swift', fileCategory: 'code' },
+        { path: 'Sources/App/Feature.swift', language: 'swift', fileCategory: 'code' },
+        { path: 'Tests/AppTests/AppTests.swift', language: 'swift', fileCategory: 'code' },
+      ],
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.output.importMap['Tests/AppTests/AppTests.swift']).toEqual([
+      'Sources/App/App.swift',
+      'Sources/App/Feature.swift',
+    ]);
+    expect(result.output.importMap['Sources/App/App.swift']).toEqual([]);
+    expect(result.output.importMap['Sources/App/Feature.swift']).toEqual([]);
+    expect(result.output.stats.filesWithImports).toBe(1);
+    expect(result.output.stats.totalEdges).toBe(2);
+  });
+
+  it('uses Package.swift custom target paths when module name differs from directory name', () => {
+    projectRoot = setupTree({
+      'Package.swift':
+        `// swift-tools-version: 5.9\n` +
+        `import PackageDescription\n` +
+        `let package = Package(\n` +
+        `  name: "Workspace",\n` +
+        `  targets: [\n` +
+        `    .target(name: "Domain", path: "Core/Model"),\n` +
+        `    .executableTarget(name: "App", path: "Clients/App")\n` +
+        `  ]\n` +
+        `)\n`,
+      'Core/Model/User.swift': `public struct User {}\n`,
+      'Clients/App/main.swift': `import Foundation\nimport Domain\nprint(User.self)\n`,
+    });
+
+    const result = runScript(projectRoot, {
+      projectRoot,
+      files: [
+        { path: 'Package.swift', language: 'swift', fileCategory: 'code' },
+        { path: 'Core/Model/User.swift', language: 'swift', fileCategory: 'code' },
+        { path: 'Clients/App/main.swift', language: 'swift', fileCategory: 'code' },
+      ],
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.output.importMap['Clients/App/main.swift']).toEqual([
+      'Core/Model/User.swift',
+    ]);
+    expect(result.output.importMap['Package.swift']).toEqual([]);
+  });
+
+  it('drops Swift SDK imports when no project module matches', () => {
+    projectRoot = setupTree({
+      'Sources/App/View.swift': `import SwiftUI\nimport Foundation\nstruct RootView {}\n`,
+    });
+
+    const result = runScript(projectRoot, {
+      projectRoot,
+      files: [
+        { path: 'Sources/App/View.swift', language: 'swift', fileCategory: 'code' },
+      ],
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.output.importMap['Sources/App/View.swift']).toEqual([]);
+    expect(result.output.stats.totalEdges).toBe(0);
+  });
+});
+
 describe('extract-import-map.mjs — per-file failure resilience', () => {
   let projectRoot;
 

tests/skill/understand/test_scan_project.test.mjs

@@ -123,14 +123,15 @@ describe('scan-project.mjs — language detection', () => {
     expect(byPath(r.output, 'f.cjs').language).toBe('javascript');
   });
 
-  it('maps Python, Go, Rust, Java, Kotlin, C# to their language ids', () => {
+  it('maps Python, Go, Rust, Java, Kotlin, C#, Swift to their language ids', () => {
     projectRoot = setupTree({
       'a.py': 'x = 1\n',
       'b.go': 'package main\n',
       'c.rs': 'fn main() {}\n',
       'd.java': 'class D {}\n',
       'e.kt': 'fun main() {}\n',
       'f.cs': 'class F {}\n',
+      'g.swift': 'struct G {}\n',
     });
     const r = runScript(projectRoot);
     expect(r.status).toBe(0);
@@ -140,6 +141,7 @@ describe('scan-project.mjs — language detection', () => {
     expect(byPath(r.output, 'd.java').language).toBe('java');
     expect(byPath(r.output, 'e.kt').language).toBe('kotlin');
     expect(byPath(r.output, 'f.cs').language).toBe('csharp');
+    expect(byPath(r.output, 'g.swift').language).toBe('swift');
   });
 
   it('maps Ruby, PHP, C, C++ to their language ids', () => {
@@ -241,19 +243,21 @@ describe('scan-project.mjs — category assignment (project-scanner.md Step 4)',
     }
   });
 
-  it('assigns code to TypeScript, JavaScript, Python, Go, Rust source files', () => {
+  it('assigns code to TypeScript, JavaScript, Python, Go, Rust, Swift source files', () => {
     projectRoot = setupTree({
       'src/a.ts': 'export const a = 1;\n',
       'src/b.py': 'def b(): pass\n',
       'src/c.go': 'package main\n',
       'src/d.rs': 'fn main() {}\n',
+      'src/e.swift': 'struct E {}\n',
     });
     const r = runScript(projectRoot);
     expect(r.status).toBe(0);
     expect(byPath(r.output, 'src/a.ts').fileCategory).toBe('code');
     expect(byPath(r.output, 'src/b.py').fileCategory).toBe('code');
     expect(byPath(r.output, 'src/c.go').fileCategory).toBe('code');
     expect(byPath(r.output, 'src/d.rs').fileCategory).toBe('code');
+    expect(byPath(r.output, 'src/e.swift').fileCategory).toBe('code');
   });
 
   it('assigns config to JSON/YAML/TOML/INI/XML', () => {

understand-anything-plugin/packages/core/package.json

@@ -39,6 +39,7 @@
   "dependencies": {
     "@tree-sitter-grammars/tree-sitter-kotlin": "1.1.0",
     "@understand-anything/tree-sitter-dart-wasm": "workspace:*",
+    "@understand-anything/tree-sitter-swift-wasm": "workspace:*",
     "fuse.js": "^7.1.0",
     "ignore": "^7.0.5",
     "tree-sitter-c-sharp": "^0.23.1",

understand-anything-plugin/packages/core/src/__tests__/language-registry.test.ts

@@ -74,6 +74,14 @@ describe("LanguageRegistry", () => {
       expect(registry.getByExtension(".js")?.id).toBe("javascript");
     });
 
+    it("registers Swift with tree-sitter grammar metadata", () => {
+      const registry = LanguageRegistry.createDefault();
+      expect(registry.getById("swift")?.treeSitter).toEqual({
+        wasmPackage: "@understand-anything/tree-sitter-swift-wasm",
+        wasmFile: "tree-sitter-swift.wasm",
+      });
+    });
+
     it("has no duplicate extension mappings across configs", () => {
       const registry = LanguageRegistry.createDefault();
       const all = registry.getAllLanguages();

understand-anything-plugin/packages/core/src/__tests__/plugin-discovery.test.ts

@@ -77,6 +77,10 @@ describe("plugin-discovery", () => {
       expect(DEFAULT_PLUGIN_CONFIG.plugins[0].name).toBe("tree-sitter");
       expect(DEFAULT_PLUGIN_CONFIG.plugins[0].enabled).toBe(true);
     });
+
+    it("includes Swift now that a tree-sitter grammar is available", () => {
+      expect(DEFAULT_PLUGIN_CONFIG.plugins[0].languages).toContain("swift");
+    });
   });
 
   describe("serializePluginConfig", () => {

understand-anything-plugin/packages/core/src/languages/configs/swift.ts

@@ -4,6 +4,10 @@ export const swiftConfig = {
   id: "swift",
   displayName: "Swift",
   extensions: [".swift"],
+  treeSitter: {
+    wasmPackage: "@understand-anything/tree-sitter-swift-wasm",
+    wasmFile: "tree-sitter-swift.wasm",
+  },
   concepts: [
     "optionals",
     "protocols",