fix(csharp): verify --codegen infers the namespace from committed output (avoid spurious drift)

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

Author: dmealing

server/csharp/MetaObjects.Cli.Tests/VerifySubverbTests.cs

@@ -174,6 +174,68 @@ public void Codegen_without_committed_output_is_exit2()
         Assert.NotNull(r.Codegen!.Error);
     }
 
+    // -------------------- the namespace-inference footgun --------------------
+    // gen used a CUSTOM namespace; verify --codegen WITHOUT --namespace must infer
+    // it from the committed output (else every file would spuriously drift on the
+    // embedded `namespace {ns};`). Build the Options with NO explicit namespace.
+
+    /// <summary>Codegen opts with NO explicit namespace (the footgun scenario).</summary>
+    private VerifyCommand.Options CodegenOptsNoNamespace() =>
+        new()
+        {
+            MetadataDir = MetaDir,
+            OutDir = OutDir,
+            Codegen = true,
+            // Namespace intentionally NOT set + NamespaceExplicit defaults to false.
+        };
+
+    [Fact]
+    public void Codegen_infers_custom_namespace_from_committed_output_no_flag()
+    {
+        File.WriteAllText(Path.Combine(MetaDir, "meta.ai.json"), EntityMetadata);
+        // Committed output generated with a CUSTOM namespace.
+        GenCommand.Run(MetaDir, OutDir, "Acme.Generated");
+
+        // verify --codegen WITHOUT --namespace → must infer "Acme.Generated" from the
+        // committed files and produce a byte-identical regen → exit 0 (no spurious drift).
+        var r = VerifyCommand.RunSubverbs(CodegenOptsNoNamespace());
+        Assert.Equal(0, r.ExitCode);
+        Assert.True(r.Codegen!.Clean, string.Join("; ", r.Codegen!.Lines));
+    }
+
+    [Fact]
+    public void Codegen_inference_still_detects_real_drift_with_custom_namespace()
+    {
+        File.WriteAllText(Path.Combine(MetaDir, "meta.ai.json"), EntityMetadata);
+        GenCommand.Run(MetaDir, OutDir, "Acme.Generated");
+        // A real hand-edit on top of the custom namespace must still be drift.
+        File.AppendAllText(Path.Combine(OutDir, "Subscriber.g.cs"), "\n// real drift\n");
+
+        var r = VerifyCommand.RunSubverbs(CodegenOptsNoNamespace());
+        Assert.NotEqual(0, r.ExitCode);
+        Assert.Contains(r.Codegen!.DriftedFiles, f => f.EndsWith("Subscriber.g.cs"));
+    }
+
+    [Fact]
+    public void Codegen_explicit_namespace_still_wins_over_inference()
+    {
+        File.WriteAllText(Path.Combine(MetaDir, "meta.ai.json"), EntityMetadata);
+        GenCommand.Run(MetaDir, OutDir, "Acme.Generated");
+
+        // Explicit namespace set (matching) → wins, byte-identical regen → exit 0.
+        var opts = new VerifyCommand.Options
+        {
+            MetadataDir = MetaDir,
+            OutDir = OutDir,
+            Namespace = "Acme.Generated",
+            NamespaceExplicit = true,
+            Codegen = true,
+        };
+        var r = VerifyCommand.RunSubverbs(opts);
+        Assert.Equal(0, r.ExitCode);
+        Assert.True(r.Codegen!.Clean, string.Join("; ", r.Codegen!.Lines));
+    }
+
     // -------------------- combining flags aggregates exit --------------------
 
     [Fact]

server/csharp/MetaObjects.Cli/Program.cs

@@ -17,10 +17,12 @@
         "        [--generators <a,b,c>] [--template-root <dir>]\n" +
         "                                                     generate EF Core code from metadata\n" +
         "    gen --list                                       list available generators (stable names) and exit\n" +
-        "    verify <metadataDir> [--templates <root>] [--codegen --out <dir>] [--db]\n" +
+        "    verify <metadataDir> [--templates <root>] [--codegen --out <dir> [--namespace <ns>]] [--db]\n" +
         "                                                     drift gates (ADR-0021 D2 subverbs):\n" +
         "                                                       --templates  template/prompt drift (default)\n" +
         "                                                       --codegen    regen-to-temp vs committed --out\n" +
+        "                                                       --namespace  codegen regen namespace; inferred\n" +
+        "                                                                    from the committed --out when omitted\n" +
         "                                                       --db         NOT supported in C# (migrate engine)");
     return 2;
 }
@@ -99,6 +101,7 @@ static int RunVerify(string[] rest)
     string? templatesRoot = null;
     string? outDir = null;
     string ns = "Generated";
+    bool nsExplicit = false;
     string? generatorsCsv = null;
     string? templateRoot = null;
     bool templates = false, codegen = false, db = false;
@@ -115,13 +118,13 @@ static int RunVerify(string[] rest)
         else if (a == "--codegen") codegen = true;
         else if (a == "--db") db = true;
         else if (a == "--out" && i + 1 < rest.Length) outDir = rest[++i];
-        else if (a == "--namespace" && i + 1 < rest.Length) ns = rest[++i];
+        else if (a == "--namespace" && i + 1 < rest.Length) { ns = rest[++i]; nsExplicit = true; }
         else if (a == "--generators" && i + 1 < rest.Length) generatorsCsv = rest[++i];
         else if (a == "--template-root" && i + 1 < rest.Length) templateRoot = rest[++i];
         else if (a.StartsWith('-'))
         {
             Console.Error.WriteLine($"dotnet meta verify: unknown option \"{a}\"");
-            Console.Error.WriteLine("usage: dotnet meta verify <metadataDir> [--templates <root>] [--codegen --out <dir>] [--db]");
+            Console.Error.WriteLine("usage: dotnet meta verify <metadataDir> [--templates <root>] [--codegen --out <dir> [--namespace <ns>]] [--db]");
             return 2;
         }
         else if (metadataDir is null) metadataDir = a;
@@ -133,7 +136,7 @@ static int RunVerify(string[] rest)
 
     if (metadataDir is null)
     {
-        Console.Error.WriteLine("usage: dotnet meta verify <metadataDir> [--templates <root>] [--codegen --out <dir>] [--db]");
+        Console.Error.WriteLine("usage: dotnet meta verify <metadataDir> [--templates <root>] [--codegen --out <dir> [--namespace <ns>]] [--db]");
         return 2;
     }
 
@@ -143,7 +146,8 @@ static int RunVerify(string[] rest)
     if (wantsTemplates && templatesRoot is null)
     {
         Console.Error.WriteLine("usage: dotnet meta verify <metadataDir> --templates <templatesRoot>");
-        Console.Error.WriteLine("  (the templates gate is the default; pass --codegen --out <dir> for codegen drift)");
+        Console.Error.WriteLine("  (the templates gate is the default; pass --codegen --out <dir> for codegen drift —");
+        Console.Error.WriteLine("   --namespace is inferred from the committed output when omitted)");
         return 2;
     }
 
@@ -156,6 +160,7 @@ static int RunVerify(string[] rest)
         TemplatesRoot = templatesRoot,
         OutDir = outDir,
         Namespace = ns,
+        NamespaceExplicit = nsExplicit,
         Generators = generators,
         TemplateRoot = templateRoot,
         Templates = templates,

server/csharp/MetaObjects.Cli/VerifyCommand.cs

@@ -74,6 +74,10 @@ public sealed record Options
         public string? OutDir { get; init; }
         /// <summary>Code-gen namespace (only affects the temp regen; default mirrors `gen`).</summary>
         public string Namespace { get; init; } = "Generated";
+        /// <summary>True when the user explicitly passed <c>--namespace</c>. When false and
+        /// <c>--codegen</c> runs, the namespace is inferred from the committed output so a
+        /// regen matches output generated with any namespace (avoids spurious drift).</summary>
+        public bool NamespaceExplicit { get; init; }
         /// <summary>Optional generator selection for the <c>--codegen</c> regen (else the default suite).</summary>
         public IReadOnlyList<string>? Generators { get; init; }
         /// <summary>Template root for render-helper/template generators in the codegen regen.</summary>
@@ -199,7 +203,16 @@ private static Codegen.CodegenDrift.Result RunCodegenDrift(Options opts)
             return new Codegen.CodegenDrift.Result { Clean = false, Error = $"verify --codegen: {ex.Message}" };
         }
 
-        var config = new GenConfig { OutDir = opts.OutDir, Namespace = opts.Namespace };
+        // The C# namespace is embedded in every generated file (`namespace {ns};`).
+        // If the user did NOT pass --namespace, infer it from the committed output so
+        // the regen matches output produced with any namespace (otherwise every file
+        // would spuriously drift). An explicit --namespace always wins (back-compat /
+        // override); inference falling back to null leaves the default in place.
+        var ns = opts.Namespace;
+        if (!opts.NamespaceExplicit)
+            ns = Codegen.CodegenDrift.InferNamespace(opts.OutDir) ?? opts.Namespace;
+
+        var config = new GenConfig { OutDir = opts.OutDir, Namespace = ns };
         return Codegen.CodegenDrift.Compute(config, load.Root, generators);
     }
 

server/csharp/MetaObjects.Codegen.Tests/CodegenDriftTests.cs

@@ -138,6 +138,48 @@ public void Drift_run_never_writes_to_the_real_out_dir()
         Assert.NotEqual(before, afterMutation);
     }
 
+    // -------------------- namespace inference from committed output ----------
+
+    [Fact]
+    public void InferNamespace_reads_file_scoped_namespace()
+    {
+        Gen(); // writes files with `namespace Acme.Generated;`
+        Assert.Equal("Acme.Generated", CodegenDrift.InferNamespace(OutDir));
+    }
+
+    [Fact]
+    public void InferNamespace_reads_block_scoped_namespace()
+    {
+        Directory.CreateDirectory(OutDir);
+        File.WriteAllText(Path.Combine(OutDir, "Block.g.cs"),
+            "// <auto-generated/>\nnamespace Acme.Block\n{\n    public class Foo { }\n}\n");
+        Assert.Equal("Acme.Block", CodegenDrift.InferNamespace(OutDir));
+    }
+
+    [Fact]
+    public void InferNamespace_picks_the_first_sorted_file()
+    {
+        Directory.CreateDirectory(OutDir);
+        File.WriteAllText(Path.Combine(OutDir, "Zeta.g.cs"), "namespace Zeta.Ns;\n");
+        File.WriteAllText(Path.Combine(OutDir, "Alpha.g.cs"), "namespace Alpha.Ns;\n");
+        Assert.Equal("Alpha.Ns", CodegenDrift.InferNamespace(OutDir));
+    }
+
+    [Fact]
+    public void InferNamespace_returns_null_for_missing_dir()
+    {
+        Assert.Null(CodegenDrift.InferNamespace(Path.Combine(_tmp, "does-not-exist")));
+    }
+
+    [Fact]
+    public void InferNamespace_returns_null_when_no_cs_has_a_namespace()
+    {
+        Directory.CreateDirectory(OutDir);
+        File.WriteAllText(Path.Combine(OutDir, "NoNs.g.cs"), "// top-level statements only\nvar x = 1;\n");
+        File.WriteAllText(Path.Combine(OutDir, "notes.txt"), "namespace NotCSharp;\n");
+        Assert.Null(CodegenDrift.InferNamespace(OutDir));
+    }
+
     private static Dictionary<string, string> SnapshotDir(string dir)
     {
         var snap = new Dictionary<string, string>(StringComparer.Ordinal);

server/csharp/MetaObjects.Codegen/CodegenDrift.cs

@@ -11,13 +11,49 @@
 // SAFETY: the regen is written ONLY under a fresh temp dir; the real OutDir is
 // read but never written. On any outcome the temp tree is removed.
 
+using System.Text.RegularExpressions;
 using MetaObjects.Meta;
 
 namespace MetaObjects.Codegen;
 
 /// <summary>Regenerate-to-temp + diff vs committed output (ADR-0021 D2).</summary>
 public static class CodegenDrift
 {
+    // Matches the FIRST top-level namespace declaration in a C# source file:
+    // file-scoped `namespace X.Y;` or block `namespace X.Y {` / `namespace X.Y`.
+    // Multiline so `^` anchors each line; we scan line-leading declarations only.
+    private static readonly Regex NamespaceDecl =
+        new(@"^\s*namespace\s+([A-Za-z_][\w.]*)\s*;?", RegexOptions.Multiline | RegexOptions.Compiled);
+
+    /// <summary>
+    /// Infer the C# namespace embedded in the committed generated output under
+    /// <paramref name="outDir"/>. Scans the FIRST <c>.cs</c> file (ordinal-sorted)
+    /// that carries a top-level <c>namespace</c> declaration and returns it.
+    /// Returns <c>null</c> when the dir is missing or no <c>.cs</c> file declares a
+    /// namespace — the caller then falls back to its default (there is nothing
+    /// meaningful to diff against in that case anyway). Used by
+    /// <c>verify --codegen</c> so a regen matches output produced with ANY namespace
+    /// when <c>--namespace</c> is omitted.
+    /// </summary>
+    public static string? InferNamespace(string outDir)
+    {
+        if (!Directory.Exists(outDir)) return null;
+
+        var csFiles = Directory.EnumerateFiles(outDir, "*.cs", SearchOption.AllDirectories)
+            .OrderBy(p => p.Replace(Path.DirectorySeparatorChar, '/'), StringComparer.Ordinal);
+
+        foreach (var file in csFiles)
+        {
+            string text;
+            try { text = File.ReadAllText(file); }
+            catch { continue; }
+
+            var m = NamespaceDecl.Match(text);
+            if (m.Success) return m.Groups[1].Value;
+        }
+        return null;
+    }
+
     /// <summary>The outcome of a codegen-drift computation (pure; no console I/O).</summary>
     public sealed record Result
     {