# FabWorks.Api Implementation Plan

> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.

**Goal:** Create a standalone ASP.NET Web API (`FabWorks.Api`) that owns all fabrication data — export records, BOM items, cut templates, form programs — so ExportDXF and other tools communicate via HTTP instead of direct database access.

**Architecture:** FabWorks.Api is a minimal ASP.NET Web API targeting net8.0. It uses EF Core with SQL Server (same database ExportDXF already uses). A shared class library (`FabWorks.Core`) holds the entity models and DbContext so both the API and ExportDXF can share the schema during the migration period. CincyLib's press brake models are copied into FabWorks.Core as a net8.0 port (just the PressBrake folder — pure XML parsing, no dependencies). The API exposes RESTful endpoints for export records, BOM items, cut templates, and form programs.

**Tech Stack:** ASP.NET Web API (net8.0), EF Core 8 + SQL Server, CincyLib PressBrake parser (ported to net8.0), xUnit for tests

---

## Project Layout

```
ExportDXF/                          (solution root)
├── ExportDXF.sln                   (add new projects here)
├── ExportDXF/                      (existing WinForms app)
├── FabWorks.Core/                  ← NEW shared library
│   ├── FabWorks.Core.csproj
│   ├── Data/
│   │   └── FabWorksDbContext.cs
│   ├── Models/
│   │   ├── ExportRecord.cs
│   │   ├── BomItem.cs
│   │   ├── CutTemplate.cs
│   │   └── FormProgram.cs          ← NEW entity
│   └── PressBrake/                 ← Ported from CincyLib
│       ├── Program.cs
│       ├── ProgramReader.cs
│       ├── Step.cs
│       ├── ToolSetup.cs
│       ├── SegEntry.cs
│       ├── MatType.cs
│       └── Extensions.cs
├── FabWorks.Api/                   ← NEW web API
│   ├── FabWorks.Api.csproj
│   ├── Program.cs
│   ├── Controllers/
│   │   ├── ExportsController.cs
│   │   ├── BomItemsController.cs
│   │   └── FormProgramsController.cs
│   ├── DTOs/
│   │   ├── CreateExportRequest.cs
│   │   ├── ExportDetailDto.cs
│   │   ├── BomItemDto.cs
│   │   └── FormProgramDto.cs
│   └── Services/
│       └── FormProgramService.cs
└── FabWorks.Tests/                 ← NEW test project
    ├── FabWorks.Tests.csproj
    ├── FormProgramServiceTests.cs
    ├── ExportsControllerTests.cs
    └── PressBrake/
        └── ProgramReaderTests.cs
```

---

## Task 1: Create FabWorks.Core with Shared Models

**Files:**
- Create: `FabWorks.Core/FabWorks.Core.csproj`
- Create: `FabWorks.Core/Models/ExportRecord.cs`
- Create: `FabWorks.Core/Models/BomItem.cs`
- Create: `FabWorks.Core/Models/CutTemplate.cs`
- Create: `FabWorks.Core/Models/FormProgram.cs`
- Create: `FabWorks.Core/Data/FabWorksDbContext.cs`

**Step 1: Create the class library project**

```bash
cd C:\Users\aisaacs\Desktop\Projects\ExportDXF
dotnet new classlib -n FabWorks.Core --framework net8.0
dotnet sln ExportDXF.sln add FabWorks.Core/FabWorks.Core.csproj
```

**Step 2: Add EF Core package to FabWorks.Core**

```bash
cd C:\Users\aisaacs\Desktop\Projects\ExportDXF\FabWorks.Core
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 8.0.11
dotnet add package Microsoft.EntityFrameworkCore.Tools --version 8.0.11
```

**Step 3: Create entity models**

Move/recreate the existing entity models from `ExportDXF/Models/` into `FabWorks.Core/Models/` under namespace `FabWorks.Core.Models`. Keep the exact same schema so the existing database is compatible.

`FabWorks.Core/Models/ExportRecord.cs`:
```csharp
using System;
using System.Collections.Generic;

namespace FabWorks.Core.Models
{
    public class ExportRecord
    {
        public int Id { get; set; }
        public string DrawingNumber { get; set; }
        public string SourceFilePath { get; set; }
        public string OutputFolder { get; set; }
        public DateTime ExportedAt { get; set; }
        public string ExportedBy { get; set; }
        public string PdfContentHash { get; set; }

        public virtual ICollection<BomItem> BomItems { get; set; } = new List<BomItem>();
    }
}
```

`FabWorks.Core/Models/BomItem.cs`:
```csharp
namespace FabWorks.Core.Models
{
    public class BomItem
    {
        public int ID { get; set; }
        public string ItemNo { get; set; } = "";
        public string PartNo { get; set; } = "";
        public int SortOrder { get; set; }
        public int? Qty { get; set; }
        public int? TotalQty { get; set; }
        public string Description { get; set; } = "";
        public string PartName { get; set; } = "";
        public string ConfigurationName { get; set; } = "";
        public string Material { get; set; } = "";

        public int ExportRecordId { get; set; }
        public virtual ExportRecord ExportRecord { get; set; }

        public virtual CutTemplate CutTemplate { get; set; }
        public virtual FormProgram FormProgram { get; set; }
    }
}
```

`FabWorks.Core/Models/CutTemplate.cs`:
```csharp
using System;

namespace FabWorks.Core.Models
{
    public class CutTemplate
    {
        public int Id { get; set; }
        public string DxfFilePath { get; set; } = "";
        public string ContentHash { get; set; }
        public string CutTemplateName { get; set; } = "";

        private double? _thickness;
        public double? Thickness
        {
            get => _thickness;
            set => _thickness = value.HasValue ? Math.Round(value.Value, 8) : null;
        }

        public double? KFactor { get; set; }

        private double? _defaultBendRadius;
        public double? DefaultBendRadius
        {
            get => _defaultBendRadius;
            set => _defaultBendRadius = value.HasValue ? Math.Round(value.Value, 8) : null;
        }

        public int BomItemId { get; set; }
        public virtual BomItem BomItem { get; set; }
    }
}
```

`FabWorks.Core/Models/FormProgram.cs` (NEW):
```csharp
namespace FabWorks.Core.Models
{
    public class FormProgram
    {
        public int Id { get; set; }
        public string ProgramFilePath { get; set; } = "";
        public string ContentHash { get; set; }
        public string ProgramName { get; set; } = "";
        public double? Thickness { get; set; }
        public string MaterialType { get; set; } = "";
        public double? KFactor { get; set; }
        public int BendCount { get; set; }
        public string UpperToolNames { get; set; } = "";
        public string LowerToolNames { get; set; } = "";
        public string SetupNotes { get; set; } = "";

        public int BomItemId { get; set; }
        public virtual BomItem BomItem { get; set; }
    }
}
```

**Step 4: Create FabWorksDbContext**

`FabWorks.Core/Data/FabWorksDbContext.cs`:
```csharp
using FabWorks.Core.Models;
using Microsoft.EntityFrameworkCore;

namespace FabWorks.Core.Data
{
    public class FabWorksDbContext : DbContext
    {
        public DbSet<ExportRecord> ExportRecords { get; set; }
        public DbSet<BomItem> BomItems { get; set; }
        public DbSet<CutTemplate> CutTemplates { get; set; }
        public DbSet<FormProgram> FormPrograms { get; set; }

        public FabWorksDbContext(DbContextOptions<FabWorksDbContext> options) : base(options) { }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            modelBuilder.Entity<ExportRecord>(entity =>
            {
                entity.HasKey(e => e.Id);
                entity.Property(e => e.DrawingNumber).HasMaxLength(100);
                entity.Property(e => e.SourceFilePath).HasMaxLength(500);
                entity.Property(e => e.OutputFolder).HasMaxLength(500);
                entity.Property(e => e.ExportedBy).HasMaxLength(100);
                entity.Property(e => e.PdfContentHash).HasMaxLength(64);

                entity.HasMany(e => e.BomItems)
                      .WithOne(b => b.ExportRecord)
                      .HasForeignKey(b => b.ExportRecordId)
                      .OnDelete(DeleteBehavior.Cascade);
            });

            modelBuilder.Entity<BomItem>(entity =>
            {
                entity.HasKey(e => e.ID);
                entity.Property(e => e.ItemNo).HasMaxLength(50);
                entity.Property(e => e.PartNo).HasMaxLength(100);
                entity.Property(e => e.Description).HasMaxLength(500);
                entity.Property(e => e.PartName).HasMaxLength(200);
                entity.Property(e => e.ConfigurationName).HasMaxLength(100);
                entity.Property(e => e.Material).HasMaxLength(100);

                entity.HasOne(e => e.CutTemplate)
                      .WithOne(ct => ct.BomItem)
                      .HasForeignKey<CutTemplate>(ct => ct.BomItemId)
                      .OnDelete(DeleteBehavior.Cascade);

                entity.HasOne(e => e.FormProgram)
                      .WithOne(fp => fp.BomItem)
                      .HasForeignKey<FormProgram>(fp => fp.BomItemId)
                      .OnDelete(DeleteBehavior.Cascade);
            });

            modelBuilder.Entity<CutTemplate>(entity =>
            {
                entity.HasKey(e => e.Id);
                entity.Property(e => e.DxfFilePath).HasMaxLength(500);
                entity.Property(e => e.CutTemplateName).HasMaxLength(100);
                entity.Property(e => e.ContentHash).HasMaxLength(64);
            });

            modelBuilder.Entity<FormProgram>(entity =>
            {
                entity.HasKey(e => e.Id);
                entity.Property(e => e.ProgramFilePath).HasMaxLength(500);
                entity.Property(e => e.ContentHash).HasMaxLength(64);
                entity.Property(e => e.ProgramName).HasMaxLength(200);
                entity.Property(e => e.MaterialType).HasMaxLength(50);
                entity.Property(e => e.UpperToolNames).HasMaxLength(500);
                entity.Property(e => e.LowerToolNames).HasMaxLength(500);
                entity.Property(e => e.SetupNotes).HasMaxLength(2000);
            });
        }
    }
}
```

**Step 5: Delete auto-generated Class1.cs and build**

```bash
del FabWorks.Core\Class1.cs
dotnet build FabWorks.Core/FabWorks.Core.csproj
```

**Step 6: Commit**

```bash
git add FabWorks.Core/
git commit -m "feat: add FabWorks.Core shared library with entity models and FormProgram"
```

---

## Task 2: Port CincyLib PressBrake Parser into FabWorks.Core

**Files:**
- Create: `FabWorks.Core/PressBrake/Program.cs`
- Create: `FabWorks.Core/PressBrake/ProgramReader.cs`
- Create: `FabWorks.Core/PressBrake/Step.cs`
- Create: `FabWorks.Core/PressBrake/ToolSetup.cs`
- Create: `FabWorks.Core/PressBrake/SegEntry.cs`
- Create: `FabWorks.Core/PressBrake/MatType.cs`
- Create: `FabWorks.Core/PressBrake/Extensions.cs`

**Step 1: Copy CincyLib PressBrake files**

Copy the following files from `C:\Users\aisaacs\Desktop\Projects\CincyLib\CincyLib\PressBrake\` into `FabWorks.Core\PressBrake\`:
- `Program.cs`
- `ProgramReader.cs`
- `Step.cs`
- `ToolSetup.cs`
- `SegEntry.cs`
- `MatType.cs`

Also copy `C:\Users\aisaacs\Desktop\Projects\CincyLib\CincyLib\Extensions.cs` into `FabWorks.Core\PressBrake\Extensions.cs`.

**Step 2: Update namespaces**

Change all `namespace CincyLib.PressBrake` to `namespace FabWorks.Core.PressBrake`.
Change `namespace CincyLib` (in Extensions.cs) to `namespace FabWorks.Core.PressBrake`.

No other code changes needed — these files only use `System`, `System.IO`, `System.Linq`, `System.Xml.Linq`, `System.Collections.Generic`, all available in net8.0.

**Step 3: Build to verify port**

```bash
dotnet build FabWorks.Core/FabWorks.Core.csproj
```

**Step 4: Commit**

```bash
git add FabWorks.Core/PressBrake/
git commit -m "feat: port CincyLib PressBrake parser to FabWorks.Core (net8.0)"
```

---

## Task 3: Create FabWorks.Tests and Validate PressBrake Parser

**Files:**
- Create: `FabWorks.Tests/FabWorks.Tests.csproj`
- Create: `FabWorks.Tests/PressBrake/ProgramReaderTests.cs`
- Create: `FabWorks.Tests/TestData/` (copy a sample .pgm file)

**Step 1: Create test project**

```bash
cd C:\Users\aisaacs\Desktop\Projects\ExportDXF
dotnet new xunit -n FabWorks.Tests --framework net8.0
dotnet sln ExportDXF.sln add FabWorks.Tests/FabWorks.Tests.csproj
cd FabWorks.Tests
dotnet add reference ../FabWorks.Core/FabWorks.Core.csproj
```

**Step 2: Copy test data**

Copy a sample `.pgm` file into `FabWorks.Tests/TestData/sample.pgm`. Use the file from `S:\4980 GMCH Lockport\4980 A05 Degreaser Casing\4980 A05-1 Access door\Forms\4980 A05-1 PT02.pgm`. Add it to the csproj as `<Content Include="TestData\**" CopyToOutputDirectory="PreserveNewest" />`.

**Step 3: Write ProgramReader test**

`FabWorks.Tests/PressBrake/ProgramReaderTests.cs`:
```csharp
using FabWorks.Core.PressBrake;
using Xunit;

namespace FabWorks.Tests.PressBrake
{
    public class ProgramReaderTests
    {
        [Fact]
        public void Load_SamplePgm_ParsesProgramName()
        {
            var pgm = Program.Load("TestData/sample.pgm");
            Assert.False(string.IsNullOrEmpty(pgm.ProgName));
        }

        [Fact]
        public void Load_SamplePgm_ParsesThickness()
        {
            var pgm = Program.Load("TestData/sample.pgm");
            Assert.True(pgm.MatThick > 0);
        }

        [Fact]
        public void Load_SamplePgm_ParsesSteps()
        {
            var pgm = Program.Load("TestData/sample.pgm");
            Assert.NotEmpty(pgm.Steps);
        }

        [Fact]
        public void Load_SamplePgm_ParsesToolSetups()
        {
            var pgm = Program.Load("TestData/sample.pgm");
            Assert.NotEmpty(pgm.UpperToolSets);
            Assert.NotEmpty(pgm.LowerToolSets);
        }

        [Fact]
        public void Load_SamplePgm_ResolvesStepToolReferences()
        {
            var pgm = Program.Load("TestData/sample.pgm");
            var step = pgm.Steps[0];
            Assert.NotNull(step.UpperTool);
            Assert.NotNull(step.LowerTool);
        }
    }
}
```

**Step 4: Run tests**

```bash
dotnet test FabWorks.Tests/FabWorks.Tests.csproj -v normal
```

Expected: All 5 tests PASS.

**Step 5: Commit**

```bash
git add FabWorks.Tests/
git commit -m "test: add ProgramReader tests validating CincyLib port"
```

---

## Task 4: Create FabWorks.Api Project with Exports Endpoint

**Files:**
- Create: `FabWorks.Api/FabWorks.Api.csproj`
- Create: `FabWorks.Api/Program.cs`
- Create: `FabWorks.Api/Controllers/ExportsController.cs`
- Create: `FabWorks.Api/DTOs/CreateExportRequest.cs`
- Create: `FabWorks.Api/DTOs/ExportDetailDto.cs`

**Step 1: Create web API project**

```bash
cd C:\Users\aisaacs\Desktop\Projects\ExportDXF
dotnet new webapi -n FabWorks.Api --framework net8.0 --no-openapi
dotnet sln ExportDXF.sln add FabWorks.Api/FabWorks.Api.csproj
cd FabWorks.Api
dotnet add reference ../FabWorks.Core/FabWorks.Core.csproj
```

**Step 2: Configure Program.cs with EF Core**

`FabWorks.Api/Program.cs`:
```csharp
using FabWorks.Core.Data;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddDbContext<FabWorksDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("FabWorksDb")));

var app = builder.Build();

app.MapControllers();
app.Run();
```

Add connection string to `appsettings.json`:
```json
{
  "ConnectionStrings": {
    "FabWorksDb": "Server=localhost;Database=ExportDxfDb;Trusted_Connection=True;TrustServerCertificate=True;"
  }
}
```

Note: Points at the same `ExportDxfDb` database. Same schema, just adding the FormPrograms table.

**Step 3: Create DTOs**

`FabWorks.Api/DTOs/CreateExportRequest.cs`:
```csharp
namespace FabWorks.Api.DTOs
{
    public class CreateExportRequest
    {
        public string DrawingNumber { get; set; }
        public string SourceFilePath { get; set; }
        public string OutputFolder { get; set; }
    }
}
```

`FabWorks.Api/DTOs/ExportDetailDto.cs`:
```csharp
using System;
using System.Collections.Generic;

namespace FabWorks.Api.DTOs
{
    public class ExportDetailDto
    {
        public int Id { get; set; }
        public string DrawingNumber { get; set; }
        public string SourceFilePath { get; set; }
        public string OutputFolder { get; set; }
        public DateTime ExportedAt { get; set; }
        public string ExportedBy { get; set; }
        public string PdfContentHash { get; set; }
        public List<BomItemDto> BomItems { get; set; } = new();
    }

    public class BomItemDto
    {
        public int ID { get; set; }
        public string ItemNo { get; set; }
        public string PartNo { get; set; }
        public int SortOrder { get; set; }
        public int? Qty { get; set; }
        public int? TotalQty { get; set; }
        public string Description { get; set; }
        public string PartName { get; set; }
        public string ConfigurationName { get; set; }
        public string Material { get; set; }
        public CutTemplateDto CutTemplate { get; set; }
        public FormProgramDto FormProgram { get; set; }
    }

    public class CutTemplateDto
    {
        public int Id { get; set; }
        public string DxfFilePath { get; set; }
        public string ContentHash { get; set; }
        public double? Thickness { get; set; }
        public double? KFactor { get; set; }
        public double? DefaultBendRadius { get; set; }
    }

    public class FormProgramDto
    {
        public int Id { get; set; }
        public string ProgramFilePath { get; set; }
        public string ContentHash { get; set; }
        public string ProgramName { get; set; }
        public double? Thickness { get; set; }
        public string MaterialType { get; set; }
        public double? KFactor { get; set; }
        public int BendCount { get; set; }
        public string UpperToolNames { get; set; }
        public string LowerToolNames { get; set; }
        public string SetupNotes { get; set; }
    }
}
```

**Step 4: Create ExportsController**

`FabWorks.Api/Controllers/ExportsController.cs`:
```csharp
using FabWorks.Api.DTOs;
using FabWorks.Core.Data;
using FabWorks.Core.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace FabWorks.Api.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ExportsController : ControllerBase
    {
        private readonly FabWorksDbContext _db;

        public ExportsController(FabWorksDbContext db)
        {
            _db = db;
        }

        [HttpPost]
        public async Task<ActionResult<ExportDetailDto>> Create(CreateExportRequest request)
        {
            var record = new ExportRecord
            {
                DrawingNumber = request.DrawingNumber,
                SourceFilePath = request.SourceFilePath,
                OutputFolder = request.OutputFolder,
                ExportedAt = DateTime.Now,
                ExportedBy = Environment.UserName
            };

            _db.ExportRecords.Add(record);
            await _db.SaveChangesAsync();

            return CreatedAtAction(nameof(GetById), new { id = record.Id }, MapToDto(record));
        }

        [HttpGet("{id}")]
        public async Task<ActionResult<ExportDetailDto>> GetById(int id)
        {
            var record = await _db.ExportRecords
                .Include(r => r.BomItems).ThenInclude(b => b.CutTemplate)
                .Include(r => r.BomItems).ThenInclude(b => b.FormProgram)
                .FirstOrDefaultAsync(r => r.Id == id);

            if (record == null) return NotFound();
            return MapToDto(record);
        }

        [HttpGet("by-source")]
        public async Task<ActionResult<ExportDetailDto>> GetBySourceFile([FromQuery] string path)
        {
            var record = await _db.ExportRecords
                .Where(r => r.SourceFilePath.ToLower() == path.ToLower()
                         && !string.IsNullOrEmpty(r.DrawingNumber))
                .OrderByDescending(r => r.Id)
                .FirstOrDefaultAsync();

            if (record == null) return NotFound();
            return MapToDto(record);
        }

        [HttpGet("by-drawing")]
        public async Task<ActionResult<List<ExportDetailDto>>> GetByDrawing([FromQuery] string drawingNumber)
        {
            var records = await _db.ExportRecords
                .Include(r => r.BomItems).ThenInclude(b => b.CutTemplate)
                .Include(r => r.BomItems).ThenInclude(b => b.FormProgram)
                .Where(r => r.DrawingNumber == drawingNumber)
                .OrderByDescending(r => r.ExportedAt)
                .ToListAsync();

            return records.Select(MapToDto).ToList();
        }

        [HttpGet("next-item-number")]
        public async Task<ActionResult<string>> GetNextItemNumber([FromQuery] string drawingNumber)
        {
            if (string.IsNullOrEmpty(drawingNumber)) return "1";

            var existingItems = await _db.ExportRecords
                .Where(r => r.DrawingNumber == drawingNumber)
                .SelectMany(r => r.BomItems)
                .Select(b => b.ItemNo)
                .ToListAsync();

            int maxNum = 0;
            foreach (var itemNo in existingItems)
            {
                if (int.TryParse(itemNo, out var num) && num > maxNum)
                    maxNum = num;
            }
            return (maxNum + 1).ToString();
        }

        private static ExportDetailDto MapToDto(ExportRecord r) => new()
        {
            Id = r.Id,
            DrawingNumber = r.DrawingNumber,
            SourceFilePath = r.SourceFilePath,
            OutputFolder = r.OutputFolder,
            ExportedAt = r.ExportedAt,
            ExportedBy = r.ExportedBy,
            PdfContentHash = r.PdfContentHash,
            BomItems = r.BomItems?.Select(b => new BomItemDto
            {
                ID = b.ID,
                ItemNo = b.ItemNo,
                PartNo = b.PartNo,
                SortOrder = b.SortOrder,
                Qty = b.Qty,
                TotalQty = b.TotalQty,
                Description = b.Description,
                PartName = b.PartName,
                ConfigurationName = b.ConfigurationName,
                Material = b.Material,
                CutTemplate = b.CutTemplate == null ? null : new CutTemplateDto
                {
                    Id = b.CutTemplate.Id,
                    DxfFilePath = b.CutTemplate.DxfFilePath,
                    ContentHash = b.CutTemplate.ContentHash,
                    Thickness = b.CutTemplate.Thickness,
                    KFactor = b.CutTemplate.KFactor,
                    DefaultBendRadius = b.CutTemplate.DefaultBendRadius
                },
                FormProgram = b.FormProgram == null ? null : new FormProgramDto
                {
                    Id = b.FormProgram.Id,
                    ProgramFilePath = b.FormProgram.ProgramFilePath,
                    ContentHash = b.FormProgram.ContentHash,
                    ProgramName = b.FormProgram.ProgramName,
                    Thickness = b.FormProgram.Thickness,
                    MaterialType = b.FormProgram.MaterialType,
                    KFactor = b.FormProgram.KFactor,
                    BendCount = b.FormProgram.BendCount,
                    UpperToolNames = b.FormProgram.UpperToolNames,
                    LowerToolNames = b.FormProgram.LowerToolNames,
                    SetupNotes = b.FormProgram.SetupNotes
                }
            }).ToList() ?? new()
        };
    }
}
```

**Step 5: Clean up auto-generated files, build**

Delete the auto-generated `WeatherForecast.cs` and `Controllers/WeatherForecastController.cs` if present.

```bash
dotnet build FabWorks.Api/FabWorks.Api.csproj
```

**Step 6: Commit**

```bash
git add FabWorks.Api/
git commit -m "feat: add FabWorks.Api with ExportsController and DTOs"
```

---

## Task 5: Add BomItems and FormPrograms Controllers

**Files:**
- Create: `FabWorks.Api/Controllers/BomItemsController.cs`
- Create: `FabWorks.Api/Controllers/FormProgramsController.cs`
- Create: `FabWorks.Api/Services/FormProgramService.cs`

**Step 1: Create FormProgramService (wraps CincyLib parser)**

`FabWorks.Api/Services/FormProgramService.cs`:
```csharp
using FabWorks.Core.Models;
using FabWorks.Core.PressBrake;
using System.Security.Cryptography;

namespace FabWorks.Api.Services
{
    public class FormProgramService
    {
        /// <summary>
        /// Parse a .pgm file and return a FormProgram entity with metadata populated.
        /// </summary>
        public FormProgram ParseFromFile(string filePath)
        {
            var pgm = Program.Load(filePath);
            var hash = ComputeFileHash(filePath);

            return new FormProgram
            {
                ProgramFilePath = filePath,
                ContentHash = hash,
                ProgramName = pgm.ProgName ?? "",
                Thickness = pgm.MatThick > 0 ? pgm.MatThick : null,
                MaterialType = pgm.MatType.ToString(),
                KFactor = pgm.KFactor > 0 ? pgm.KFactor : null,
                BendCount = pgm.Steps.Count,
                UpperToolNames = string.Join(", ", pgm.UpperToolSets
                    .Select(t => t.Name).Where(n => !string.IsNullOrEmpty(n)).Distinct()),
                LowerToolNames = string.Join(", ", pgm.LowerToolSets
                    .Select(t => t.Name).Where(n => !string.IsNullOrEmpty(n)).Distinct()),
                SetupNotes = pgm.SetupNotes ?? ""
            };
        }

        private static string ComputeFileHash(string filePath)
        {
            using var sha = SHA256.Create();
            using var stream = File.OpenRead(filePath);
            var bytes = sha.ComputeHash(stream);
            return BitConverter.ToString(bytes).Replace("-", "").ToLowerInvariant();
        }
    }
}
```

**Step 2: Register FormProgramService in DI**

In `FabWorks.Api/Program.cs`, add:
```csharp
builder.Services.AddSingleton<FormProgramService>();
```

**Step 3: Create BomItemsController**

`FabWorks.Api/Controllers/BomItemsController.cs`:
```csharp
using FabWorks.Api.DTOs;
using FabWorks.Core.Data;
using FabWorks.Core.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace FabWorks.Api.Controllers
{
    [ApiController]
    [Route("api/exports/{exportId}/bom-items")]
    public class BomItemsController : ControllerBase
    {
        private readonly FabWorksDbContext _db;

        public BomItemsController(FabWorksDbContext db) => _db = db;

        [HttpGet]
        public async Task<ActionResult<List<BomItemDto>>> GetByExport(int exportId)
        {
            var items = await _db.BomItems
                .Include(b => b.CutTemplate)
                .Include(b => b.FormProgram)
                .Where(b => b.ExportRecordId == exportId)
                .OrderBy(b => b.SortOrder)
                .ToListAsync();

            return items.Select(MapToDto).ToList();
        }

        [HttpPost]
        public async Task<ActionResult<BomItemDto>> Create(int exportId, BomItemDto dto)
        {
            var export = await _db.ExportRecords.FindAsync(exportId);
            if (export == null) return NotFound("Export record not found");

            var item = new BomItem
            {
                ExportRecordId = exportId,
                ItemNo = dto.ItemNo ?? "",
                PartNo = dto.PartNo ?? "",
                SortOrder = dto.SortOrder,
                Qty = dto.Qty,
                TotalQty = dto.TotalQty,
                Description = dto.Description ?? "",
                PartName = dto.PartName ?? "",
                ConfigurationName = dto.ConfigurationName ?? "",
                Material = dto.Material ?? ""
            };

            if (dto.CutTemplate != null)
            {
                item.CutTemplate = new CutTemplate
                {
                    DxfFilePath = dto.CutTemplate.DxfFilePath ?? "",
                    ContentHash = dto.CutTemplate.ContentHash,
                    Thickness = dto.CutTemplate.Thickness,
                    KFactor = dto.CutTemplate.KFactor,
                    DefaultBendRadius = dto.CutTemplate.DefaultBendRadius
                };
            }

            if (dto.FormProgram != null)
            {
                item.FormProgram = new FormProgram
                {
                    ProgramFilePath = dto.FormProgram.ProgramFilePath ?? "",
                    ContentHash = dto.FormProgram.ContentHash,
                    ProgramName = dto.FormProgram.ProgramName ?? "",
                    Thickness = dto.FormProgram.Thickness,
                    MaterialType = dto.FormProgram.MaterialType ?? "",
                    KFactor = dto.FormProgram.KFactor,
                    BendCount = dto.FormProgram.BendCount,
                    UpperToolNames = dto.FormProgram.UpperToolNames ?? "",
                    LowerToolNames = dto.FormProgram.LowerToolNames ?? "",
                    SetupNotes = dto.FormProgram.SetupNotes ?? ""
                };
            }

            _db.BomItems.Add(item);
            await _db.SaveChangesAsync();

            return CreatedAtAction(nameof(GetByExport), new { exportId }, MapToDto(item));
        }

        private static BomItemDto MapToDto(BomItem b) => new()
        {
            ID = b.ID,
            ItemNo = b.ItemNo,
            PartNo = b.PartNo,
            SortOrder = b.SortOrder,
            Qty = b.Qty,
            TotalQty = b.TotalQty,
            Description = b.Description,
            PartName = b.PartName,
            ConfigurationName = b.ConfigurationName,
            Material = b.Material,
            CutTemplate = b.CutTemplate == null ? null : new CutTemplateDto
            {
                Id = b.CutTemplate.Id,
                DxfFilePath = b.CutTemplate.DxfFilePath,
                ContentHash = b.CutTemplate.ContentHash,
                Thickness = b.CutTemplate.Thickness,
                KFactor = b.CutTemplate.KFactor,
                DefaultBendRadius = b.CutTemplate.DefaultBendRadius
            },
            FormProgram = b.FormProgram == null ? null : new FormProgramDto
            {
                Id = b.FormProgram.Id,
                ProgramFilePath = b.FormProgram.ProgramFilePath,
                ContentHash = b.FormProgram.ContentHash,
                ProgramName = b.FormProgram.ProgramName,
                Thickness = b.FormProgram.Thickness,
                MaterialType = b.FormProgram.MaterialType,
                KFactor = b.FormProgram.KFactor,
                BendCount = b.FormProgram.BendCount,
                UpperToolNames = b.FormProgram.UpperToolNames,
                LowerToolNames = b.FormProgram.LowerToolNames,
                SetupNotes = b.FormProgram.SetupNotes
            }
        };
    }
}
```

**Step 4: Create FormProgramsController**

`FabWorks.Api/Controllers/FormProgramsController.cs`:
```csharp
using FabWorks.Api.DTOs;
using FabWorks.Api.Services;
using FabWorks.Core.Data;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace FabWorks.Api.Controllers
{
    [ApiController]
    [Route("api/form-programs")]
    public class FormProgramsController : ControllerBase
    {
        private readonly FabWorksDbContext _db;
        private readonly FormProgramService _formService;

        public FormProgramsController(FabWorksDbContext db, FormProgramService formService)
        {
            _db = db;
            _formService = formService;
        }

        [HttpGet("by-drawing")]
        public async Task<ActionResult<List<FormProgramDto>>> GetByDrawing([FromQuery] string drawingNumber)
        {
            var programs = await _db.FormPrograms
                .Include(fp => fp.BomItem)
                .ThenInclude(b => b.ExportRecord)
                .Where(fp => fp.BomItem.ExportRecord.DrawingNumber == drawingNumber)
                .ToListAsync();

            return programs.Select(fp => new FormProgramDto
            {
                Id = fp.Id,
                ProgramFilePath = fp.ProgramFilePath,
                ContentHash = fp.ContentHash,
                ProgramName = fp.ProgramName,
                Thickness = fp.Thickness,
                MaterialType = fp.MaterialType,
                KFactor = fp.KFactor,
                BendCount = fp.BendCount,
                UpperToolNames = fp.UpperToolNames,
                LowerToolNames = fp.LowerToolNames,
                SetupNotes = fp.SetupNotes
            }).ToList();
        }

        [HttpPost("parse")]
        public ActionResult<FormProgramDto> Parse([FromQuery] string filePath)
        {
            if (!System.IO.File.Exists(filePath))
                return NotFound($"File not found: {filePath}");

            var fp = _formService.ParseFromFile(filePath);
            return new FormProgramDto
            {
                ProgramFilePath = fp.ProgramFilePath,
                ContentHash = fp.ContentHash,
                ProgramName = fp.ProgramName,
                Thickness = fp.Thickness,
                MaterialType = fp.MaterialType,
                KFactor = fp.KFactor,
                BendCount = fp.BendCount,
                UpperToolNames = fp.UpperToolNames,
                LowerToolNames = fp.LowerToolNames,
                SetupNotes = fp.SetupNotes
            };
        }

        [HttpPost("{bomItemId}")]
        public async Task<ActionResult<FormProgramDto>> AttachToItem(int bomItemId, [FromQuery] string filePath)
        {
            var bomItem = await _db.BomItems
                .Include(b => b.FormProgram)
                .FirstOrDefaultAsync(b => b.ID == bomItemId);

            if (bomItem == null) return NotFound("BOM item not found");

            if (!System.IO.File.Exists(filePath))
                return NotFound($"File not found: {filePath}");

            var fp = _formService.ParseFromFile(filePath);
            fp.BomItemId = bomItemId;

            // Replace existing if present
            if (bomItem.FormProgram != null)
                _db.FormPrograms.Remove(bomItem.FormProgram);

            bomItem.FormProgram = fp;
            await _db.SaveChangesAsync();

            return new FormProgramDto
            {
                Id = fp.Id,
                ProgramFilePath = fp.ProgramFilePath,
                ContentHash = fp.ContentHash,
                ProgramName = fp.ProgramName,
                Thickness = fp.Thickness,
                MaterialType = fp.MaterialType,
                KFactor = fp.KFactor,
                BendCount = fp.BendCount,
                UpperToolNames = fp.UpperToolNames,
                LowerToolNames = fp.LowerToolNames,
                SetupNotes = fp.SetupNotes
            };
        }
    }
}
```

**Step 5: Build**

```bash
dotnet build FabWorks.Api/FabWorks.Api.csproj
```

**Step 6: Commit**

```bash
git add FabWorks.Api/
git commit -m "feat: add BomItems and FormPrograms controllers with parse service"
```

---

## Task 6: Add EF Core Migration for FormPrograms Table

**Step 1: Add migration from FabWorks.Api**

```bash
cd C:\Users\aisaacs\Desktop\Projects\ExportDXF\FabWorks.Api
dotnet ef migrations add AddFormPrograms --project ../FabWorks.Core/FabWorks.Core.csproj --startup-project .
```

Note: If the migration tooling complains about the existing tables, we may need a baseline migration. The existing ExportDxfDb already has ExportRecords, BomItems, CutTemplates tables. The migration should only add the FormPrograms table and the FK on BomItems.

**Step 2: Apply migration**

```bash
dotnet ef database update --project ../FabWorks.Core/FabWorks.Core.csproj --startup-project .
```

**Step 3: Commit**

```bash
git add FabWorks.Core/Migrations/
git commit -m "feat: add EF migration for FormPrograms table"
```

---

## Task 7: Add FormProgramService Tests

**Files:**
- Create: `FabWorks.Tests/FormProgramServiceTests.cs`

**Step 1: Write tests**

`FabWorks.Tests/FormProgramServiceTests.cs`:
```csharp
using FabWorks.Api.Services;
using Xunit;

namespace FabWorks.Tests
{
    public class FormProgramServiceTests
    {
        [Fact]
        public void ParseFromFile_SamplePgm_PopulatesProgramName()
        {
            var service = new FormProgramService();
            var fp = service.ParseFromFile("TestData/sample.pgm");
            Assert.False(string.IsNullOrEmpty(fp.ProgramName));
        }

        [Fact]
        public void ParseFromFile_SamplePgm_PopulatesThickness()
        {
            var service = new FormProgramService();
            var fp = service.ParseFromFile("TestData/sample.pgm");
            Assert.NotNull(fp.Thickness);
            Assert.True(fp.Thickness > 0);
        }

        [Fact]
        public void ParseFromFile_SamplePgm_PopulatesBendCount()
        {
            var service = new FormProgramService();
            var fp = service.ParseFromFile("TestData/sample.pgm");
            Assert.True(fp.BendCount > 0);
        }

        [Fact]
        public void ParseFromFile_SamplePgm_PopulatesToolNames()
        {
            var service = new FormProgramService();
            var fp = service.ParseFromFile("TestData/sample.pgm");
            Assert.False(string.IsNullOrEmpty(fp.UpperToolNames));
            Assert.False(string.IsNullOrEmpty(fp.LowerToolNames));
        }

        [Fact]
        public void ParseFromFile_SamplePgm_ComputesContentHash()
        {
            var service = new FormProgramService();
            var fp = service.ParseFromFile("TestData/sample.pgm");
            Assert.NotNull(fp.ContentHash);
            Assert.Equal(64, fp.ContentHash.Length); // SHA256 hex = 64 chars
        }
    }
}
```

**Step 2: Add project reference to FabWorks.Api**

```bash
cd C:\Users\aisaacs\Desktop\Projects\ExportDXF\FabWorks.Tests
dotnet add reference ../FabWorks.Api/FabWorks.Api.csproj
```

**Step 3: Run all tests**

```bash
dotnet test FabWorks.Tests/FabWorks.Tests.csproj -v normal
```

Expected: All 10 tests PASS.

**Step 4: Commit**

```bash
git add FabWorks.Tests/
git commit -m "test: add FormProgramService tests"
```

---

## Task 8: Smoke Test — Run API and Hit Endpoints

**Step 1: Run the API**

```bash
cd C:\Users\aisaacs\Desktop\Projects\ExportDXF\FabWorks.Api
dotnet run
```

**Step 2: Test endpoints with curl/Invoke-WebRequest**

```powershell
# Create export record
Invoke-RestMethod -Uri "http://localhost:5000/api/exports" -Method Post -ContentType "application/json" -Body '{"drawingNumber":"4980 A05-1","sourceFilePath":"C:\\test.slddrw","outputFolder":"C:\\output"}'

# Get by ID
Invoke-RestMethod -Uri "http://localhost:5000/api/exports/1"

# Lookup by source file
Invoke-RestMethod -Uri "http://localhost:5000/api/exports/by-source?path=C:\test.slddrw"

# Parse a .pgm file
Invoke-RestMethod -Uri "http://localhost:5000/api/form-programs/parse?filePath=S:\4980 GMCH Lockport\4980 A05 Degreaser Casing\4980 A05-1 Access door\Forms\4980 A05-1 PT02.pgm"
```

**Step 3: Verify JSON responses look correct**

**Step 4: Commit any fixes needed**

---

## Future Tasks (Not In This Plan)

These are follow-up items after the API is proven out:

1. **Wire ExportDXF to call FabWorks.Api** — Add `IFabWorksClient` interface, replace `_dbContextFactory` usage in `DxfExportService` with HTTP calls
2. **Deploy as Windows Service** — Add `Microsoft.Extensions.Hosting.WindowsServices`, create `deploy.ps1` per deploy script guide
3. **Add Swagger/OpenAPI** — For discoverability
4. **LaserQuote integration** — Point LaserQuote at FabWorks.Api for BOM/material lookups
5. **Batch form program scanner** — Endpoint to scan a directory tree and auto-link .pgm files to BOM items by naming convention