dirsql 0.3.74__tar.gz → 0.3.76__tar.gz

{dirsql-0.3.74 → dirsql-0.3.76}/Cargo.lock

@@ -500,7 +500,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.74"
+version = "0.3.76"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.74 → dirsql-0.3.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.74
+Version: 0.3.76
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index
 Author: Kevin Scott

{dirsql-0.3.74/packages/rust → dirsql-0.3.76}/docs/reference/cli.md

@@ -5,8 +5,8 @@ The `dirsql` binary has three modes:
 | Invocation | Behavior |
 |---|---|
 | `dirsql` (no subcommand) | Start a long-lived HTTP server exposing a SQL view of a directory. See [HTTP API](./http-api.md). |
-| `dirsql query "<sql>"` | Build the index, run one query, print the rows as JSON, exit. No server, no watch. |
-| `dirsql init` | Generate a starter `.dirsql.toml` by running `claude` over a directory. |
+| `dirsql query "<sql>"` | Query the file system as JSON |
+| `dirsql init` | Generate a `.dirsql.toml` |
 
 ## Installation
 
@@ -100,8 +100,7 @@ with a JSON body describing the failure:
 
 ## `dirsql query`
 
-Run one SQL query from the shell — for ad-hoc inspection, scripting, and
-docs verification snippets — without booting the server and `curl`ing it:
+Run a SQL query from the shell:
 
 ```bash
 dirsql query "SELECT basename, size FROM files ORDER BY size DESC LIMIT 5"
@@ -140,34 +139,29 @@ stderr, with exit code `1`.
 
 ## `dirsql init`
 
-Generates a `.dirsql.toml` by running the `claude` CLI over the target
-directory. The generated config contains only filesystem-fact tables
-(`[[table]]` entries whose columns come from [glob captures and virtual
-columns](./columns.md)) — never content-derived columns.
+Writes a starter `.dirsql.toml`:
 
 ```bash
 dirsql init
 ```
 
+You can further tweak this config as needed.
+
 ### Flags
 
 | Flag | Default | Description |
 |---|---|---|
-| `--root <path>` | current directory | Directory to scan. |
-| `--output <path>` | `<root>/.dirsql.toml` | Where to write the generated config. |
+| `--root <path>` | current directory | Directory the default `--output` path is resolved against. |
+| `--output <path>` | `<root>/.dirsql.toml` | Where to write the config. |
 | `--force` | off | Overwrite the output file if it already exists. |
 
 ### Requirements and failure modes
 
-`init` requires `claude` on `PATH`, signed in; there is no separate API key.
 All failures exit `1` with a message on stderr:
 
 | Condition | Behavior |
 |---|---|
-| Output file exists and `--force` not passed | Fails before invoking `claude` (no LLM call is made). |
-| `claude` not found on `PATH` | Fails with a pointer to the Claude Code install docs. |
-| `claude` exits non-zero | Fails with `claude`'s stderr; no partial config is written. |
-| `claude` produces non-UTF-8 output | Fails; nothing is written. |
+| Output file exists and `--force` not passed | Fails; nothing is written. |
+| Output path unwritable (e.g. missing parent directory) | Fails with the underlying I/O error. |
 
-On success, `claude`'s stdout is written verbatim to the output path and
-`init` exits `0`.
+On success, `init` exits `0`.

{dirsql-0.3.74 → dirsql-0.3.76}/packages/python/Cargo.toml

@@ -4,7 +4,7 @@ name = "dirsql-py-ext"
 # pypi/maturin handler can rewrite it via `write-version` before
 # `maturin build`. `pyproject.toml` declares `dynamic = ["version"]`
 # and maturin reads this field. Mirrors `packages/rust/Cargo.toml`.
-version = "0.3.74"
+version = "0.3.76"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.74 → dirsql-0.3.76/packages/python}/docs/reference/cli.md

@@ -5,8 +5,8 @@ The `dirsql` binary has three modes:
 | Invocation | Behavior |
 |---|---|
 | `dirsql` (no subcommand) | Start a long-lived HTTP server exposing a SQL view of a directory. See [HTTP API](./http-api.md). |
-| `dirsql query "<sql>"` | Build the index, run one query, print the rows as JSON, exit. No server, no watch. |
-| `dirsql init` | Generate a starter `.dirsql.toml` by running `claude` over a directory. |
+| `dirsql query "<sql>"` | Query the file system as JSON |
+| `dirsql init` | Generate a `.dirsql.toml` |
 
 ## Installation
 
@@ -100,8 +100,7 @@ with a JSON body describing the failure:
 
 ## `dirsql query`
 
-Run one SQL query from the shell — for ad-hoc inspection, scripting, and
-docs verification snippets — without booting the server and `curl`ing it:
+Run a SQL query from the shell:
 
 ```bash
 dirsql query "SELECT basename, size FROM files ORDER BY size DESC LIMIT 5"
@@ -140,34 +139,29 @@ stderr, with exit code `1`.
 
 ## `dirsql init`
 
-Generates a `.dirsql.toml` by running the `claude` CLI over the target
-directory. The generated config contains only filesystem-fact tables
-(`[[table]]` entries whose columns come from [glob captures and virtual
-columns](./columns.md)) — never content-derived columns.
+Writes a starter `.dirsql.toml`:
 
 ```bash
 dirsql init
 ```
 
+You can further tweak this config as needed.
+
 ### Flags
 
 | Flag | Default | Description |
 |---|---|---|
-| `--root <path>` | current directory | Directory to scan. |
-| `--output <path>` | `<root>/.dirsql.toml` | Where to write the generated config. |
+| `--root <path>` | current directory | Directory the default `--output` path is resolved against. |
+| `--output <path>` | `<root>/.dirsql.toml` | Where to write the config. |
 | `--force` | off | Overwrite the output file if it already exists. |
 
 ### Requirements and failure modes
 
-`init` requires `claude` on `PATH`, signed in; there is no separate API key.
 All failures exit `1` with a message on stderr:
 
 | Condition | Behavior |
 |---|---|
-| Output file exists and `--force` not passed | Fails before invoking `claude` (no LLM call is made). |
-| `claude` not found on `PATH` | Fails with a pointer to the Claude Code install docs. |
-| `claude` exits non-zero | Fails with `claude`'s stderr; no partial config is written. |
-| `claude` produces non-UTF-8 output | Fails; nothing is written. |
+| Output file exists and `--force` not passed | Fails; nothing is written. |
+| Output path unwritable (e.g. missing parent directory) | Fails with the underlying I/O error. |
 
-On success, `claude`'s stdout is written verbatim to the output path and
-`init` exits `0`.
+On success, `init` exits `0`.

{dirsql-0.3.74 → dirsql-0.3.76}/packages/python/e2e-attestation.json

@@ -1,6 +1,6 @@
 {
   "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1783471100,
+  "ran_at": 1783522894,
   "exit_code": 0,
-  "commit": "4722385a3a76526258c52a9ae1759562feba3f7a"
+  "commit": "aff7a746e4dfcd46d9f52f11f5cd7f680f5464ae"
 }

{dirsql-0.3.74/packages/python → dirsql-0.3.76/packages/rust}/docs/reference/cli.md

@@ -5,8 +5,8 @@ The `dirsql` binary has three modes:
 | Invocation | Behavior |
 |---|---|
 | `dirsql` (no subcommand) | Start a long-lived HTTP server exposing a SQL view of a directory. See [HTTP API](./http-api.md). |
-| `dirsql query "<sql>"` | Build the index, run one query, print the rows as JSON, exit. No server, no watch. |
-| `dirsql init` | Generate a starter `.dirsql.toml` by running `claude` over a directory. |
+| `dirsql query "<sql>"` | Query the file system as JSON |
+| `dirsql init` | Generate a `.dirsql.toml` |
 
 ## Installation
 
@@ -100,8 +100,7 @@ with a JSON body describing the failure:
 
 ## `dirsql query`
 
-Run one SQL query from the shell — for ad-hoc inspection, scripting, and
-docs verification snippets — without booting the server and `curl`ing it:
+Run a SQL query from the shell:
 
 ```bash
 dirsql query "SELECT basename, size FROM files ORDER BY size DESC LIMIT 5"
@@ -140,34 +139,29 @@ stderr, with exit code `1`.
 
 ## `dirsql init`
 
-Generates a `.dirsql.toml` by running the `claude` CLI over the target
-directory. The generated config contains only filesystem-fact tables
-(`[[table]]` entries whose columns come from [glob captures and virtual
-columns](./columns.md)) — never content-derived columns.
+Writes a starter `.dirsql.toml`:
 
 ```bash
 dirsql init
 ```
 
+You can further tweak this config as needed.
+
 ### Flags
 
 | Flag | Default | Description |
 |---|---|---|
-| `--root <path>` | current directory | Directory to scan. |
-| `--output <path>` | `<root>/.dirsql.toml` | Where to write the generated config. |
+| `--root <path>` | current directory | Directory the default `--output` path is resolved against. |
+| `--output <path>` | `<root>/.dirsql.toml` | Where to write the config. |
 | `--force` | off | Overwrite the output file if it already exists. |
 
 ### Requirements and failure modes
 
-`init` requires `claude` on `PATH`, signed in; there is no separate API key.
 All failures exit `1` with a message on stderr:
 
 | Condition | Behavior |
 |---|---|
-| Output file exists and `--force` not passed | Fails before invoking `claude` (no LLM call is made). |
-| `claude` not found on `PATH` | Fails with a pointer to the Claude Code install docs. |
-| `claude` exits non-zero | Fails with `claude`'s stderr; no partial config is written. |
-| `claude` produces non-UTF-8 output | Fails; nothing is written. |
+| Output file exists and `--force` not passed | Fails; nothing is written. |
+| Output path unwritable (e.g. missing parent directory) | Fails with the underlying I/O error. |
 
-On success, `claude`'s stdout is written verbatim to the output path and
-`init` exits `0`.
+On success, `init` exits `0`.

{dirsql-0.3.74 → dirsql-0.3.76}/packages/rust/src/bin/dirsql.rs

@@ -2,7 +2,7 @@
 //! - No subcommand: HTTP server documented in `docs/reference/cli.md`.
 //! - `query`: one-shot query over the same pipeline the server uses; see
 //!   `docs/reference/cli.md`.
-//! - `init`: starter `.dirsql.toml` generation; see `docs/reference/cli.md`.
+//! - `init`: writes a fixed starter `.dirsql.toml`; see `docs/reference/cli.md`.
 //!
 //! Only compiled with `--features cli`.
 
@@ -25,8 +25,9 @@ use dirsql::{DirSQL, Extension, Row, Table};
                   directory. Tables are defined by a `.dirsql.toml` config \
                   file; with no config, a default `files` table over every \
                   file in the directory is served. With the `init` \
-                  subcommand, generates a starter `.dirsql.toml` by running \
-                  `claude` over the target directory."
+                  subcommand, writes that same default `files` table as a \
+                  starter `.dirsql.toml` — no target-directory inspection, \
+                  no network, deterministic."
 )]
 struct Cli {
     #[command(subcommand)]
@@ -64,8 +65,8 @@ struct Cli {
 
 #[derive(Debug, Subcommand)]
 enum Command {
-    /// Generate a starter `.dirsql.toml` by running `claude` over the
-    /// target directory.
+    /// Write the fixed starter `.dirsql.toml` — the same default `files`
+    /// table zero-config mode serves. No target-directory inspection.
     Init(InitArgs),
 
     /// Run one SQL query against the indexed directory, print the result
@@ -84,7 +85,9 @@ struct QueryArgs {
 
 #[derive(Debug, Args)]
 struct InitArgs {
-    /// Directory to scan (default: current directory).
+    /// Directory the default `--output` path is resolved against (default:
+    /// current directory). The written config's content does not depend on
+    /// this directory's contents.
     #[arg(long)]
     root: Option<PathBuf>,
 
@@ -162,7 +165,6 @@ fn run_init(args: InitArgs) -> ExitCode {
     let output = args.output.unwrap_or_else(|| root.join(".dirsql.toml"));
 
     let opts = InitOptions {
-        root,
         output,
         force: args.force,
     };
@@ -344,15 +346,16 @@ fn load_default_state(config_path: &Path) -> AppState {
     }
 }
 
-/// The default `files` table used in zero-config mode: glob `**/*` matches
-/// every file under the root at any depth (no ignores), and each row is built
-/// purely from the auto-injected filesystem-fact columns.
+/// The default `files` table used in zero-config mode, parsed from the same
+/// [`dirsql::cli::DEFAULT_CONFIG_TOML`] asset `dirsql init` writes verbatim,
+/// so the two can never drift apart.
 fn default_files_table() -> Table {
+    let config = dirsql::config::load_config_str(dirsql::cli::DEFAULT_CONFIG_TOML)
+        .expect("DEFAULT_CONFIG_TOML must be valid dirsql config TOML");
+    let table_config = &config.tables[0];
     Table::new(
-        "CREATE TABLE files (\
-         path TEXT, basename TEXT, dir TEXT, ext TEXT, \
-         size INTEGER, mtime INTEGER, ctime INTEGER)",
-        "**/*",
+        table_config.ddl.clone(),
+        table_config.glob.clone(),
         |_path| vec![Row::new()],
     )
 }

{dirsql-0.3.74 → dirsql-0.3.76}/packages/rust/src/cli/execute.rs

@@ -217,15 +217,10 @@ async fn run_post_query(pq: &PostQuery, rows: Vec<Value>) -> Result<Value, Query
 mod tests {
     use super::*;
 
-    // The `DirSqlError::Core => BadRequest` arm of `classify_query_error` is
-    // exercised end-to-end at the integration tier by
+    // The `Core => BadRequest` arm is covered end-to-end by
     // `post_query_malformed_sql_returns_400_not_500` in
-    // `tests/cli_integration.rs`, which posts malformed SQL to `/query` and
-    // asserts the 400. Constructing a `Core` value inline would require
-    // importing the first-party `crate::db::DbError`, which the
-    // `testing-conventions` `unit lint` isolation rule forbids (a unit test
-    // may reach only `super::` and pure `std`). The non-Core arm below is
-    // pure -- it builds a `super::DirSqlError::Lock` -- so it stays inline.
+    // `tests/cli_integration.rs` (unit-lint isolation bars constructing a
+    // `Core` value inline). The pure non-Core arm below stays here.
 
     #[test]
     fn classify_non_core_error_is_internal() {

dirsql-0.3.76/packages/rust/src/cli/init.rs

@@ -0,0 +1,93 @@
+//! `dirsql init` — write a fixed starter `.dirsql.toml`. See
+//! `docs/reference/cli.md` for the user-facing contract.
+//!
+//! `init` does not inspect the target directory at all: it writes
+//! [`super::DEFAULT_CONFIG_TOML`] verbatim -- the same single `files` table
+//! [zero-config mode](../bin/dirsql.rs) parses that same asset to build --
+//! so a user always has something loadable to hand-edit, and the two
+//! surfaces can never drift apart. No LLM, no network, no filesystem walk.
+
+use std::path::PathBuf;
+
+use super::DEFAULT_CONFIG_TOML;
+
+#[derive(Debug, thiserror::Error)]
+pub enum InitError {
+    #[error("{}: already exists; pass --force to overwrite", path.display())]
+    AlreadyExists { path: PathBuf },
+
+    #[error("failed to write {}: {source}", path.display())]
+    Write {
+        path: PathBuf,
+        source: std::io::Error,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub struct InitOptions {
+    /// Path the generated config is written to. Resolved by the caller
+    /// (default: `<root>/.dirsql.toml`).
+    pub output: PathBuf,
+    /// Overwrite `output` if it already exists.
+    pub force: bool,
+}
+
+pub fn run(opts: InitOptions) -> Result<(), InitError> {
+    if !opts.force && opts.output.exists() {
+        return Err(InitError::AlreadyExists { path: opts.output });
+    }
+
+    std::fs::write(&opts.output, DEFAULT_CONFIG_TOML.as_bytes()).map_err(|source| {
+        InitError::Write {
+            path: opts.output.clone(),
+            source,
+        }
+    })?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn already_exists_error_mentions_force() {
+        let err = InitError::AlreadyExists {
+            path: PathBuf::from("/tmp/foo.toml"),
+        };
+        let msg = format!("{err}");
+        assert!(msg.contains("already exists"));
+        assert!(msg.contains("--force"));
+    }
+
+    #[test]
+    fn write_error_display_names_the_path_and_source() {
+        let err = InitError::Write {
+            path: PathBuf::from("/tmp/out.toml"),
+            source: std::io::Error::other("disk full"),
+        };
+        let msg = format!("{err}");
+        assert!(msg.contains("/tmp/out.toml"), "got: {msg}");
+        assert!(msg.contains("disk full"), "got: {msg}");
+    }
+
+    /// The temp dir itself serves as the already-existing output path.
+    #[test]
+    fn run_bails_when_output_exists_without_force() {
+        let dir = tempfile::tempdir().unwrap();
+        let opts = InitOptions {
+            output: dir.path().to_path_buf(),
+            force: false,
+        };
+        let err = run(opts).unwrap_err();
+        assert!(
+            matches!(err, InitError::AlreadyExists { .. }),
+            "got: {err:?}"
+        );
+    }
+
+    // The write success + `--force` paths are covered black-box in
+    // `tests/init_integration.rs` (unit-lint isolation keeps effectful
+    // `std::fs` out of here).
+}

{dirsql-0.3.74 → dirsql-0.3.76}/packages/rust/src/cli/mod.rs

@@ -39,6 +39,12 @@ pub mod server;
 
 pub use server::{serve, serve_with_state};
 
+/// The one starter `.dirsql.toml` -- a single `files` table over every file
+/// under the root, built from the seven stat columns. This is both what
+/// `dirsql init` writes verbatim ([`init::run`]) and what zero-config mode
+/// parses to build its default table, so the two can never drift apart.
+pub const DEFAULT_CONFIG_TOML: &str = include_str!("../default_config.toml");
+
 /// A server-wide `pre-query` command hook, carrying the command template plus
 /// the directory it runs in (the config file's parent). When set on a
 /// [`ServerConfig`], the server passes each `POST /query` request body to the
@@ -336,4 +342,7 @@ mod tests {
             AppState::Ready(_) => panic!("String must map to the Unavailable arm"),
         }
     }
+
+    // `DEFAULT_CONFIG_TOML` parsing is covered in `tests/config.rs`
+    // (unit-lint isolation bars calling `config::load_config_str` here).
 }

dirsql-0.3.76/packages/rust/src/default_config.toml

@@ -0,0 +1,3 @@
+[[table]]
+ddl  = "CREATE TABLE files (path TEXT, basename TEXT, dir TEXT, ext TEXT, size INTEGER, mtime INTEGER, ctime INTEGER)"
+glob = "**/*"

dirsql-0.3.74/packages/rust/src/cli/init.rs

@@ -1,207 +0,0 @@
-//! `dirsql init` — generate a starter `.dirsql.toml` by shelling out to
-//! the `claude` CLI. See `docs/reference/cli.md` for the user-facing
-//! contract.
-//!
-//! The agent's only required responsibility is to print a valid
-//! filesystem-fact-only `.dirsql.toml` to stdout. We invoke `claude -p`
-//! with the working directory set to the target root, capture stdout,
-//! and write it verbatim to the configured output path.
-//!
-//! Failure modes:
-//! - Output already exists and `--force` was not passed: bail before
-//!   spawning the agent (never burn a paid LLM call first).
-//! - `claude` is not on PATH: surface a descriptive error pointing at
-//!   the install docs.
-//! - `claude` exits non-zero: surface its stderr; do not write any
-//!   partial config.
-
-use std::path::PathBuf;
-use std::process::Command;
-
-#[derive(Debug, thiserror::Error)]
-pub enum InitError {
-    #[error("{}: already exists; pass --force to overwrite", path.display())]
-    AlreadyExists { path: PathBuf },
-
-    #[error(
-        "`claude` not found on PATH; install Claude Code (https://docs.claude.com/en/docs/claude-code/quickstart)"
-    )]
-    ClaudeNotFound,
-
-    #[error("failed to spawn `claude`: {0}")]
-    Spawn(std::io::Error),
-
-    #[error("`claude` exited with {status}\n{stderr}")]
-    ClaudeFailed {
-        status: std::process::ExitStatus,
-        stderr: String,
-    },
-
-    #[error("`claude` produced non-UTF8 output")]
-    InvalidUtf8(#[from] std::string::FromUtf8Error),
-
-    #[error("failed to write {}: {source}", path.display())]
-    Write {
-        path: PathBuf,
-        source: std::io::Error,
-    },
-}
-
-#[derive(Debug, Clone)]
-pub struct InitOptions {
-    /// Directory to scan. Resolved by the caller (default: cwd).
-    pub root: PathBuf,
-    /// Path the generated config is written to. Resolved by the caller
-    /// (default: `<root>/.dirsql.toml`).
-    pub output: PathBuf,
-    /// Overwrite `output` if it already exists.
-    pub force: bool,
-}
-
-pub fn run(opts: InitOptions) -> Result<(), InitError> {
-    if !opts.force && opts.output.exists() {
-        return Err(InitError::AlreadyExists { path: opts.output });
-    }
-
-    let prompt = build_prompt();
-    let output = Command::new("claude")
-        .arg("-p")
-        .arg(&prompt)
-        .current_dir(&opts.root)
-        .output()
-        .map_err(|err| match err.kind() {
-            std::io::ErrorKind::NotFound => InitError::ClaudeNotFound,
-            _ => InitError::Spawn(err),
-        })?;
-
-    if !output.status.success() {
-        return Err(InitError::ClaudeFailed {
-            status: output.status,
-            stderr: String::from_utf8_lossy(&output.stderr).to_string(),
-        });
-    }
-
-    let toml = String::from_utf8(output.stdout)?;
-    std::fs::write(&opts.output, toml.as_bytes()).map_err(|source| InitError::Write {
-        path: opts.output.clone(),
-        source,
-    })?;
-
-    Ok(())
-}
-
-fn build_prompt() -> String {
-    PROMPT.to_string()
-}
-
-const PROMPT: &str = r#"You are running inside a directory. Your job is to produce a `.dirsql.toml` config file that defines SQL tables over that directory's filesystem.
-
-Inspect the directory structure (files and subdirectories). Then produce a `.dirsql.toml` with one or more `[[table]]` blocks.
-
-Each `[[table]]` block has:
-- `ddl`: a SQLite CREATE TABLE statement.
-- `glob`: a glob pattern matching files relative to the directory root.
-
-Each row is one matched file. Columns come from these sources ONLY:
-- Glob path captures: `{name}` segments in the glob become columns named `name`.
-- Stat virtuals (reserved column names): `path`, `basename`, `dir`, `ext`, `size`, `mtime`, `ctime`.
-
-Do NOT include columns sourced from file content (JSON keys, CSV headers, frontmatter, etc.). Content parsing is not configured in `.dirsql.toml`.
-
-Output ONLY the TOML, with no surrounding prose, no markdown fences, no explanation.
-
-Example for a flat directory of mixed files:
-[[table]]
-ddl  = "CREATE TABLE files (path TEXT, ext TEXT, size INTEGER)"
-glob = "*"
-
-Example with path captures:
-[[table]]
-ddl  = "CREATE TABLE photos (month TEXT, basename TEXT, mtime INTEGER)"
-glob = "{month}/*.jpg"
-"#;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn prompt_mentions_filesystem_fact_constraints() {
-        let p = build_prompt();
-        assert!(p.contains("[[table]]"));
-        assert!(p.contains("path"));
-        assert!(p.contains("Output ONLY the TOML"));
-    }
-
-    #[test]
-    fn already_exists_error_mentions_force() {
-        let err = InitError::AlreadyExists {
-            path: PathBuf::from("/tmp/foo.toml"),
-        };
-        let msg = format!("{err}");
-        assert!(msg.contains("already exists"));
-        assert!(msg.contains("--force"));
-    }
-
-    #[test]
-    fn claude_not_found_error_mentions_claude() {
-        let err = InitError::ClaudeNotFound;
-        let msg = format!("{err}").to_lowercase();
-        assert!(msg.contains("claude"));
-    }
-
-    /// The temp dir itself serves as the already-existing output path.
-    #[test]
-    fn run_bails_when_output_exists_without_force() {
-        let dir = tempfile::tempdir().unwrap();
-        let opts = InitOptions {
-            root: dir.path().to_path_buf(),
-            output: dir.path().to_path_buf(),
-            force: false,
-        };
-        let err = run(opts).unwrap_err();
-        assert!(
-            matches!(err, InitError::AlreadyExists { .. }),
-            "got: {err:?}"
-        );
-    }
-
-    // The spawn / non-zero-exit / write failure arms of `run` need a real
-    // `claude` and filesystem, so they live at the e2e tier; only their pure
-    // `Display` renderings are covered here.
-
-    #[test]
-    fn spawn_error_display_mentions_spawn() {
-        let err = InitError::Spawn(std::io::Error::new(
-            std::io::ErrorKind::PermissionDenied,
-            "denied",
-        ));
-        let msg = format!("{err}");
-        assert!(msg.contains("failed to spawn"), "got: {msg}");
-        assert!(msg.contains("denied"), "got: {msg}");
-    }
-
-    #[test]
-    fn write_error_display_names_the_path_and_source() {
-        let err = InitError::Write {
-            path: PathBuf::from("/tmp/out.toml"),
-            source: std::io::Error::other("disk full"),
-        };
-        let msg = format!("{err}");
-        assert!(msg.contains("/tmp/out.toml"), "got: {msg}");
-        assert!(msg.contains("disk full"), "got: {msg}");
-    }
-
-    #[test]
-    fn invalid_utf8_error_display_mentions_utf8() {
-        let utf8_err = String::from_utf8(vec![0xff, 0xfe]).unwrap_err();
-        let err: InitError = utf8_err.into();
-        let msg = format!("{err}");
-        assert!(msg.contains("non-UTF8"), "got: {msg}");
-    }
-
-    // NOTE: `InitError::ClaudeFailed`'s `Display` is not unit-tested -- building
-    // it needs an `ExitStatus`, and `std::process::ExitStatus::from_raw` is
-    // effectful std the unit-isolation lint (`no-out-of-module-call`) forbids.
-    // Its rendering is covered end-to-end at the e2e tier instead.
-}