feat: native swift profile (ships as 0.7.0) (#28)

* feat(profile): add native swift profile; release 0.7.0

Adds a first-class `swift` profile alongside rust/typescript/python/generic.

- ProfileKind::Swift wired through parse/name/for_kind and every exhaustive
  match (detect, scaffold, guards, signals).
- src/profile/swift.rs: SwiftPM defaults (swift build/test, coverage via
  --enable-code-coverage), .swift sources, language-agnostic signals with a
  Swift fragility pattern (try!/as!/fatalError/unsafelyUnwrapped), and the
  no-print-in-lib + deps-justified guards.
- detect.rs: Package.swift -> SwiftPM (Sources/* domains); *.xcodeproj /
  *.xcworkspace -> Xcode-flavored with an xcodebuild note.
- CI is now runner-aware: generated ci.yml runs on macos-latest for swift
  (Xcode/Swift preinstalled, no toolchain step); other profiles stay on
  ubuntu-latest. meta-check/arch stay on Linux (grep-only).
- deps-justified understands SwiftPM: extracts .package(url:) names from
  Package.swift.
- Tests across profile/detect/scaffold/guards + a swift init integration test.

Bumps to 0.7.0 to ship the new profile.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(swift): recognize SwiftPM test paths; harden swift_deps + fragility

Addresses adversarial review findings on the new swift profile:
- is_test_path now recognizes SwiftPM/XCTest conventions (capital-T `Tests/`
  dir, `<Name>Tests.swift`), so Swift test files are excluded from guards and
  arch signals — no more false no-print-in-lib failures under `check --strict`
  or bogus fragility tickets on `try!` in test setup.
- swift_deps skips whole-line `//` comments so a commented-out `.package(url:)`
  isn't counted as a declared dependency.
- Swift fragility signal also flags preconditionFailure( / assertionFailure(.

Tests: is_test_path swift cases, a no-print-in-lib Tests/ exclusion test, and a
commented-dep case in the swift deps test.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: tizz98

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "ai-meta"
-version = "0.6.0"
+version = "0.7.0"
 edition = "2021"
 rust-version = "1.80"
 description = "The LLM's missing meta framework — one versioned CLI that scaffolds, lints, and syncs project tooling across repos."

Cargo.toml

@@ -47,7 +47,7 @@ then use `./meta <cmd>` in PowerShell or `.\meta <cmd>` in cmd.exe. The generate
 - **`meta init`** — scaffold `.meta/meta.toml`, the `./meta` shim, GitHub Actions
   workflows, `CLAUDE.md` (with a managed block), `.claude/skills/meta-*`, and
   `META.md`. Auto-detects the language **profile** (rust / typescript / python /
-  generic) and infers build/test/lint commands + domains from the repo. Uses the
+  swift / generic) and infers build/test/lint commands + domains from the repo. Uses the
   `claude` CLI to tailor wording when available (deterministic fallback otherwise).
 - **`meta check` / `meta arch`** — a data-driven rule engine (guards + advisory
   architecture signals) with per-profile defaults, tunable thresholds, and custom

README.md

@@ -7,7 +7,7 @@ on:
 
 jobs:
   ci:
-    runs-on: ubuntu-latest
+    runs-on: {{runs_on}}
     steps:
       - uses: actions/checkout@v4
 {{toolchain_setup}}{{extra_steps}}      - name: Local CI gate

src/assets/workflows/ci.yml

@@ -43,6 +43,10 @@ pub fn detect(root: &Path) -> Detection {
         det.kind = Some(ProfileKind::Rust);
         det.markers.push("Cargo.toml".into());
         infer_rust(root, &mut det);
+    } else if let Some(marker) = swift_marker(root) {
+        det.kind = Some(ProfileKind::Swift);
+        det.markers.push(marker.clone());
+        infer_swift(root, &marker, &mut det);
     } else if has("package.json") {
         det.kind = Some(ProfileKind::TypeScript);
         det.markers.push("package.json".into());
@@ -104,6 +108,37 @@ fn infer_rust(root: &Path, det: &mut Detection) {
     }
 }
 
+/// The Swift marker present at `root`, if any: a SwiftPM `Package.swift` (checked
+/// first), else an Xcode `*.xcodeproj` / `*.xcworkspace` bundle.
+fn swift_marker(root: &Path) -> Option<String> {
+    if root.join("Package.swift").exists() {
+        return Some("Package.swift".into());
+    }
+    for e in std::fs::read_dir(root).ok()?.flatten() {
+        let name = e.file_name().to_string_lossy().to_string();
+        if name.ends_with(".xcodeproj") || name.ends_with(".xcworkspace") {
+            return Some(name);
+        }
+    }
+    None
+}
+
+fn infer_swift(root: &Path, marker: &str, det: &mut Detection) {
+    // SwiftPM's `swift build` / `swift test` are already the profile defaults, so
+    // (like a Rust workspace) we don't restate them. An Xcode project needs a
+    // custom `xcodebuild` invocation we can't infer — leave a note instead.
+    if marker != "Package.swift" {
+        det.notes.push(format!(
+            "Xcode project ({marker}); set [commands] build/test to your xcodebuild invocation"
+        ));
+    }
+    // Swift targets live under Sources/ (SwiftPM); fall back to top-level dirs.
+    det.domains = child_dirs(&root.join("Sources"), &[]);
+    if det.domains.is_empty() {
+        det.domains = child_dirs(root, &["Tests"]);
+    }
+}
+
 fn infer_typescript(root: &Path, det: &mut Detection) {
     let pkg = std::fs::read_to_string(root.join("package.json")).unwrap_or_default();
     let scripts = json_scripts(&pkg);
@@ -267,6 +302,33 @@ mod tests {
         assert_eq!(d.commands.test.as_deref(), Some("cargo test"));
     }
 
+    #[test]
+    fn detects_swift_package() {
+        let tmp = tempdir().unwrap();
+        fs::write(
+            tmp.path().join("Package.swift"),
+            "// swift-tools-version:5.9\nimport PackageDescription\n",
+        )
+        .unwrap();
+        fs::create_dir_all(tmp.path().join("Sources").join("App")).unwrap();
+        fs::create_dir_all(tmp.path().join("Sources").join("Core")).unwrap();
+        let d = detect(tmp.path());
+        assert_eq!(d.kind, Some(ProfileKind::Swift));
+        assert_eq!(d.markers, vec!["Package.swift".to_string()]);
+        // SwiftPM commands equal the profile default, so they're not restated.
+        assert!(d.commands.build.is_none());
+        assert_eq!(d.domains, vec!["App", "Core"]);
+    }
+
+    #[test]
+    fn detects_swift_xcode_project() {
+        let tmp = tempdir().unwrap();
+        fs::create_dir_all(tmp.path().join("MyApp.xcodeproj")).unwrap();
+        let d = detect(tmp.path());
+        assert_eq!(d.kind, Some(ProfileKind::Swift));
+        assert!(d.notes.iter().any(|n| n.contains("xcodebuild")));
+    }
+
     #[test]
     fn detects_typescript_and_infers_scripts() {
         let tmp = tempdir().unwrap();

src/detect.rs

@@ -6,6 +6,7 @@
 
 pub mod python;
 pub mod rust;
+pub mod swift;
 pub mod typescript;
 
 use crate::error::{Error, Result};
@@ -18,6 +19,7 @@ pub enum ProfileKind {
     Rust,
     TypeScript,
     Python,
+    Swift,
     Generic,
 }
 
@@ -27,6 +29,7 @@ impl ProfileKind {
             ProfileKind::Rust => "rust",
             ProfileKind::TypeScript => "typescript",
             ProfileKind::Python => "python",
+            ProfileKind::Swift => "swift",
             ProfileKind::Generic => "generic",
         }
     }
@@ -36,6 +39,7 @@ impl ProfileKind {
             "rust" => Ok(ProfileKind::Rust),
             "typescript" | "ts" | "javascript" | "js" => Ok(ProfileKind::TypeScript),
             "python" | "py" => Ok(ProfileKind::Python),
+            "swift" | "swiftpm" => Ok(ProfileKind::Swift),
             "generic" => Ok(ProfileKind::Generic),
             other => Err(Error::UnknownProfile(other.to_string())),
         }
@@ -99,6 +103,7 @@ impl Profile {
             ProfileKind::Rust => rust::profile(),
             ProfileKind::TypeScript => typescript::profile(),
             ProfileKind::Python => python::profile(),
+            ProfileKind::Swift => swift::profile(),
             ProfileKind::Generic => generic(),
         }
     }
@@ -173,6 +178,8 @@ mod tests {
         assert_eq!(ProfileKind::parse("ts").unwrap(), ProfileKind::TypeScript);
         assert_eq!(ProfileKind::parse("PY").unwrap(), ProfileKind::Python);
         assert_eq!(ProfileKind::parse("Rust").unwrap(), ProfileKind::Rust);
+        assert_eq!(ProfileKind::parse("Swift").unwrap(), ProfileKind::Swift);
+        assert_eq!(ProfileKind::parse("swiftpm").unwrap(), ProfileKind::Swift);
         assert!(ProfileKind::parse("cobol").is_err());
     }
 
@@ -182,6 +189,7 @@ mod tests {
             ProfileKind::Rust,
             ProfileKind::TypeScript,
             ProfileKind::Python,
+            ProfileKind::Swift,
             ProfileKind::Generic,
         ] {
             let p = Profile::for_kind(k);

src/profile/mod.rs

@@ -0,0 +1,53 @@
+//! The `swift` profile — SwiftPM defaults (`swift build`/`swift test`) for a
+//! Swift package or macOS/iOS app. Generated CI runs on a macOS runner (Xcode
+//! and the Swift toolchain are preinstalled there), so no toolchain-setup step
+//! is emitted. Xcode-project repos override the SwiftPM commands in meta.toml.
+
+use super::{
+    default_label_colors, default_statuses, default_types, Commands, CoverageTool, Profile,
+    ProfileKind, VersionLocation,
+};
+use crate::rules::model::{GuardId, Severity, SignalId, Thresholds};
+
+pub fn profile() -> Profile {
+    Profile {
+        kind: ProfileKind::Swift,
+        commands: Commands {
+            build: Some("swift build".into()),
+            test: Some("swift test".into()),
+            // `swift format` / SwiftLint aren't guaranteed to be installed, so
+            // the profile leaves fmt/lint unset; a repo opts in via meta.toml.
+            fmt: None,
+            lint: None,
+            typecheck: None,
+            coverage: Some("swift test --enable-code-coverage".into()),
+        },
+        // No in-engine coverage parser for Swift yet; the command is still handy
+        // for `meta test --coverage`, but coverage isn't gated.
+        coverage_tool: CoverageTool::None,
+        coverage_min: 0,
+        coverage_summary: None,
+        statuses: default_statuses(),
+        types: default_types(),
+        guards: vec![
+            (GuardId::NoPrintInLib, Severity::Warn),
+            (GuardId::DepsJustified, Severity::Warn),
+        ],
+        signals: vec![
+            SignalId::OversizedFiles,
+            SignalId::Fragility,
+            SignalId::DeepNesting,
+            SignalId::DebtMarkers,
+        ],
+        thresholds: Thresholds::default(),
+        // Swift has no canonical in-repo version file; default to a plain VERSION
+        // file (like the generic profile). Projects point `meta tag` elsewhere
+        // (e.g. an Xcode MARKETING_VERSION) via `[[version.locations]]`.
+        version_location: VersionLocation {
+            path: "VERSION".into(),
+            anchor: "^".into(),
+        },
+        source_exts: vec!["swift".into()],
+        label_colors: default_label_colors(),
+    }
+}

src/profile/swift.rs

@@ -41,16 +41,21 @@ impl Hit {
 /// Whether `path` (relative to a scan root) is a test/bench/declaration file
 /// that guards exclude. `exts` are the language source extensions.
 pub fn is_test_path(rel: &str, exts: &[String]) -> bool {
-    if rel.contains("/tests/") || rel.starts_with("tests/") || rel.contains("/benches/") {
+    if rel.contains("/tests/")
+        || rel.starts_with("tests/")
+        || rel.contains("/Tests/")
+        || rel.starts_with("Tests/")
+        || rel.contains("/benches/")
+    {
         return true;
     }
     if rel.ends_with(".d.ts") {
         return true;
     }
-    // `_test.<ext>` (rust/go style) and `.test.`/`.spec.` (js/ts) and python
-    // `test_*.py` / `*_test.py`.
+    // `_test.<ext>` (rust/go style), `<Name>Tests.<ext>` (SwiftPM/XCTest style),
+    // `.test.`/`.spec.` (js/ts), and python `test_*.py` / `*_test.py`.
     for e in exts {
-        if rel.ends_with(&format!("_test.{e}")) {
+        if rel.ends_with(&format!("_test.{e}")) || rel.ends_with(&format!("Tests.{e}")) {
             return true;
         }
     }
@@ -151,15 +156,20 @@ mod tests {
 
     #[test]
     fn test_path_detection() {
-        let exts = vec!["rs".into(), "ts".into(), "py".into()];
+        let exts = vec!["rs".into(), "ts".into(), "py".into(), "swift".into()];
         assert!(is_test_path("crate/tests/it.rs", &exts));
         assert!(is_test_path("src/foo_test.rs", &exts));
         assert!(is_test_path("src/foo.test.ts", &exts));
         assert!(is_test_path("src/foo.spec.ts", &exts));
         assert!(is_test_path("pkg/test_foo.py", &exts));
         assert!(is_test_path("types/x.d.ts", &exts));
+        // SwiftPM/XCTest conventions: a capital-T `Tests/` dir and `<Name>Tests.swift`.
+        assert!(is_test_path("Tests/AppTests/AppTests.swift", &exts));
+        assert!(is_test_path("MyLibTests.swift", &exts));
         assert!(!is_test_path("src/foo.rs", &exts));
         assert!(!is_test_path("src/testing.rs", &exts));
+        // Product Swift files that merely end in "…ests.swift" are not tests.
+        assert!(!is_test_path("Sources/App/Requests.swift", &exts));
     }
 
     #[test]

src/rules/grep.rs

@@ -261,6 +261,7 @@ fn deps_justified(ctx: &GuardCtx) -> GuardResult {
         ProfileKind::Rust => rust_deps(ctx.root),
         ProfileKind::TypeScript => ts_deps(ctx.root),
         ProfileKind::Python => py_deps(ctx.root),
+        ProfileKind::Swift => swift_deps(ctx.root),
         ProfileKind::Generic => return GuardResult::Skip("no dependency model for generic".into()),
     };
     let declared = match declared {
@@ -415,6 +416,42 @@ fn py_name(spec: &str) -> String {
         .to_string()
 }
 
+/// Package dependencies from a SwiftPM `Package.swift`, each identified by the
+/// repo name in its `.package(url: "…")` entry (last path segment, sans `.git`).
+/// Local `.package(path: …)` entries have no URL and are treated as internal.
+fn swift_deps(root: &Path) -> Option<Vec<(String, String)>> {
+    let path = root.join("Package.swift");
+    if !path.is_file() {
+        return None;
+    }
+    // Drop whole-line `//` comments so a commented-out dependency isn't counted
+    // (line-by-line, like rust_deps — multi-line non-commented calls survive).
+    let src = grep::read(&path);
+    let text = src
+        .lines()
+        .filter(|l| !l.trim_start().starts_with("//"))
+        .collect::<Vec<_>>()
+        .join("\n");
+    let re = compile(r#"\.package\(\s*(?:name:\s*"[^"]*"\s*,\s*)?url:\s*"([^"]+)""#);
+    let mut out = Vec::new();
+    for caps in re.captures_iter(&text) {
+        let url = caps.get(1).map(|m| m.as_str()).unwrap_or("");
+        let name = url
+            .trim_end_matches('/')
+            .rsplit('/')
+            .next()
+            .unwrap_or(url)
+            .trim_end_matches(".git")
+            .to_string();
+        if !name.is_empty() {
+            out.push(("Package.swift".to_string(), name));
+        }
+    }
+    out.sort();
+    out.dedup();
+    Some(out)
+}
+
 // --- shared helpers ----------------------------------------------------------
 
 fn scan(