mirror of
https://github.com/ajisaacs/OpenNest.git
synced 2026-11-19 15:07:40 -05:00
feat(mcp): nest server tools for sets, Make Nests and re-nesting
Releasing element-rack jobs from an agent meant hand-writing a console runner around SetReleaseSession, posting set JSON by hand (opaque "Invalid set JSON." and 428 without If-Match) and re-nesting by hand when the 60x120 default wasted sheets. The MCP server now does it through the desktop's own clients and release session: - search_drawings, get_drawing, search_sets, get_set - create_set, update_set, archive_set, restore_set (revision guard handled) - plan_release: material groups, refusals and mergeable drafts, read-only - make_nests: SetReleaseSession with headless ReleaseRenest, File > New nests from NewNestSource (server-allocated names), MaterialLedger when set up, optional merges into drafts - renest_nest: re-nest a Draft/Quote nest, saved with the expected-revision guard only when every part is placed - nest_summary, get_release, undo_release make_nests and renest_nest take candidate sheet sizes: each alone and all together as plate options are tried on copies, keeping the fewest unplaced, then fewest sheets, then least sheet area, because the engine's own stock choice minimizes area, not sheet count. Tests run the tools against the in-process server; docs in docs/mcp-nest-server-tools.md. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
68cd070399
commit
a171b6a0de
11 files changed
+1597
No files matched your search
@@ -85,4 +85,5 @@ Read the relevant contract before changing its behavior:
|
||||
- [Fill verification](docs/performance/fill-verification.md): opt-in benchmarks, frozen oracles, Debug-only counters and predictor initialization. Zero Release counters do not prove work removal.
|
||||
- [Desktop auto-update](docs/auto-update.md): GitHub Releases by default, opt-in rolling `dev-build` pre-release from green master pushes, the nest server's `/updates` mirror first in Database mode (GitHub fallback), `UpdateFeedUrl` for a self-hosted feed, release Velopack assets and `Deploy-OpenNest.ps1`.
|
||||
- [Undo and Redo](docs/undo-redo.md): whole-nest history, the recording rule, what a restore rebuilds and what is excluded.
|
||||
- [MCP nest server tools](docs/mcp-nest-server-tools.md): Database-mode MCP tools for the drawing library, sets, Make Nests, re-nesting on candidate sheet sizes and undo; they write to the live nest server, so tests use the in-process server only
|
||||
- [Desktop help](docs/desktop-help.md): WebView2 help window, topic IDs and the pinned help release both packaging scripts install.
|
||||
@@ -0,0 +1,163 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Net.Http;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using OpenNest.Data;
|
||||
using OpenNest.Data.MaterialLedger;
|
||||
using OpenNest.Desktop;
|
||||
using OpenNest.Engine.Jobs;
|
||||
|
||||
namespace OpenNest.Mcp.Database;
|
||||
|
||||
/// <summary>
|
||||
/// The nest server the Database-mode tools talk to, and what they need to make nests as the
|
||||
/// desktop does: File > New nests (<see cref="NewNestSource"/>), the saved Auto Nest engine and
|
||||
/// this PC's MaterialLedger connection. <see cref="Load"/> reads the desktop's own settings
|
||||
/// (storage.json, defaults, machines, user-settings.json); tests build one around an
|
||||
/// in-process server.
|
||||
/// </summary>
|
||||
public sealed class NestServerContext : IDisposable
|
||||
{
|
||||
private static readonly HttpClient LedgerHttp = new();
|
||||
|
||||
// Distinguishes OpenNest's ledger key from other DPAPI blobs of the same user; matches the desktop.
|
||||
private static readonly byte[] LedgerEntropy = Encoding.UTF8.GetBytes("OpenNest.MaterialLedger.ApiKey");
|
||||
|
||||
private readonly Func<SetReleaseGroup, Task<NewNest>> _createNest;
|
||||
private readonly Func<string> _engineName;
|
||||
private readonly Func<Guid, ReleaseLedgerStock> _createLedger;
|
||||
private readonly IDisposable[] _owned;
|
||||
|
||||
/// <param name="createNest">Makes a group's empty nest as File > New would.</param>
|
||||
/// <param name="engineName">The Auto Nest engine to use when a call names none.</param>
|
||||
/// <param name="createLedger">
|
||||
/// MaterialLedger stock for one run, leaving out codes on every open nest but the given one;
|
||||
/// null when the ledger is not set up, so nests use sheet sizes only.
|
||||
/// </param>
|
||||
public NestServerContext(string serverUrl, RemoteDrawingLibrary library, IDrawingSetStore sets,
|
||||
INestRepository nests, Func<SetReleaseGroup, Task<NewNest>> createNest, Func<string> engineName,
|
||||
Func<Guid, ReleaseLedgerStock> createLedger, string userName, params IDisposable[] owned)
|
||||
{
|
||||
ServerUrl = serverUrl ?? throw new ArgumentNullException(nameof(serverUrl));
|
||||
Library = library ?? throw new ArgumentNullException(nameof(library));
|
||||
Sets = sets ?? throw new ArgumentNullException(nameof(sets));
|
||||
Nests = nests ?? throw new ArgumentNullException(nameof(nests));
|
||||
_createNest = createNest ?? throw new ArgumentNullException(nameof(createNest));
|
||||
_engineName = engineName ?? throw new ArgumentNullException(nameof(engineName));
|
||||
_createLedger = createLedger;
|
||||
UserName = string.IsNullOrWhiteSpace(userName) ? Environment.UserName : userName.Trim();
|
||||
_owned = owned ?? Array.Empty<IDisposable>();
|
||||
}
|
||||
|
||||
private NestServerContext(string error)
|
||||
{
|
||||
Error = error;
|
||||
_owned = Array.Empty<IDisposable>();
|
||||
}
|
||||
|
||||
/// <summary>Why the tools cannot reach a nest server (File mode, no URL); null when they can.</summary>
|
||||
public string Error { get; }
|
||||
|
||||
public string ServerUrl { get; }
|
||||
|
||||
public RemoteDrawingLibrary Library { get; }
|
||||
|
||||
public IDrawingSetStore Sets { get; }
|
||||
|
||||
public INestRepository Nests { get; }
|
||||
|
||||
/// <summary>Recorded as SavedBy, ReleasedBy and UndoneBy.</summary>
|
||||
public string UserName { get; }
|
||||
|
||||
/// <summary>True when MaterialLedger stock is offered before the sheet sizes.</summary>
|
||||
public bool HasLedger => _createLedger != null;
|
||||
|
||||
public Task<NewNest> CreateNestAsync(SetReleaseGroup group) => _createNest(group);
|
||||
|
||||
/// <summary>The ledger stock for one run, or null when the ledger is not set up.</summary>
|
||||
public ReleaseLedgerStock CreateLedger(Guid excludeNestId) => _createLedger?.Invoke(excludeNestId);
|
||||
|
||||
/// <summary>
|
||||
/// <paramref name="requested"/> as the registry spells it, else the engine the desktop last
|
||||
/// used (engine-selection.json), else Default.
|
||||
/// </summary>
|
||||
public string ResolveEngine(string requested, out string error)
|
||||
{
|
||||
error = null;
|
||||
if (string.IsNullOrWhiteSpace(requested))
|
||||
return _engineName();
|
||||
var name = NestingEngineRegistry.ResolveName(requested.Trim());
|
||||
if (name != null)
|
||||
return name;
|
||||
error = $"Unknown engine '{requested}'. Available: "
|
||||
+ string.Join(", ", NestingEngineRegistry.AvailableEngines.Select(e => e.Name)) + ".";
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The nest server from storage.json in Database mode, with File > New nests, the engine
|
||||
/// and MaterialLedger set up from the desktop's settings files.
|
||||
/// </summary>
|
||||
public static NestServerContext Load() => FromStorage(NestStorageSettings.Load(NestStorageSettings.DefaultPath));
|
||||
|
||||
/// <summary><see cref="Load"/> for the given storage settings; File mode gives a context with <see cref="Error"/>.</summary>
|
||||
public static NestServerContext FromStorage(NestStorageSettings storage)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(storage);
|
||||
if (!storage.IsDatabaseMode || string.IsNullOrWhiteSpace(storage.ServerUrl))
|
||||
return new NestServerContext(
|
||||
"OpenNest is not in Database mode on this PC (storage.json has no nest server), so the nest server tools are unavailable.");
|
||||
|
||||
var url = storage.ServerUrl;
|
||||
RemoteDrawingLibrary library;
|
||||
RemoteDrawingSetStore sets;
|
||||
RemoteNestRepository nests;
|
||||
try
|
||||
{
|
||||
library = new RemoteDrawingLibrary(url);
|
||||
sets = new RemoteDrawingSetStore(url);
|
||||
nests = new RemoteNestRepository(url);
|
||||
}
|
||||
catch (ArgumentException ex)
|
||||
{
|
||||
return new NestServerContext($"The nest server URL '{url}' in storage.json is not valid: {ex.Message}");
|
||||
}
|
||||
|
||||
var shared = new SharedSettingsSource(() => storage);
|
||||
var machines = new MachineSettingsSource(shared, new MachineUserSettingsFile(UserSettingsFile.DefaultPath));
|
||||
var newNests = new NewNestSource(machines, new NewNestUserSettingsFile(UserSettingsFile.DefaultPath), () => nests);
|
||||
|
||||
var ledgerSettings = MaterialLedgerSettings.Load(MaterialLedgerSettings.DefaultPath, UnprotectLedgerKey);
|
||||
Func<Guid, ReleaseLedgerStock> ledger = !ledgerSettings.IsConfigured
|
||||
? null
|
||||
: exclude => new ReleaseLedgerStock(
|
||||
(material, grade, thicknessIn, token) => new MaterialLedgerClient(LedgerHttp, ledgerSettings)
|
||||
.GetStockAsync(material, grade, thicknessIn, token),
|
||||
token => LedgerCodesInUse.ReadAsync(nests, exclude, token));
|
||||
|
||||
return new NestServerContext(url, library, sets, nests, group => newNests.CreateAsync(group),
|
||||
SavedEngine, ledger, Environment.UserName, library, sets, nests);
|
||||
}
|
||||
|
||||
/// <summary>The engine the desktop last used, resolved against the loaded engines.</summary>
|
||||
public static string SavedEngine() =>
|
||||
EngineSelectionSettings.Load(EngineSelectionSettings.DefaultPath)
|
||||
.Resolve(NestingEngineRegistry.AvailableEngines.Select(e => e.Name), out _, NestingEngineRegistry.ResolveName);
|
||||
|
||||
private static string UnprotectLedgerKey(string protectedText)
|
||||
{
|
||||
if (!OperatingSystem.IsWindows())
|
||||
throw new PlatformNotSupportedException("The MaterialLedger key is protected for Windows.");
|
||||
return Encoding.UTF8.GetString(ProtectedData.Unprotect(Convert.FromBase64String(protectedText), LedgerEntropy,
|
||||
DataProtectionScope.CurrentUser));
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
foreach (var owned in _owned)
|
||||
owned?.Dispose();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
namespace OpenNest.Mcp.Database;
|
||||
|
||||
/// <summary>A drawing set and how many kits of it.</summary>
|
||||
public sealed class ReleaseSetInput
|
||||
{
|
||||
/// <summary>The set's id, or its exact name.</summary>
|
||||
public string Set { get; set; }
|
||||
|
||||
public int Quantity { get; set; } = 1;
|
||||
}
|
||||
|
||||
/// <summary>A library drawing (released on its own, or a set member) and how many.</summary>
|
||||
public sealed class DrawingQuantityInput
|
||||
{
|
||||
/// <summary>The drawing's id, or its exact name.</summary>
|
||||
public string Drawing { get; set; }
|
||||
|
||||
public int Quantity { get; set; } = 1;
|
||||
}
|
||||
|
||||
/// <summary>Merges one material group of a release into an existing Draft nest.</summary>
|
||||
public sealed class MergeInput
|
||||
{
|
||||
/// <summary>The group key plan_release prints.</summary>
|
||||
public string Group { get; set; }
|
||||
|
||||
/// <summary>The draft nest's id, or its exact name.</summary>
|
||||
public string Draft { get; set; }
|
||||
}
|
||||
@@ -0,0 +1,227 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using OpenNest.Data.MaterialLedger;
|
||||
using OpenNest.Desktop;
|
||||
using OpenNest.Engine.BestFit;
|
||||
using OpenNest.Engine.Jobs;
|
||||
using OpenNest.Geometry;
|
||||
using OpenNest.IO;
|
||||
|
||||
namespace OpenNest.Mcp.Database;
|
||||
|
||||
/// <summary>One sheet-size choice: a single size, or every size offered together as plate options.</summary>
|
||||
public sealed class SheetChoice
|
||||
{
|
||||
private SheetChoice(IReadOnlyList<Size> sizes, bool mixed)
|
||||
{
|
||||
Sizes = sizes;
|
||||
Mixed = mixed;
|
||||
}
|
||||
|
||||
public IReadOnlyList<Size> Sizes { get; }
|
||||
|
||||
/// <summary>True when the engine may mix the sizes (Nest.PlateOptions); false for one size alone.</summary>
|
||||
public bool Mixed { get; }
|
||||
|
||||
public static SheetChoice Single(Size size) => new(new[] { size }, false);
|
||||
|
||||
public static SheetChoice Together(IReadOnlyList<Size> sizes) => new(sizes, true);
|
||||
|
||||
/// <summary>
|
||||
/// Sets the nest up to nest on this choice: one size as the plate default with no plate
|
||||
/// options, or every size as plate options (offered without limit).
|
||||
/// </summary>
|
||||
public void ApplyTo(Nest nest)
|
||||
{
|
||||
if (Mixed)
|
||||
{
|
||||
nest.PlateOptions = Sizes.Select(s => new PlateOption { Width = s.Width, Length = s.Length }).ToList();
|
||||
return;
|
||||
}
|
||||
nest.PlateDefaults.Size = Sizes[0];
|
||||
nest.PlateOptions = new List<PlateOption>();
|
||||
}
|
||||
|
||||
public override string ToString() =>
|
||||
Mixed ? $"mixed ({string.Join(", ", Sizes.Select(SheetSizes.Format))})" : SheetSizes.Format(Sizes[0]);
|
||||
}
|
||||
|
||||
/// <summary>What one sheet choice nested: kept or not, copies left, physical sheets and their area.</summary>
|
||||
public sealed record SheetTrial(SheetChoice Choice, bool Kept, int Unplaced, int Sheets, double SheetArea,
|
||||
double Utilization, string Note)
|
||||
{
|
||||
/// <summary>A kept layout first, then fewer copies unplaced, fewer sheets, less sheet area.</summary>
|
||||
public static int Compare(SheetTrial a, SheetTrial b)
|
||||
{
|
||||
var order = b.Kept.CompareTo(a.Kept);
|
||||
if (order == 0)
|
||||
order = a.Unplaced.CompareTo(b.Unplaced);
|
||||
if (order == 0)
|
||||
order = a.Sheets.CompareTo(b.Sheets);
|
||||
if (order == 0)
|
||||
order = a.SheetArea.CompareTo(b.SheetArea);
|
||||
return order;
|
||||
}
|
||||
|
||||
public string Describe() => Kept
|
||||
? string.Format(CultureInfo.InvariantCulture, "{0}: {1} sheet{2}, {3:0.##} sq, {4:P1} used, {5} unplaced",
|
||||
Name, Sheets, Sheets == 1 ? "" : "s", SheetArea, Utilization, Unplaced)
|
||||
: $"{Name}: no layout kept";
|
||||
|
||||
/// <summary>The choice, or the nest's own plate defaults when no size was given.</summary>
|
||||
public string Name => Choice?.ToString() ?? "plate defaults";
|
||||
}
|
||||
|
||||
/// <summary>The kept nest, the trial it came from and every trial run, best first.</summary>
|
||||
public sealed record SheetTrialOutcome(bool Nested, string Note, SheetTrial Chosen, IReadOnlyList<SheetTrial> Trials);
|
||||
|
||||
/// <summary>Sheet sizes as tools take and print them: "72x144", width then length.</summary>
|
||||
public static class SheetSizes
|
||||
{
|
||||
public static string Format(Size size) =>
|
||||
string.Format(CultureInfo.InvariantCulture, "{0:0.###}x{1:0.###}", size.Width, size.Length);
|
||||
|
||||
/// <summary>Parses "WxL" (x, X or *), each positive and finite; error says which one is not.</summary>
|
||||
public static IReadOnlyList<Size> Parse(IEnumerable<string> texts, out string error)
|
||||
{
|
||||
error = null;
|
||||
var sizes = new List<Size>();
|
||||
foreach (var text in texts ?? Array.Empty<string>())
|
||||
{
|
||||
var parts = (text ?? "").Split(new[] { 'x', 'X', '*' }, StringSplitOptions.TrimEntries);
|
||||
if (parts.Length != 2
|
||||
|| !double.TryParse(parts[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var width)
|
||||
|| !double.TryParse(parts[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var length)
|
||||
|| !double.IsFinite(width) || !double.IsFinite(length) || width <= 0 || length <= 0)
|
||||
{
|
||||
error = $"Sheet size '{text}' is not WIDTHxLENGTH, for example 60x120.";
|
||||
return null;
|
||||
}
|
||||
var size = new Size(width, length);
|
||||
if (!sizes.Any(s => s.Width == size.Width && s.Length == size.Length))
|
||||
sizes.Add(size);
|
||||
}
|
||||
return sizes;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Auto Nest of a nest no one is looking at, as Make Nests runs it (<see cref="ReleaseRenest"/>),
|
||||
/// on the best of several sheet sizes: each size alone and, for two or more, all of them as
|
||||
/// plate options, keeping the layout that leaves the fewest copies unplaced, then uses the
|
||||
/// fewest sheets, then the least sheet area. Trials run on copies read back from the nest's
|
||||
/// archive without MaterialLedger stock; the choice is then nested on the nest itself with the
|
||||
/// ledger first, as Make Nests does.
|
||||
/// </summary>
|
||||
public static class SheetSizeTrials
|
||||
{
|
||||
/// <summary>
|
||||
/// Nests <paramref name="nest"/> in place on the best choice from <paramref name="sizes"/>
|
||||
/// (empty: the nest's own plate defaults and options).
|
||||
/// </summary>
|
||||
public static async Task<SheetTrialOutcome> NestAsync(Nest nest, IReadOnlyList<Size> sizes,
|
||||
ReleaseLedgerStock ledger, string engineName, CancellationToken token)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(nest);
|
||||
var trials = new List<SheetTrial>();
|
||||
SheetChoice chosen = null;
|
||||
var choices = Choices(sizes);
|
||||
if (choices.Count > 1)
|
||||
{
|
||||
var archive = Write(nest);
|
||||
foreach (var choice in choices)
|
||||
{
|
||||
var copy = Read(archive);
|
||||
trials.Add(await RunAsync(copy, choice, null, engineName, token));
|
||||
}
|
||||
trials.Sort(SheetTrial.Compare);
|
||||
chosen = trials[0].Choice;
|
||||
}
|
||||
else if (choices.Count == 1)
|
||||
{
|
||||
chosen = choices[0];
|
||||
}
|
||||
|
||||
var final = await RunAsync(nest, chosen, ledger, engineName, token);
|
||||
if (trials.Count == 0 && chosen != null)
|
||||
trials.Add(final);
|
||||
return new SheetTrialOutcome(final.Kept, final.Note, final, trials);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The trials on copies of <paramref name="archive"/> and the best copy nested, ledger
|
||||
/// first when given; the archive's nest itself is not changed.
|
||||
/// </summary>
|
||||
public static async Task<(Nest Nest, SheetTrialOutcome Outcome)> NestCopyAsync(byte[] archive,
|
||||
Action<Nest> prepare, IReadOnlyList<Size> sizes, ReleaseLedgerStock ledger, string engineName,
|
||||
CancellationToken token)
|
||||
{
|
||||
var choices = Choices(sizes);
|
||||
if (choices.Count == 0)
|
||||
choices = new List<SheetChoice> { null };
|
||||
var runs = new List<(Nest Nest, SheetTrial Trial)>();
|
||||
foreach (var choice in choices)
|
||||
{
|
||||
var copy = Read(archive);
|
||||
prepare?.Invoke(copy);
|
||||
runs.Add((copy, await RunAsync(copy, choice, choices.Count > 1 ? null : ledger, engineName, token)));
|
||||
}
|
||||
runs.Sort((a, b) => SheetTrial.Compare(a.Trial, b.Trial));
|
||||
var best = runs[0];
|
||||
if (choices.Count > 1 && ledger != null)
|
||||
{
|
||||
// The ledger's sheets are taken by the nest that keeps them, so only the choice runs on them.
|
||||
var copy = Read(archive);
|
||||
prepare?.Invoke(copy);
|
||||
best = (copy, await RunAsync(copy, best.Trial.Choice, ledger, engineName, token));
|
||||
}
|
||||
var trials = runs.Select(r => r.Trial).Where(t => t.Choice != null).ToList();
|
||||
return (best.Nest, new SheetTrialOutcome(best.Trial.Kept, best.Trial.Note, best.Trial, trials));
|
||||
}
|
||||
|
||||
private static List<SheetChoice> Choices(IReadOnlyList<Size> sizes)
|
||||
{
|
||||
var choices = (sizes ?? Array.Empty<Size>()).Select(SheetChoice.Single).ToList();
|
||||
if (choices.Count > 1)
|
||||
choices.Add(SheetChoice.Together(sizes));
|
||||
return choices;
|
||||
}
|
||||
|
||||
private static async Task<SheetTrial> RunAsync(Nest nest, SheetChoice choice, ReleaseLedgerStock ledger,
|
||||
string engineName, CancellationToken token)
|
||||
{
|
||||
choice?.ApplyTo(nest);
|
||||
var result = await Task.Run(() => ReleaseRenest.RunHeadlessAsync(nest, ledger,
|
||||
NestingEngineRegistry.Create(engineName), engineName, Nest.DefaultMinimumRemnantDimension, token), token);
|
||||
return Measure(nest, choice, result.Nested, result.Note);
|
||||
}
|
||||
|
||||
/// <summary>The trial as the nest now stands.</summary>
|
||||
public static SheetTrial Measure(Nest nest, SheetChoice choice, bool kept, string note)
|
||||
{
|
||||
var plates = nest.Plates.ToList();
|
||||
var sheets = plates.Sum(p => p.Quantity);
|
||||
var area = plates.Sum(p => p.Area() * p.Quantity);
|
||||
var used = area > 0 ? plates.Sum(p => p.Utilization() * p.Area() * p.Quantity) / area : 0;
|
||||
var unplaced = nest.Drawings.Where(d => !d.IsCutOff).Sum(d => d.Quantity.Remaining);
|
||||
return new SheetTrial(choice, kept, unplaced, sheets, area, used, note ?? "");
|
||||
}
|
||||
|
||||
public static byte[] Write(Nest nest)
|
||||
{
|
||||
using var stream = new MemoryStream();
|
||||
new NestWriter(nest) { BestFitStore = BestFitCacheStore.Shared }.Write(stream);
|
||||
return stream.ToArray();
|
||||
}
|
||||
|
||||
public static Nest Read(byte[] archive)
|
||||
{
|
||||
using var stream = new MemoryStream(archive, writable: false);
|
||||
return new NestReader(stream) { BestFitStore = BestFitCacheStore.Shared }.Read();
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,10 @@
|
||||
<ProjectReference Include="..\OpenNest.Core\OpenNest.Core.csproj" />
|
||||
<ProjectReference Include="..\OpenNest.Engine\OpenNest.Engine.csproj" />
|
||||
<ProjectReference Include="..\OpenNest.IO\OpenNest.IO.csproj" />
|
||||
<!-- Database-mode tools: drawing library, sets, releases and File > New nests, as the desktop does them. -->
|
||||
<ProjectReference Include="..\OpenNest.Desktop\OpenNest.Desktop.csproj" />
|
||||
<!-- Reads the MaterialLedger API key the desktop protects with DPAPI. -->
|
||||
<PackageReference Include="System.Security.Cryptography.ProtectedData" Version="8.0.0" />
|
||||
<PackageReference Include="ModelContextProtocol" Version="0.9.0-preview.2" />
|
||||
<PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.21" />
|
||||
</ItemGroup>
|
||||
|
||||
@@ -5,6 +5,7 @@ using Microsoft.Extensions.Hosting;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using OpenNest.Engine.Jobs;
|
||||
using OpenNest.Mcp;
|
||||
using OpenNest.Mcp.Database;
|
||||
|
||||
NestingEngineRegistry.LoadPlugins(Path.Combine(AppContext.BaseDirectory, "Engines"));
|
||||
var builder = Host.CreateApplicationBuilder(args);
|
||||
@@ -14,6 +15,8 @@ builder.Logging.AddConsole(o => o.LogToStandardErrorThreshold = LogLevel.Trace);
|
||||
|
||||
using var toolGate = new SessionToolGate();
|
||||
builder.Services.AddSingleton<NestSession>();
|
||||
// Database-mode tools read storage.json and the desktop settings once, at first use.
|
||||
builder.Services.AddSingleton(_ => NestServerContext.Load());
|
||||
builder
|
||||
.Services.AddMcpServer()
|
||||
.WithRequestFilters(filters => filters.AddCallToolFilter(
|
||||
|
||||
@@ -0,0 +1,786 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.ComponentModel;
|
||||
using System.Globalization;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using ModelContextProtocol.Server;
|
||||
using OpenNest.Data;
|
||||
using OpenNest.Geometry;
|
||||
using OpenNest.Mcp.Database;
|
||||
|
||||
namespace OpenNest.Mcp.Tools
|
||||
{
|
||||
/// <summary>
|
||||
/// Database-mode tools: the nest server's drawing library, drawing sets, releases (Make
|
||||
/// Nests) and saved nests, through the same clients and release session the desktop uses.
|
||||
/// </summary>
|
||||
[McpServerToolType]
|
||||
public class NestServerTools
|
||||
{
|
||||
private const string SheetSizesHelp =
|
||||
"Optional candidate sheet sizes as WIDTHxLENGTH in the nest's units, e.g. [\"60x120\",\"72x144\"]. "
|
||||
+ "Each size is tried alone and, for two or more, all together as plate options; the layout leaving the "
|
||||
+ "fewest parts unplaced, then using the fewest sheets, then the least sheet area, is kept. "
|
||||
+ "Omit to nest on the nest defaults' plate size and options, as the desktop does.";
|
||||
|
||||
private readonly NestServerContext _server;
|
||||
|
||||
public NestServerTools(NestServerContext server)
|
||||
{
|
||||
_server = server;
|
||||
}
|
||||
|
||||
[McpServerTool(Name = "search_drawings")]
|
||||
[Description("Search the nest server's drawing library. Text search matches names; filters narrow by customer, material, grade and thickness. Returns ids for get_drawing, create_set and make_nests.")]
|
||||
public Task<string> SearchDrawings(
|
||||
[Description("Text to search for in drawing names (optional)")] string search = null,
|
||||
[Description("Customer (optional)")] string customer = null,
|
||||
[Description("Material name, e.g. 'Stainless' (optional)")] string material = null,
|
||||
[Description("Material grade, e.g. '304' (optional)")] string grade = null,
|
||||
[Description("Thickness in the drawing's units (optional)")] double? thickness = null,
|
||||
[Description("Include archived drawings (default false)")] bool includeArchived = false,
|
||||
[Description("Results to skip (default 0)")] int offset = 0,
|
||||
[Description("Most results to return (default 50, at most 500)")] int limit = 50,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
var page = await _server.Library.QueryAsync(new DrawingLibraryQuery
|
||||
{
|
||||
Search = search ?? "",
|
||||
Customer = customer ?? "",
|
||||
MaterialName = material ?? "",
|
||||
MaterialGrade = grade ?? "",
|
||||
Thickness = thickness,
|
||||
IncludeArchived = includeArchived,
|
||||
Offset = System.Math.Max(0, offset),
|
||||
Limit = System.Math.Clamp(limit, 1, DrawingLibraryQuery.MaxLimit),
|
||||
}, cancellationToken);
|
||||
var sb = new StringBuilder();
|
||||
sb.AppendLine($"{page.Items.Count} of {page.Total} drawings (offset {page.Offset}):");
|
||||
foreach (var drawing in page.Items)
|
||||
sb.AppendLine("- " + DescribeDrawing(drawing));
|
||||
return sb.ToString();
|
||||
});
|
||||
|
||||
[McpServerTool(Name = "get_drawing")]
|
||||
[Description("One library drawing by id or exact name: material, thickness, size, notes, revision and the sets that list it.")]
|
||||
public Task<string> GetDrawing(
|
||||
[Description("Drawing id, or its exact name")] string drawing,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
var (record, error) = await ResolveDrawingAsync(drawing, cancellationToken);
|
||||
if (record == null)
|
||||
return Error(error);
|
||||
var sb = new StringBuilder();
|
||||
sb.AppendLine(DescribeDrawing(record));
|
||||
sb.AppendLine($"Saved {record.SavedAt:yyyy-MM-dd HH:mm} by {Blank(record.SavedBy)}");
|
||||
if (record.Notes.Length > 0)
|
||||
sb.AppendLine($"Notes: {record.Notes}");
|
||||
var sets = await _server.Sets.GetSetsContainingAsync(record.Id, 0, 100, cancellationToken);
|
||||
if (sets == null || sets.Items.Count == 0)
|
||||
sb.AppendLine("In no drawing set.");
|
||||
else
|
||||
{
|
||||
sb.AppendLine($"In {sets.Total} set(s):");
|
||||
foreach (var set in sets.Items)
|
||||
sb.AppendLine($"- {set.Name} | id {set.Id} rev {set.Revision}{(set.Archived ? " | archived" : "")}");
|
||||
}
|
||||
return sb.ToString();
|
||||
});
|
||||
|
||||
[McpServerTool(Name = "search_sets")]
|
||||
[Description("Search the nest server's drawing sets (assemblies/kits of library drawings) by name text and customer.")]
|
||||
public Task<string> SearchSets(
|
||||
[Description("Text to search for in set names (optional)")] string search = null,
|
||||
[Description("Customer (optional)")] string customer = null,
|
||||
[Description("Include archived sets (default false)")] bool includeArchived = false,
|
||||
[Description("Results to skip (default 0)")] int offset = 0,
|
||||
[Description("Most results to return (default 50, at most 500)")] int limit = 50,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
var page = await _server.Sets.QueryAsync(new DrawingSetQuery
|
||||
{
|
||||
Search = search ?? "",
|
||||
Customer = customer ?? "",
|
||||
IncludeArchived = includeArchived,
|
||||
Offset = System.Math.Max(0, offset),
|
||||
Limit = System.Math.Clamp(limit, 1, DrawingSetQuery.MaxLimit),
|
||||
}, cancellationToken);
|
||||
var sb = new StringBuilder();
|
||||
sb.AppendLine($"{page.Items.Count} of {page.Total} sets (offset {page.Offset}):");
|
||||
foreach (var set in page.Items)
|
||||
sb.AppendLine("- " + DescribeSet(set));
|
||||
return sb.ToString();
|
||||
});
|
||||
|
||||
[McpServerTool(Name = "get_set")]
|
||||
[Description("One drawing set by id or exact name, with every member's drawing, quantity per kit, material and thickness.")]
|
||||
public Task<string> GetSet(
|
||||
[Description("Set id, or its exact name")] string set,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
var (record, error) = await ResolveSetAsync(set, cancellationToken);
|
||||
return record == null ? Error(error) : FormatSet(record);
|
||||
});
|
||||
|
||||
[McpServerTool(Name = "create_set")]
|
||||
[Description("Create a drawing set on the nest server from library drawings and per-kit quantities. Refuses a name another set already has.")]
|
||||
public Task<string> CreateSet(
|
||||
[Description("Set name, e.g. '4348 A21 Lower element rack'")] string name,
|
||||
[Description("Members: [{\"drawing\": id or exact name, \"quantity\": per kit}]")] DrawingQuantityInput[] members,
|
||||
[Description("Customer (optional)")] string customer = null,
|
||||
[Description("Notes (optional)")] string notes = null,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(name))
|
||||
return Error("A set needs a name.");
|
||||
var existing = await FindSetsByNameAsync(name.Trim(), cancellationToken);
|
||||
if (existing.Count > 0)
|
||||
return Error($"A set named '{existing[0].Name}' already exists (id {existing[0].Id}). Use update_set to change it.");
|
||||
var (resolved, error) = await ResolveMembersAsync(members, cancellationToken);
|
||||
if (resolved == null)
|
||||
return Error(error);
|
||||
var created = await _server.Sets.CreateAsync(new DrawingSetRecord
|
||||
{
|
||||
Id = Guid.NewGuid(),
|
||||
Name = name.Trim(),
|
||||
Customer = customer?.Trim() ?? "",
|
||||
Notes = notes ?? "",
|
||||
SavedBy = _server.UserName,
|
||||
Members = resolved,
|
||||
}, cancellationToken);
|
||||
var stored = await _server.Sets.GetAsync(created.Id, cancellationToken) ?? created;
|
||||
return "Created set.\n" + FormatSet(stored);
|
||||
});
|
||||
|
||||
[McpServerTool(Name = "update_set")]
|
||||
[Description("Save a new revision of a drawing set: rename it or change its customer, notes or members. Omitted fields keep their current value; members, when given, replace the whole list.")]
|
||||
public Task<string> UpdateSet(
|
||||
[Description("Set id, or its exact name")] string set,
|
||||
[Description("New name (optional)")] string name = null,
|
||||
[Description("New customer (optional)")] string customer = null,
|
||||
[Description("New notes (optional)")] string notes = null,
|
||||
[Description("New member list, replacing the current one: [{\"drawing\": id or exact name, \"quantity\": per kit}] (optional)")] DrawingQuantityInput[] members = null,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
var (current, error) = await ResolveSetAsync(set, cancellationToken);
|
||||
if (current == null)
|
||||
return Error(error);
|
||||
if (name != null && !string.Equals(name.Trim(), current.Name, StringComparison.OrdinalIgnoreCase)
|
||||
&& (await FindSetsByNameAsync(name.Trim(), cancellationToken)).FirstOrDefault(s => s.Id != current.Id) is { } clash)
|
||||
return Error($"Another set is already named '{clash.Name}' (id {clash.Id}).");
|
||||
|
||||
IReadOnlyList<DrawingSetMember> newMembers = current.Members
|
||||
.Select(m => new DrawingSetMember { DrawingId = m.DrawingId, Quantity = m.Quantity }).ToList();
|
||||
if (members != null)
|
||||
{
|
||||
var (resolved, memberError) = await ResolveMembersAsync(members, cancellationToken);
|
||||
if (resolved == null)
|
||||
return Error(memberError);
|
||||
newMembers = resolved;
|
||||
}
|
||||
|
||||
var saved = await _server.Sets.UpdateAsync(current.Id, new DrawingSetRecord
|
||||
{
|
||||
Id = current.Id,
|
||||
Name = name?.Trim() ?? current.Name,
|
||||
Customer = customer?.Trim() ?? current.Customer,
|
||||
Notes = notes ?? current.Notes,
|
||||
Archived = current.Archived,
|
||||
SavedBy = _server.UserName,
|
||||
Members = newMembers,
|
||||
}, current.Revision, cancellationToken);
|
||||
var stored = await _server.Sets.GetAsync(saved.Id, cancellationToken) ?? saved;
|
||||
return $"Saved revision {stored.Revision}.\n" + FormatSet(stored);
|
||||
});
|
||||
|
||||
[McpServerTool(Name = "archive_set")]
|
||||
[Description("Archive a drawing set so it no longer shows by default. Releases already made are kept.")]
|
||||
public Task<string> ArchiveSet(
|
||||
[Description("Set id, or its exact name")] string set,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
SetArchivedAsync(set, archive: true, cancellationToken);
|
||||
|
||||
[McpServerTool(Name = "restore_set")]
|
||||
[Description("Restore an archived drawing set.")]
|
||||
public Task<string> RestoreSet(
|
||||
[Description("Set id, or its exact name")] string set,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
SetArchivedAsync(set, archive: false, cancellationToken);
|
||||
|
||||
[McpServerTool(Name = "plan_release")]
|
||||
[Description("Read-only preview of a release (Make Nests): sets x kits plus drawings on their own x quantity, split into material groups (material, grade, thickness, units, cut type) with each group's parts and quantities, refusals, warnings and the Draft nests it could merge into. Nothing is created.")]
|
||||
public Task<string> PlanRelease(
|
||||
[Description("Sets to release: [{\"set\": id or exact name, \"quantity\": kits}] (optional)")] ReleaseSetInput[] sets = null,
|
||||
[Description("Library drawings to release on their own: [{\"drawing\": id or exact name, \"quantity\": n}] (optional)")] DrawingQuantityInput[] drawings = null,
|
||||
[Description("Include archived drawings (default false: they are skipped)")] bool includeArchived = false,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
var (plan, error) = await BuildPlanAsync(sets, drawings, includeArchived, cancellationToken);
|
||||
if (plan == null)
|
||||
return Error(error);
|
||||
var sb = new StringBuilder();
|
||||
await AppendPlanAsync(sb, plan, cancellationToken);
|
||||
return sb.ToString();
|
||||
});
|
||||
|
||||
[McpServerTool(Name = "make_nests")]
|
||||
[Description("Release sets and drawings as the desktop's Make Nests does: one Draft nest per material group, new (named by the server, set up as File > New) or merged into a named draft, nested after release with the desktop's engine (MaterialLedger stock first when set up on this PC), saved to the nest server and recorded as one release. Returns each group's nest name, id, revision, sheets, utilization and unplaced parts, and the release id (undo_release undoes it). Refuses everything when any group cannot be released, unless skipRefusedGroups.")]
|
||||
public Task<string> MakeNests(
|
||||
[Description("Sets to release: [{\"set\": id or exact name, \"quantity\": kits}] (optional)")] ReleaseSetInput[] sets = null,
|
||||
[Description("Library drawings to release on their own: [{\"drawing\": id or exact name, \"quantity\": n}] (optional)")] DrawingQuantityInput[] drawings = null,
|
||||
[Description("Release notes, e.g. job numbers (optional)")] string notes = null,
|
||||
[Description(SheetSizesHelp)] string[] sheetSizes = null,
|
||||
[Description("Groups to merge into existing Draft nests instead of new nests: [{\"group\": key from plan_release, \"draft\": nest id or exact name}] (optional)")] MergeInput[] merge = null,
|
||||
[Description("Include archived drawings (default false: they are skipped)")] bool includeArchived = false,
|
||||
[Description("Run Auto Nest on each nest before saving (default true)")] bool nestAfterRelease = true,
|
||||
[Description("Offer MaterialLedger stock first when it is set up on this PC (default true)")] bool useLedger = true,
|
||||
[Description("Release the groups that can be and leave out refused ones (default false: refuse all)")] bool skipRefusedGroups = false,
|
||||
[Description("Whole-job engine name (optional; default: the engine last chosen on the desktop)")] string engine = null,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
var engineName = _server.ResolveEngine(engine, out var engineError);
|
||||
if (engineName == null)
|
||||
return Error(engineError);
|
||||
var sizes = SheetSizes.Parse(sheetSizes, out var sizeError);
|
||||
if (sizes == null)
|
||||
return Error(sizeError);
|
||||
var (plan, error) = await BuildPlanAsync(sets, drawings, includeArchived, cancellationToken);
|
||||
if (plan == null)
|
||||
return Error(error);
|
||||
var refused = plan.Groups.Where(g => !g.CanRelease).ToList();
|
||||
var chosen = plan.Groups.Where(g => g.CanRelease).ToList();
|
||||
if (chosen.Count == 0 || (refused.Count > 0 && !skipRefusedGroups))
|
||||
{
|
||||
var why = new StringBuilder("Error: nothing was released. ");
|
||||
why.AppendLine(chosen.Count == 0 ? "No group can be released." : "Some groups cannot be released (pass skipRefusedGroups to release the rest).");
|
||||
foreach (var group in refused)
|
||||
why.AppendLine($"- {group.Key}: {group.Refusal}");
|
||||
return why.ToString();
|
||||
}
|
||||
|
||||
var merges = new Dictionary<SetReleaseGroup, NestRecord>();
|
||||
foreach (var target in merge ?? Array.Empty<MergeInput>())
|
||||
{
|
||||
var group = chosen.FirstOrDefault(g => string.Equals(g.Key, target?.Group?.Trim(), StringComparison.OrdinalIgnoreCase));
|
||||
if (group == null)
|
||||
return Error($"No releasable group '{target?.Group}'. Groups: {string.Join(", ", chosen.Select(g => g.Key))}.");
|
||||
if (merges.ContainsKey(group))
|
||||
return Error($"Group '{group.Key}' is merged twice.");
|
||||
var (draft, draftError) = await ResolveNestAsync(target.Draft, cancellationToken);
|
||||
if (draft == null)
|
||||
return Error(draftError);
|
||||
merges[group] = draft;
|
||||
}
|
||||
|
||||
var ledger = nestAfterRelease && useLedger ? _server.CreateLedger(Guid.Empty) : null;
|
||||
var trials = new Dictionary<Nest, SheetTrialOutcome>(ReferenceEqualityComparer.Instance);
|
||||
var session = new SetReleaseSession(_server.Sets, _server.Library, _server.Nests, _server.ServerUrl,
|
||||
ReadPackage, SheetSizeTrials.Write,
|
||||
async (group, _) =>
|
||||
{
|
||||
var made = await _server.CreateNestAsync(group);
|
||||
if (made.Warning != null)
|
||||
Warnings(made.Nest).Add(made.Warning);
|
||||
return made.Nest;
|
||||
},
|
||||
SheetSizeTrials.Read,
|
||||
!nestAfterRelease ? null : async (nest, token) =>
|
||||
{
|
||||
var outcome = await SheetSizeTrials.NestAsync(nest, sizes, ledger, engineName, token);
|
||||
trials[nest] = outcome;
|
||||
return new SetReleaseRenest(outcome.Nested, outcome.Note);
|
||||
});
|
||||
|
||||
var result = await session.RunAsync(plan, chosen, _server.UserName, notes ?? "", null, cancellationToken, merges);
|
||||
|
||||
var sb = new StringBuilder();
|
||||
if (result.Release != null)
|
||||
sb.AppendLine($"Release {result.Release.Id} recorded ({result.Created.Count} nest(s)).");
|
||||
else if (result.ReleaseError.Length > 0)
|
||||
sb.AppendLine($"Release NOT recorded: {result.ReleaseError}");
|
||||
else
|
||||
sb.AppendLine(result.Canceled ? "Canceled; the release was not recorded." : "The release was not recorded.");
|
||||
if (nestAfterRelease)
|
||||
sb.AppendLine($"Engine: {engineName}. MaterialLedger: {(ledger != null ? "offered first" : useLedger ? "not set up on this PC, sheet sizes only" : "not used")}.");
|
||||
foreach (var group in result.Groups)
|
||||
{
|
||||
sb.AppendLine();
|
||||
sb.AppendLine($"Group {group.Group.Key}: {group.Outcome}");
|
||||
if (group.Error.Length > 0)
|
||||
sb.AppendLine($" {group.Error}");
|
||||
if (group.Record != null)
|
||||
sb.AppendLine($" Nest {group.Record.Name} | id {group.Record.Id} | revision {group.Record.Revision}"
|
||||
+ (group.MergedInto != null ? $" | merged into revision {group.MergedInto.Revision}" : " | new"));
|
||||
if (group.Nest != null)
|
||||
{
|
||||
AppendLayout(sb, group.Nest, " ");
|
||||
if (trials.TryGetValue(group.Nest, out var outcome) && outcome.Trials.Count > 1)
|
||||
{
|
||||
sb.AppendLine($" Sheet sizes tried (chose {outcome.Chosen.Name}):");
|
||||
foreach (var trial in outcome.Trials)
|
||||
sb.AppendLine(" " + trial.Describe());
|
||||
}
|
||||
foreach (var warning in Warnings(group.Nest))
|
||||
sb.AppendLine($" Warning: {warning}");
|
||||
}
|
||||
foreach (var warning in group.Warnings)
|
||||
sb.AppendLine($" Note: {warning}");
|
||||
}
|
||||
foreach (var group in refused)
|
||||
sb.AppendLine($"\nGroup {group.Key}: not released: {group.Refusal}");
|
||||
return sb.ToString();
|
||||
});
|
||||
|
||||
[McpServerTool(Name = "renest_nest")]
|
||||
[Description("Re-nest a Draft or Quote nest on the nest server from scratch (every plate removed, every drawing's required quantity nested again), optionally on the best of several sheet sizes, and save it as a new revision only when every part is placed and a layout was kept; the save is refused if someone saved the nest since it was read.")]
|
||||
public Task<string> RenestNest(
|
||||
[Description("Nest id, or its exact name (e.g. N26-2CM)")] string nest,
|
||||
[Description(SheetSizesHelp)] string[] sheetSizes = null,
|
||||
[Description("Save the result as a new revision (default true); false only reports what it would be")] bool save = true,
|
||||
[Description("Offer MaterialLedger stock first when it is set up on this PC (default true)")] bool useLedger = true,
|
||||
[Description("Whole-job engine name (optional; default: the engine last chosen on the desktop)")] string engine = null,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
var engineName = _server.ResolveEngine(engine, out var engineError);
|
||||
if (engineName == null)
|
||||
return Error(engineError);
|
||||
var sizes = SheetSizes.Parse(sheetSizes, out var sizeError);
|
||||
if (sizes == null)
|
||||
return Error(sizeError);
|
||||
var (record, error) = await ResolveNestAsync(nest, cancellationToken);
|
||||
if (record == null)
|
||||
return Error(error);
|
||||
if (record.Status is not (NestStatus.Draft or NestStatus.Quote))
|
||||
return Error($"'{record.Name}' is {record.Status}; only Draft and Quote nests are re-nested.");
|
||||
var archive = await _server.Nests.GetFileAsync(record.Id, cancellationToken);
|
||||
if (archive == null)
|
||||
return Error($"'{record.Name}' has no archive on the server.");
|
||||
|
||||
var ledger = useLedger ? _server.CreateLedger(record.Id) : null;
|
||||
var (renested, outcome) = await SheetSizeTrials.NestCopyAsync(archive,
|
||||
copy => NestRecordFactory.ApplyMetadata(copy, record), sizes, ledger, engineName, cancellationToken);
|
||||
|
||||
var sb = new StringBuilder();
|
||||
sb.AppendLine($"{record.Name} | id {record.Id} | revision {record.Revision} | engine {engineName}");
|
||||
if (outcome.Trials.Count > 1)
|
||||
{
|
||||
sb.AppendLine($"Sheet sizes tried (chose {outcome.Chosen.Name}):");
|
||||
foreach (var trial in outcome.Trials)
|
||||
sb.AppendLine(" " + trial.Describe());
|
||||
}
|
||||
if (outcome.Note.Length > 0)
|
||||
sb.AppendLine($"Auto Nest: {outcome.Note}");
|
||||
AppendLayout(sb, renested, "");
|
||||
|
||||
if (!save)
|
||||
return sb.AppendLine("Not saved (save=false).").ToString();
|
||||
if (!outcome.Nested)
|
||||
return sb.AppendLine("Not saved: no layout was kept.").ToString();
|
||||
if (outcome.Chosen.Unplaced > 0)
|
||||
return sb.AppendLine($"Not saved: {outcome.Chosen.Unplaced} part(s) unplaced.").ToString();
|
||||
|
||||
var bytes = SheetSizeTrials.Write(renested);
|
||||
var saved = await _server.Nests.UpdateFileAsync(record.Id, bytes,
|
||||
NestRecordFactory.FromNest(renested, record.Id, bytes.LongLength), record.Revision, cancellationToken);
|
||||
return sb.AppendLine($"Saved revision {saved.Revision} ({saved.PlateCount} plate(s), {saved.PartCount} part(s)).").ToString();
|
||||
});
|
||||
|
||||
[McpServerTool(Name = "nest_summary")]
|
||||
[Description("A saved nest on the nest server: status, material, sheets with sizes and utilization, and each drawing's required and nested quantities.")]
|
||||
public Task<string> NestSummary(
|
||||
[Description("Nest id, or its exact name (e.g. N26-2CM)")] string nest,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
var (record, error) = await ResolveNestAsync(nest, cancellationToken);
|
||||
if (record == null)
|
||||
return Error(error);
|
||||
var archive = await _server.Nests.GetFileAsync(record.Id, cancellationToken);
|
||||
if (archive == null)
|
||||
return Error($"'{record.Name}' has no archive on the server.");
|
||||
var read = SheetSizeTrials.Read(archive);
|
||||
var sb = new StringBuilder();
|
||||
sb.AppendLine($"{record.Name} | id {record.Id} | revision {record.Revision} | {record.Status}");
|
||||
sb.AppendLine($"Material: {Material(record.Material, record.MaterialGrade, record.Thickness, read.Units)} | customer {Blank(record.Customer)} | made by {Blank(record.MadeBy)}");
|
||||
if (record.Comments.Length > 0)
|
||||
sb.AppendLine($"Comments: {record.Comments}");
|
||||
sb.AppendLine($"Plate defaults: {SheetSizes.Format(read.PlateDefaults.Size)}"
|
||||
+ (read.PlateOptions.Count > 0 ? $"; options {string.Join(", ", read.PlateOptions.Select(o => SheetSizes.Format(new Size(o.Width, o.Length))))}" : ""));
|
||||
AppendLayout(sb, read, "");
|
||||
sb.AppendLine("Drawings (required / nested):");
|
||||
foreach (var drawing in read.Drawings.Where(d => !d.IsCutOff).OrderBy(d => d.Name, StringComparer.OrdinalIgnoreCase))
|
||||
sb.AppendLine($" {drawing.Name}: {drawing.Quantity.Required} / {drawing.Quantity.Nested}");
|
||||
return sb.ToString();
|
||||
});
|
||||
|
||||
[McpServerTool(Name = "get_release")]
|
||||
[Description("One release by id: its sets and drawings, notes, and each nest it created or merged into, with undo state.")]
|
||||
public Task<string> GetRelease(
|
||||
[Description("Release id (make_nests prints it)")] string release,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
if (!Guid.TryParse(release, out var id))
|
||||
return Error($"'{release}' is not a release id.");
|
||||
var record = await _server.Sets.GetReleaseAsync(id, cancellationToken);
|
||||
return record == null ? Error($"Release {id} is not on the nest server.") : FormatRelease(record);
|
||||
});
|
||||
|
||||
[McpServerTool(Name = "undo_release")]
|
||||
[Description("Undo a release, all or nothing: nests it created are deleted (recoverable on the server) and drafts it merged into are restored to their earlier revision. Refused when a nest changed since the release unless that nest is listed in skipNests, which leaves it as it is.")]
|
||||
public Task<string> UndoRelease(
|
||||
[Description("Release id (make_nests prints it)")] string release,
|
||||
[Description("Nest ids to leave as they are because they changed since the release (optional)")] string[] skipNests = null,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
if (!Guid.TryParse(release, out var id))
|
||||
return Error($"'{release}' is not a release id.");
|
||||
var skip = new List<Guid>();
|
||||
foreach (var text in skipNests ?? Array.Empty<string>())
|
||||
{
|
||||
if (!Guid.TryParse(text, out var nestId))
|
||||
return Error($"'{text}' is not a nest id.");
|
||||
skip.Add(nestId);
|
||||
}
|
||||
try
|
||||
{
|
||||
var undone = await _server.Sets.UndoReleaseAsync(id,
|
||||
new SetReleaseUndoRequest { UndoneBy = _server.UserName, SkipNests = skip }, cancellationToken);
|
||||
return "Undone.\n" + FormatRelease(undone);
|
||||
}
|
||||
catch (SetReleaseUndoConflictException ex)
|
||||
{
|
||||
var sb = new StringBuilder();
|
||||
sb.AppendLine(ex.Conflict.Reason == SetReleaseUndoRefusal.AlreadyUndone
|
||||
? "Error: the release is already undone."
|
||||
: "Error: nothing was undone; these nests changed since the release (list them in skipNests to leave them as they are):");
|
||||
foreach (var changed in ex.Conflict.ChangedNests)
|
||||
sb.AppendLine($"- {changed.Name} | id {changed.Id} | now revision {changed.Revision}{(changed.Deleted ? " (deleted)" : "")}");
|
||||
return sb.ToString();
|
||||
}
|
||||
});
|
||||
|
||||
// --- Shared steps ---
|
||||
|
||||
private Task<string> SetArchivedAsync(string set, bool archive, CancellationToken cancellationToken) =>
|
||||
RunAsync(async () =>
|
||||
{
|
||||
var (current, error) = await ResolveSetAsync(set, cancellationToken);
|
||||
if (current == null)
|
||||
return Error(error);
|
||||
if (current.Archived == archive)
|
||||
return $"'{current.Name}' is already {(archive ? "archived" : "not archived")} (revision {current.Revision}).";
|
||||
var saved = archive
|
||||
? await _server.Sets.ArchiveAsync(current.Id, current.Revision, cancellationToken)
|
||||
: await _server.Sets.RestoreAsync(current.Id, current.Revision, cancellationToken);
|
||||
return $"{(archive ? "Archived" : "Restored")} '{saved.Name}' (id {saved.Id}, revision {saved.Revision}).";
|
||||
});
|
||||
|
||||
private async Task<(SetReleasePlan Plan, string Error)> BuildPlanAsync(ReleaseSetInput[] sets,
|
||||
DrawingQuantityInput[] drawings, bool includeArchived, CancellationToken cancellationToken)
|
||||
{
|
||||
sets ??= Array.Empty<ReleaseSetInput>();
|
||||
drawings ??= Array.Empty<DrawingQuantityInput>();
|
||||
if (sets.Length == 0 && drawings.Length == 0)
|
||||
return (null, "Give at least one set or drawing to release.");
|
||||
var lines = new List<SetReleasePlanLine>();
|
||||
foreach (var line in sets)
|
||||
{
|
||||
var (set, error) = await ResolveSetAsync(line?.Set, cancellationToken);
|
||||
if (set == null)
|
||||
return (null, error);
|
||||
lines.Add(new SetReleasePlanLine(set, line.Quantity));
|
||||
}
|
||||
var own = new List<SetReleaseDrawingLine>();
|
||||
foreach (var line in drawings)
|
||||
{
|
||||
var (drawing, error) = await ResolveDrawingAsync(line?.Drawing, cancellationToken);
|
||||
if (drawing == null)
|
||||
return (null, error);
|
||||
own.Add(new SetReleaseDrawingLine(drawing, line.Quantity));
|
||||
}
|
||||
try
|
||||
{
|
||||
return (SetReleasePlan.Build(lines, own, includeArchived), null);
|
||||
}
|
||||
catch (ArgumentException ex)
|
||||
{
|
||||
return (null, ex.Message);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task AppendPlanAsync(StringBuilder sb, SetReleasePlan plan, CancellationToken cancellationToken)
|
||||
{
|
||||
sb.AppendLine($"Customer: {Blank(plan.Customer)}");
|
||||
foreach (var line in plan.Lines)
|
||||
sb.AppendLine($"Set {line.Set.Name} (rev {line.Set.Revision}) x {line.Quantity}");
|
||||
foreach (var line in plan.Drawings)
|
||||
sb.AppendLine($"Drawing {line.Drawing.Name} x {line.Quantity}");
|
||||
foreach (var skipped in plan.SkippedArchived)
|
||||
sb.AppendLine($"Skipped (archived): {skipped.Drawing?.Name ?? skipped.DrawingId.ToString()}");
|
||||
foreach (var group in plan.Groups)
|
||||
{
|
||||
sb.AppendLine();
|
||||
sb.AppendLine($"Group {group.Key}: {(group.CanRelease ? "can be released" : "REFUSED: " + group.Refusal)}");
|
||||
sb.AppendLine($" {Material(group.MaterialName, group.MaterialGrade, group.Thickness, group.Units)} {group.CutType.ToString().ToLowerInvariant()}, {group.TotalQuantity} part(s)");
|
||||
foreach (var item in group.Items)
|
||||
sb.AppendLine($" - {item.Drawing.Name} x {item.Quantity} | id {item.Drawing.Id} rev {item.Drawing.Revision}"
|
||||
+ Size(item.Drawing.Geometry));
|
||||
foreach (var warning in group.Warnings)
|
||||
sb.AppendLine($" Warning: {warning}");
|
||||
if (!group.CanRelease)
|
||||
continue;
|
||||
var drafts = await SetReleasePlan.FindDraftsAsync(_server.Nests, group, 20, cancellationToken);
|
||||
sb.AppendLine(drafts.Count == 0
|
||||
? " Drafts to merge into: none (a new nest is made)"
|
||||
: " Drafts to merge into (optional): " + string.Join("; ",
|
||||
drafts.Select(d => $"{d.Name} id {d.Id} rev {d.Revision}, {d.PlateCount} plate(s), {d.PartCount} part(s)")));
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<(List<DrawingSetMember> Members, string Error)> ResolveMembersAsync(
|
||||
DrawingQuantityInput[] members, CancellationToken cancellationToken)
|
||||
{
|
||||
if (members == null || members.Length == 0)
|
||||
return (null, "A set needs at least one member.");
|
||||
var resolved = new List<DrawingSetMember>();
|
||||
foreach (var member in members)
|
||||
{
|
||||
var (drawing, error) = await ResolveDrawingAsync(member?.Drawing, cancellationToken);
|
||||
if (drawing == null)
|
||||
return (null, error);
|
||||
if (member.Quantity < 1 || member.Quantity > DrawingSetRules.MaxQuantity)
|
||||
return (null, $"'{drawing.Name}' needs a quantity from 1 to {DrawingSetRules.MaxQuantity}.");
|
||||
if (resolved.Any(m => m.DrawingId == drawing.Id))
|
||||
return (null, $"'{drawing.Name}' is listed twice. List it once with a larger quantity.");
|
||||
resolved.Add(new DrawingSetMember { DrawingId = drawing.Id, Quantity = member.Quantity });
|
||||
}
|
||||
return (resolved, null);
|
||||
}
|
||||
|
||||
private async Task<(DrawingLibraryRecord Record, string Error)> ResolveDrawingAsync(string drawing,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(drawing))
|
||||
return (null, "A drawing id or name is required.");
|
||||
drawing = drawing.Trim();
|
||||
if (Guid.TryParse(drawing, out var id))
|
||||
{
|
||||
var record = await _server.Library.GetAsync(id, cancellationToken);
|
||||
return record == null ? (null, $"No library drawing has id {id}.") : (record, null);
|
||||
}
|
||||
var page = await _server.Library.QueryAsync(new DrawingLibraryQuery
|
||||
{
|
||||
Search = drawing,
|
||||
IncludeArchived = true,
|
||||
Limit = DrawingLibraryQuery.MaxLimit,
|
||||
}, cancellationToken);
|
||||
var exact = page.Items.Where(d => string.Equals(d.Name, drawing, StringComparison.OrdinalIgnoreCase)).ToList();
|
||||
if (exact.Count > 1 && exact.Count(d => !d.Archived) == 1)
|
||||
exact = exact.Where(d => !d.Archived).ToList();
|
||||
return exact.Count switch
|
||||
{
|
||||
1 => (exact[0], null),
|
||||
0 => (null, $"No library drawing is named '{drawing}'." + Similar(page.Items.Select(d => d.Name))),
|
||||
_ => (null, $"{exact.Count} library drawings are named '{drawing}'; use an id: "
|
||||
+ string.Join("; ", exact.Select(DescribeDrawing))),
|
||||
};
|
||||
}
|
||||
|
||||
private async Task<List<DrawingSetRecord>> FindSetsByNameAsync(string name, CancellationToken cancellationToken)
|
||||
{
|
||||
var page = await _server.Sets.QueryAsync(new DrawingSetQuery
|
||||
{
|
||||
Search = name,
|
||||
IncludeArchived = true,
|
||||
Limit = DrawingSetQuery.MaxLimit,
|
||||
}, cancellationToken);
|
||||
return page.Items.Where(s => string.Equals(s.Name, name, StringComparison.OrdinalIgnoreCase)).ToList();
|
||||
}
|
||||
|
||||
private async Task<(DrawingSetRecord Record, string Error)> ResolveSetAsync(string set, CancellationToken cancellationToken)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(set))
|
||||
return (null, "A set id or name is required.");
|
||||
set = set.Trim();
|
||||
Guid id;
|
||||
if (!Guid.TryParse(set, out id))
|
||||
{
|
||||
var exact = await FindSetsByNameAsync(set, cancellationToken);
|
||||
if (exact.Count > 1 && exact.Count(s => !s.Archived) == 1)
|
||||
exact = exact.Where(s => !s.Archived).ToList();
|
||||
if (exact.Count == 0)
|
||||
{
|
||||
var near = await _server.Sets.QueryAsync(new DrawingSetQuery { Search = set, IncludeArchived = true, Limit = 10 }, cancellationToken);
|
||||
return (null, $"No drawing set is named '{set}'." + Similar(near.Items.Select(s => s.Name)));
|
||||
}
|
||||
if (exact.Count > 1)
|
||||
return (null, $"{exact.Count} sets are named '{set}'; use an id: " + string.Join("; ", exact.Select(DescribeSet)));
|
||||
id = exact[0].Id;
|
||||
}
|
||||
var record = await _server.Sets.GetAsync(id, cancellationToken);
|
||||
return record == null ? (null, $"No drawing set has id {id}.") : (record, null);
|
||||
}
|
||||
|
||||
private async Task<(NestRecord Record, string Error)> ResolveNestAsync(string nest, CancellationToken cancellationToken)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(nest))
|
||||
return (null, "A nest id or name is required.");
|
||||
nest = nest.Trim();
|
||||
if (Guid.TryParse(nest, out var id))
|
||||
{
|
||||
var record = await _server.Nests.GetMetadataAsync(id, cancellationToken);
|
||||
return record == null || record.Deleted ? (null, $"No nest has id {id}.") : (record, null);
|
||||
}
|
||||
var page = await _server.Nests.QueryAsync(new NestQuery { Search = nest, Limit = NestQuery.MaxLimit }, cancellationToken);
|
||||
var exact = page.Items.Where(n => !n.Deleted && string.Equals(n.Name, nest, StringComparison.OrdinalIgnoreCase)).ToList();
|
||||
return exact.Count switch
|
||||
{
|
||||
1 => (exact[0], null),
|
||||
0 => (null, $"No nest is named '{nest}'." + Similar(page.Items.Select(n => n.Name))),
|
||||
_ => (null, $"{exact.Count} nests are named '{nest}'; use an id: "
|
||||
+ string.Join("; ", exact.Select(n => $"{n.Name} id {n.Id} ({n.Status}, saved {n.SavedAt:yyyy-MM-dd})"))),
|
||||
};
|
||||
}
|
||||
|
||||
private static LibraryPackage ReadPackage(byte[] bytes)
|
||||
{
|
||||
var contents = OpenNest.IO.DrawingPackage.Read(bytes);
|
||||
return new LibraryPackage(bytes, contents.Drawing, contents.Units, contents.Warnings);
|
||||
}
|
||||
|
||||
// Warnings raised while making a nest (File > New's unreadable defaults), by nest.
|
||||
private readonly Dictionary<Nest, List<string>> _nestWarnings = new(ReferenceEqualityComparer.Instance);
|
||||
|
||||
private List<string> Warnings(Nest nest)
|
||||
{
|
||||
if (!_nestWarnings.TryGetValue(nest, out var list))
|
||||
_nestWarnings[nest] = list = new List<string>();
|
||||
return list;
|
||||
}
|
||||
|
||||
private async Task<string> RunAsync(Func<Task<string>> action)
|
||||
{
|
||||
if (_server.Error != null)
|
||||
return Error(_server.Error);
|
||||
try
|
||||
{
|
||||
return await action();
|
||||
}
|
||||
catch (DrawingSetSaveConflictException ex)
|
||||
{
|
||||
return Error($"Someone saved the set since it was read (now revision {ex.Current.Revision}); nothing was changed. Try again.");
|
||||
}
|
||||
catch (Exception ex) when (ex is not OperationCanceledException)
|
||||
{
|
||||
return Error(ex.Message);
|
||||
}
|
||||
finally
|
||||
{
|
||||
_nestWarnings.Clear();
|
||||
}
|
||||
}
|
||||
|
||||
// --- Formatting ---
|
||||
|
||||
private static string Error(string message) => "Error: " + message;
|
||||
|
||||
private static string Blank(string text) => string.IsNullOrWhiteSpace(text) ? "(none)" : text;
|
||||
|
||||
private static string Number(double value) => value.ToString("0.####", CultureInfo.InvariantCulture);
|
||||
|
||||
private static string Material(string name, string grade, double thickness, Units units) =>
|
||||
string.Join(" ", new[] { name, grade, $"{Number(thickness)} {(units == Units.Millimeters ? "mm" : "in")}" }
|
||||
.Where(s => !string.IsNullOrWhiteSpace(s)));
|
||||
|
||||
private static string Size(DrawingGeometrySummary geometry) =>
|
||||
geometry is { IsMeasured: true } ? $" | {Number(geometry.Length)} x {Number(geometry.Width)}" : "";
|
||||
|
||||
private static string Similar(IEnumerable<string> names)
|
||||
{
|
||||
var list = names.Distinct(StringComparer.OrdinalIgnoreCase).Take(10).ToList();
|
||||
return list.Count == 0 ? "" : " Similar: " + string.Join(", ", list) + ".";
|
||||
}
|
||||
|
||||
private static string DescribeDrawing(DrawingLibraryRecord d) =>
|
||||
$"{d.Name} | id {d.Id} rev {d.Revision} | customer {Blank(d.Customer)} | "
|
||||
+ $"{Material(d.MaterialName, d.MaterialGrade, d.Thickness, d.Units)} {d.CutType.ToString().ToLowerInvariant()}"
|
||||
+ Size(d.Geometry) + (d.Archived ? " | archived" : "");
|
||||
|
||||
private static string DescribeSet(DrawingSetRecord s) =>
|
||||
$"{s.Name} | id {s.Id} rev {s.Revision} | customer {Blank(s.Customer)} | {s.MemberCount} member(s)"
|
||||
+ (s.Archived ? " | archived" : "");
|
||||
|
||||
private static string FormatSet(DrawingSetRecord set)
|
||||
{
|
||||
var sb = new StringBuilder();
|
||||
sb.AppendLine($"{set.Name} | id {set.Id} | revision {set.Revision} | customer {Blank(set.Customer)}{(set.Archived ? " | archived" : "")}");
|
||||
sb.AppendLine($"Saved {set.SavedAt:yyyy-MM-dd HH:mm} by {Blank(set.SavedBy)}");
|
||||
if (set.Notes.Length > 0)
|
||||
sb.AppendLine($"Notes: {set.Notes}");
|
||||
sb.AppendLine($"Members ({set.Members.Count}), quantity per kit:");
|
||||
foreach (var member in set.Members)
|
||||
sb.AppendLine(member.Drawing == null
|
||||
? $"- x{member.Quantity} drawing {member.DrawingId} (not in the library)"
|
||||
: $"- x{member.Quantity} {DescribeDrawing(member.Drawing)}");
|
||||
return sb.ToString();
|
||||
}
|
||||
|
||||
private static string FormatRelease(SetReleaseRecord release)
|
||||
{
|
||||
var sb = new StringBuilder();
|
||||
sb.AppendLine($"Release {release.Id} | {release.ReleasedAt:yyyy-MM-dd HH:mm} by {Blank(release.ReleasedBy)}"
|
||||
+ (release.IsUndone ? $" | undone {release.UndoneAt:yyyy-MM-dd HH:mm} by {Blank(release.UndoneBy)}" : ""));
|
||||
if (release.Notes.Length > 0)
|
||||
sb.AppendLine($"Notes: {release.Notes}");
|
||||
foreach (var line in release.Sets)
|
||||
sb.AppendLine($"Set {Blank(line.SetName)} (id {line.SetId} rev {line.SetRevision}) x {line.Quantity}");
|
||||
foreach (var line in release.Drawings)
|
||||
sb.AppendLine($"Drawing {Blank(line.DrawingName)} (id {line.DrawingId}) x {line.Quantity}");
|
||||
foreach (var nest in release.Nests)
|
||||
sb.AppendLine($"Nest {nest.Nest?.Name ?? "?"} | id {nest.NestId} | {nest.Kind} | revision {(nest.RevisionBefore is { } before ? before + " -> " : "")}{nest.RevisionAfter}"
|
||||
+ $" | {Material(nest.MaterialName, nest.MaterialGrade, nest.Thickness, nest.Units)}"
|
||||
+ (nest.Undo is { } undo ? $" | undo: {undo}" : ""));
|
||||
return sb.ToString();
|
||||
}
|
||||
|
||||
private static void AppendLayout(StringBuilder sb, Nest nest, string indent)
|
||||
{
|
||||
var trial = SheetSizeTrials.Measure(nest, null, nest.Plates.Count > 0, "");
|
||||
if (nest.Plates.Count == 0)
|
||||
sb.AppendLine($"{indent}Not nested: no sheets.");
|
||||
else
|
||||
{
|
||||
sb.AppendLine(string.Format(CultureInfo.InvariantCulture,
|
||||
"{0}Sheets: {1} physical, {2:0.##} sq total, {3:P1} used", indent, trial.Sheets, trial.SheetArea, trial.Utilization));
|
||||
for (var i = 0; i < nest.Plates.Count; i++)
|
||||
{
|
||||
var plate = nest.Plates[i];
|
||||
sb.AppendLine(string.Format(CultureInfo.InvariantCulture,
|
||||
"{0} Plate {1}: {2} x{3}, {4} part(s) each, {5:P1} used{6}", indent, i + 1,
|
||||
SheetSizes.Format(plate.Size), plate.Quantity, plate.Parts.Count(p => !p.BaseDrawing.IsCutOff),
|
||||
plate.Utilization(),
|
||||
plate.StockItemCodes.Count > 0 ? $", ledger {string.Join(",", plate.StockItemCodes)}" : ""));
|
||||
}
|
||||
}
|
||||
var drawings = nest.Drawings.Where(d => !d.IsCutOff).ToList();
|
||||
sb.AppendLine($"{indent}Parts: {drawings.Sum(d => d.Quantity.Required)} required, {drawings.Sum(d => System.Math.Min(d.Quantity.Nested, d.Quantity.Required))} nested");
|
||||
var unplaced = drawings.Where(d => d.Quantity.Remaining > 0).ToList();
|
||||
if (unplaced.Count > 0)
|
||||
sb.AppendLine($"{indent}Unplaced: " + string.Join(", ", unplaced.Select(d => $"{d.Name} x{d.Quantity.Remaining}")));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,271 @@
|
||||
extern alias mcp;
|
||||
|
||||
using mcp::OpenNest.Mcp.Database;
|
||||
using mcp::OpenNest.Mcp.Tools;
|
||||
using OpenNest.Data;
|
||||
using OpenNest.Desktop;
|
||||
using OpenNest.Geometry;
|
||||
using OpenNest.IO;
|
||||
using OpenNest.Shapes;
|
||||
|
||||
namespace OpenNest.Server.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// The MCP nest server tools against the in-process server: sets made from library drawings
|
||||
/// by name, a release planned and made into nested, server-named Draft nests on the best of
|
||||
/// several sheet sizes, a merge into a draft, a guarded re-nest and undo.
|
||||
/// </summary>
|
||||
public sealed class McpNestServerToolsTests
|
||||
{
|
||||
private sealed class Server : IDisposable
|
||||
{
|
||||
public Server()
|
||||
{
|
||||
Factory = new ServerFactory();
|
||||
Client = Factory.CreateClient();
|
||||
Url = Client.BaseAddress!.ToString();
|
||||
Library = new RemoteDrawingLibrary(Client, Url);
|
||||
Sets = new RemoteDrawingSetStore(Client, Url);
|
||||
Nests = new RemoteNestRepository(Client, Url);
|
||||
var directory = Path.Combine(Factory.DirectoryPath, "desktop");
|
||||
Directory.CreateDirectory(directory);
|
||||
var userSettings = Path.Combine(directory, "user-settings.json");
|
||||
var machines = new MachineSettingsSource(
|
||||
new SharedSettingsSource(() => new NestStorageSettings(), _ => throw new InvalidOperationException("File mode")),
|
||||
new MachineUserSettingsFile(userSettings), Path.Combine(directory, "Machines"),
|
||||
Path.Combine(directory, "defaults.json"), Path.Combine(directory, "clamps.json"),
|
||||
Path.Combine(directory, "grid.json"));
|
||||
var newNests = new NewNestSource(machines, new NewNestUserSettingsFile(userSettings), () => Nests);
|
||||
Context = new NestServerContext(Url, Library, Sets, Nests, group => newNests.CreateAsync(group),
|
||||
() => "Rectangles", null, "Synthetic operator");
|
||||
Tools = new NestServerTools(Context);
|
||||
}
|
||||
|
||||
public ServerFactory Factory { get; }
|
||||
public HttpClient Client { get; }
|
||||
public string Url { get; }
|
||||
public RemoteDrawingLibrary Library { get; }
|
||||
public RemoteDrawingSetStore Sets { get; }
|
||||
public RemoteNestRepository Nests { get; }
|
||||
public NestServerContext Context { get; }
|
||||
public NestServerTools Tools { get; }
|
||||
|
||||
public async Task<DrawingLibraryRecord> StoreAsync(string name, double length, string material)
|
||||
{
|
||||
var drawing = new RectangleShape { Name = name, Length = length, Width = 2 }.GetDrawing();
|
||||
return await Library.UploadAsync(new DrawingLibraryRecord
|
||||
{
|
||||
Id = Guid.NewGuid(),
|
||||
Name = name,
|
||||
Customer = "Synthetic customer",
|
||||
MaterialName = material,
|
||||
MaterialGrade = "Grade A",
|
||||
Thickness = 0.25,
|
||||
Units = Units.Inches,
|
||||
CutType = CutType.Laser,
|
||||
SavedBy = "Synthetic operator",
|
||||
}, DrawingPackage.Write(drawing, Units.Inches));
|
||||
}
|
||||
|
||||
public async Task<Nest> ReadAsync(Guid id)
|
||||
{
|
||||
using var stream = new MemoryStream((await Nests.GetFileAsync(id))!, writable: false);
|
||||
return new NestReader(stream).Read();
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
Nests.Dispose();
|
||||
Sets.Dispose();
|
||||
Library.Dispose();
|
||||
Client.Dispose();
|
||||
Factory.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
private static DrawingQuantityInput Member(string drawing, int quantity) => new() { Drawing = drawing, Quantity = quantity };
|
||||
|
||||
[Fact]
|
||||
public async Task Sets_AreMadeFromDrawingNames_AndSavedOverTheirCurrentRevision()
|
||||
{
|
||||
using var server = new Server();
|
||||
var a = await server.StoreAsync("SYN-A", 4, "Synthetic Steel");
|
||||
await server.StoreAsync("SYN-B", 5, "Synthetic Steel");
|
||||
|
||||
var created = await server.Tools.CreateSet("Synthetic kit", new[] { Member("syn-a", 3), Member("SYN-B", 1) },
|
||||
"Synthetic set customer", "Synthetic notes");
|
||||
Assert.StartsWith("Created set.", created);
|
||||
var set = (await server.Sets.QueryAsync(new DrawingSetQuery { Search = "Synthetic kit" })).Items.Single();
|
||||
Assert.Contains($"id {set.Id}", created);
|
||||
Assert.Contains("x3 SYN-A", created);
|
||||
|
||||
Assert.StartsWith("Error: A set named 'Synthetic kit' already exists",
|
||||
await server.Tools.CreateSet("synthetic kit", new[] { Member("SYN-A", 1) }));
|
||||
Assert.StartsWith("Error: No library drawing is named 'SYN-Z'",
|
||||
await server.Tools.CreateSet("Other kit", new[] { Member("SYN-Z", 1) }));
|
||||
Assert.StartsWith("Error:", await server.Tools.CreateSet("Other kit", new[] { Member("SYN-A", 1), Member(a.Id.ToString(), 2) }));
|
||||
|
||||
var updated = await server.Tools.UpdateSet("Synthetic kit", notes: "Changed notes",
|
||||
members: new[] { Member(a.Id.ToString(), 5) });
|
||||
Assert.StartsWith("Saved revision 2.", updated);
|
||||
var stored = (await server.Sets.GetAsync(set.Id))!;
|
||||
Assert.Equal(("Changed notes", "Synthetic set customer", 5), (stored.Notes, stored.Customer, stored.Members.Single().Quantity));
|
||||
|
||||
Assert.StartsWith("Archived 'Synthetic kit'", await server.Tools.ArchiveSet(set.Id.ToString()));
|
||||
Assert.True((await server.Sets.GetAsync(set.Id))!.Archived);
|
||||
Assert.Contains("already archived", await server.Tools.ArchiveSet("Synthetic kit"));
|
||||
Assert.StartsWith("Restored 'Synthetic kit'", await server.Tools.RestoreSet("Synthetic kit"));
|
||||
Assert.False((await server.Sets.GetAsync(set.Id))!.Archived);
|
||||
|
||||
var found = await server.Tools.SearchDrawings(search: "SYN", material: "Synthetic Steel");
|
||||
Assert.StartsWith("2 of 2 drawings", found);
|
||||
Assert.Contains("In 1 set(s):", await server.Tools.GetDrawing("SYN-A"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MakeNests_ReleasesNestedServerNamedDrafts_MergesRenestsAndUndoes()
|
||||
{
|
||||
using var server = new Server();
|
||||
var a = await server.StoreAsync("SYN-A", 4, "Synthetic Steel");
|
||||
var b = await server.StoreAsync("SYN-B", 5, "Synthetic Steel");
|
||||
var c = await server.StoreAsync("SYN-C", 6, "Synthetic Aluminum");
|
||||
Assert.StartsWith("Created set.", await server.Tools.CreateSet("Synthetic kit",
|
||||
new[] { Member("SYN-A", 3), Member("SYN-B", 1), Member("SYN-C", 2) }, "Synthetic set customer"));
|
||||
var kit = new[] { new ReleaseSetInput { Set = "Synthetic kit", Quantity = 2 } };
|
||||
var steelKey = SetReleasePlan.GroupKey(a);
|
||||
var aluminumKey = SetReleasePlan.GroupKey(c);
|
||||
|
||||
var plan = await server.Tools.PlanRelease(kit);
|
||||
Assert.Contains($"Group {steelKey}: can be released", plan);
|
||||
Assert.Contains($"Group {aluminumKey}: can be released", plan);
|
||||
Assert.Contains("SYN-A x 6", plan);
|
||||
Assert.Contains("Drafts to merge into: none", plan);
|
||||
Assert.Empty((await server.Nests.ListAsync()));
|
||||
|
||||
Assert.StartsWith("Error: Sheet size 'big'", await server.Tools.MakeNests(kit, sheetSizes: new[] { "big" }));
|
||||
Assert.StartsWith("Error: Unknown engine", await server.Tools.MakeNests(kit, engine: "No such engine"));
|
||||
Assert.Empty((await server.Nests.ListAsync()));
|
||||
|
||||
var made = await server.Tools.MakeNests(kit, notes: "Synthetic job", sheetSizes: new[] { "12x12", "48x48" });
|
||||
var release = (await server.Sets.QueryReleasesAsync()).Items.Single();
|
||||
Assert.StartsWith($"Release {release.Id} recorded (2 nest(s)).", made);
|
||||
Assert.Equal("Synthetic job", release.Notes);
|
||||
Assert.Contains("Sheet sizes tried (chose ", made);
|
||||
var year = DateTime.Now.Year;
|
||||
var names = new HashSet<string>();
|
||||
foreach (var released in release.Nests)
|
||||
{
|
||||
var record = (await server.Nests.GetMetadataAsync(released.NestId))!;
|
||||
names.Add(record.Name);
|
||||
Assert.Equal(NestStatus.Draft, record.Status);
|
||||
Assert.Contains($"Nest {record.Name} | id {record.Id} | revision 1 | new", made);
|
||||
var nest = await server.ReadAsync(record.Id);
|
||||
Assert.NotEmpty(nest.Plates);
|
||||
Assert.All(nest.Drawings, d => Assert.Equal(0, d.Quantity.Remaining));
|
||||
Assert.All(nest.Plates, p => Assert.Contains(SheetSizes.Format(p.Size), new[] { "12x12", "48x48" }));
|
||||
}
|
||||
Assert.Equal(new HashSet<string> { NestNames.Format(year, 1), NestNames.Format(year, 2) }, names);
|
||||
var steelId = release.Nests.Single(n => n.MaterialName == "Synthetic Steel").NestId;
|
||||
var steelName = (await server.Nests.GetMetadataAsync(steelId))!.Name;
|
||||
|
||||
// A drawing on its own merges into the steel draft, which the plan offers.
|
||||
Assert.Contains($"Drafts to merge into (optional): {steelName} id {steelId} rev 1",
|
||||
await server.Tools.PlanRelease(drawings: new[] { Member("SYN-A", 1) }));
|
||||
var merged = await server.Tools.MakeNests(drawings: new[] { Member("SYN-A", 1) },
|
||||
merge: new[] { new MergeInput { Group = steelKey, Draft = steelName } });
|
||||
Assert.Contains($"Nest {steelName} | id {steelId} | revision 2 | merged into revision 1", merged);
|
||||
Assert.Equal(7, (await server.ReadAsync(steelId)).Drawings.Single(d => d.Name == "SYN-A").Quantity.Required);
|
||||
var mergeRelease = (await server.Sets.QueryReleasesAsync(drawingId: a.Id)).Items.Single();
|
||||
|
||||
// Too small a sheet leaves parts unplaced, so nothing is saved.
|
||||
var tooSmall = await server.Tools.RenestNest(steelName, new[] { "3x3" });
|
||||
Assert.Contains("Not saved", tooSmall);
|
||||
Assert.Equal(2, (await server.Nests.GetMetadataAsync(steelId))!.Revision);
|
||||
Assert.Contains("Not saved (save=false)", await server.Tools.RenestNest(steelId.ToString(), new[] { "48x48" }, save: false));
|
||||
Assert.Equal(2, (await server.Nests.GetMetadataAsync(steelId))!.Revision);
|
||||
|
||||
var renested = await server.Tools.RenestNest(steelName, new[] { "48x48" });
|
||||
Assert.Contains("Saved revision 3", renested);
|
||||
var resized = await server.ReadAsync(steelId);
|
||||
Assert.All(resized.Plates, p => Assert.Equal("48x48", SheetSizes.Format(p.Size)));
|
||||
Assert.All(resized.Drawings, d => Assert.Equal(0, d.Quantity.Remaining));
|
||||
Assert.Equal(NestStatus.Draft, resized.Status);
|
||||
var summary = await server.Tools.NestSummary(steelName);
|
||||
Assert.Contains("revision 3 | Draft", summary);
|
||||
Assert.Contains("SYN-A: 7 / 7", summary);
|
||||
Assert.Contains("SYN-B: 2 / 2", summary);
|
||||
// The merged draft changed after the merge, so undo is refused until it is skipped.
|
||||
var refused = await server.Tools.UndoRelease(mergeRelease.Id.ToString());
|
||||
Assert.StartsWith("Error: nothing was undone", refused);
|
||||
Assert.Contains(steelId.ToString(), refused);
|
||||
Assert.StartsWith("Error:", await server.Tools.UndoRelease(release.Id.ToString()));
|
||||
var undone = await server.Tools.UndoRelease(release.Id.ToString(), new[] { steelId.ToString() });
|
||||
Assert.StartsWith("Undone.", undone);
|
||||
var aluminumId = release.Nests.Single(n => n.MaterialName == "Synthetic Aluminum").NestId;
|
||||
Assert.Null(await server.Nests.GetMetadataAsync(aluminumId));
|
||||
Assert.Equal(3, (await server.Nests.GetMetadataAsync(steelId))!.Revision);
|
||||
Assert.Contains("undo: Deleted", await server.Tools.GetRelease(release.Id.ToString()));
|
||||
_ = b;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MakeNests_RefusesEveryGroupWhenOneCannotBeReleased()
|
||||
{
|
||||
using var server = new Server();
|
||||
await server.StoreAsync("SYN-A", 4, "Synthetic Steel");
|
||||
var unassigned = await server.StoreAsync("SYN-U", 4, "");
|
||||
|
||||
var result = await server.Tools.MakeNests(drawings: new[] { Member("SYN-A", 1), Member(unassigned.Id.ToString(), 1) });
|
||||
|
||||
Assert.StartsWith("Error: nothing was released.", result);
|
||||
Assert.Contains("no material or thickness", result);
|
||||
Assert.Empty(await server.Nests.ListAsync());
|
||||
var partial = await server.Tools.MakeNests(drawings: new[] { Member("SYN-A", 1), Member(unassigned.Id.ToString(), 1) },
|
||||
skipRefusedGroups: true, nestAfterRelease: false);
|
||||
Assert.Contains("recorded (1 nest(s))", partial);
|
||||
Assert.Contains("not released:", partial);
|
||||
Assert.Single(await server.Nests.ListAsync());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SheetSizes_ParseWidthByLength_AndRejectOthers()
|
||||
{
|
||||
var sizes = SheetSizes.Parse(new[] { "60x120", " 72 X 144 ", "60*120", "12.5x48" }, out var error);
|
||||
Assert.Null(error);
|
||||
Assert.Equal(new[] { "60x120", "72x144", "12.5x48" }, sizes.Select(SheetSizes.Format));
|
||||
foreach (var bad in new[] { "60", "0x10", "-1x5", "ax5", "1x2x3", "NaNx4" })
|
||||
{
|
||||
Assert.Null(SheetSizes.Parse(new[] { bad }, out error));
|
||||
Assert.Contains(bad, error);
|
||||
}
|
||||
Assert.Empty(SheetSizes.Parse(null, out _));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SheetTrials_RankKeptThenUnplacedThenSheetsThenArea()
|
||||
{
|
||||
var choice = SheetChoice.Single(new Size(60, 120));
|
||||
SheetTrial Trial(bool kept, int unplaced, int sheets, double area) => new(choice, kept, unplaced, sheets, area, 0, "");
|
||||
var trials = new List<SheetTrial>
|
||||
{
|
||||
Trial(false, 0, 0, 0),
|
||||
Trial(true, 0, 3, 3 * 7200),
|
||||
Trial(true, 1, 1, 7200),
|
||||
Trial(true, 0, 1, 72 * 144),
|
||||
Trial(true, 0, 1, 7200),
|
||||
};
|
||||
trials.Sort(SheetTrial.Compare);
|
||||
Assert.Equal(new[] { (true, 0, 1, 7200.0), (true, 0, 1, 72 * 144.0), (true, 0, 3, 3 * 7200.0), (true, 1, 1, 7200.0), (false, 0, 0, 0.0) },
|
||||
trials.Select(t => (t.Kept, t.Unplaced, t.Sheets, t.SheetArea)));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Tools_ReportWhenThereIsNoNestServer()
|
||||
{
|
||||
var tools = new NestServerTools(NestServerContextWithoutServer());
|
||||
Assert.StartsWith("Error: OpenNest is not in Database mode", await tools.SearchSets());
|
||||
}
|
||||
|
||||
// File mode, as storage.json says when the desktop has no nest server.
|
||||
private static NestServerContext NestServerContextWithoutServer() => NestServerContext.FromStorage(new NestStorageSettings());
|
||||
}
|
||||
@@ -27,6 +27,8 @@
|
||||
<ProjectReference Include="..\OpenNest.IO\OpenNest.IO.csproj" />
|
||||
<!-- Server nesting end to end: the worker solves a job queued through the in-memory server. -->
|
||||
<ProjectReference Include="..\OpenNest.Server.Worker\OpenNest.Server.Worker.csproj" />
|
||||
<!-- The MCP nest server tools end to end. Aliased: its top-level Program would clash with the server's. -->
|
||||
<ProjectReference Include="..\OpenNest.Mcp\OpenNest.Mcp.csproj" Aliases="mcp" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
@@ -0,0 +1,109 @@
|
||||
# MCP nest server tools
|
||||
|
||||
`OpenNest.Mcp` has Database-mode tools beside its local `.nest` tools: an agent can go from
|
||||
"these sets × these quantities" to saved, nested Draft nests on the nest server in one or two
|
||||
calls, the same nests the desktop's **Make Nests** makes ([release panel](nest-storage.md#make-nests-the-release-panel-desktop)).
|
||||
They live in `OpenNest.Mcp/Tools/NestServerTools.cs`; the release itself is
|
||||
`OpenNest.Data.SetReleaseSession`, unchanged.
|
||||
|
||||
## Setup
|
||||
|
||||
The tools read this PC's desktop settings when first used (`NestServerContext.Load`):
|
||||
|
||||
- `%APPDATA%\OpenNest\storage.json` must be in Database mode with a server URL; otherwise
|
||||
every tool returns `Error: OpenNest is not in Database mode...`.
|
||||
- New nests are made as File > New makes them (`OpenNest.Desktop.NewNestSource`): nest
|
||||
defaults and machines from the server's shared copy or this PC's files
|
||||
(`SharedSettingsSource`, `MachineSettingsSource`), the group's units, material, thickness
|
||||
and machine spacing, and a server-allocated name. The local counter in
|
||||
`user-settings.json` is the fallback, as on the desktop.
|
||||
- Auto Nest uses the engine saved in `engine-selection.json` (the desktop's last choice)
|
||||
unless a call names one, with `Nest.DefaultMinimumRemnantDimension`.
|
||||
- MaterialLedger stock is offered first when `material-ledger.json` is set up for this
|
||||
Windows user (the key is DPAPI-protected); otherwise the nests use sheet sizes only and the
|
||||
result says so.
|
||||
- `SavedBy`, `ReleasedBy` and `UndoneBy` are the Windows user name.
|
||||
|
||||
Every tool returns text. Failures start with `Error:` and say what was left unchanged.
|
||||
Sets, drawings and nests are named by id or exact name (case-insensitive); an ambiguous
|
||||
name is refused with the ids to choose from, and an unknown one lists similar names.
|
||||
|
||||
## Tools
|
||||
|
||||
| Tool | Writes | What it does |
|
||||
|---|---|---|
|
||||
| `search_drawings` | no | Library query: text, customer, material, grade, thickness, `includeArchived`, paging. |
|
||||
| `get_drawing` | no | One drawing's record, notes and the sets that list it. |
|
||||
| `search_sets` | no | Set query: text, customer, `includeArchived`, paging. |
|
||||
| `get_set` | no | One set with each member's drawing and quantity per kit. |
|
||||
| `create_set` | yes | New set from `members: [{drawing, quantity}]`; refuses a name another set has, an unknown drawing or one listed twice. |
|
||||
| `update_set` | yes | Next revision: omitted fields keep their value, `members` replaces the list. The `If-Match` revision is the one just read. |
|
||||
| `archive_set`, `restore_set` | yes | Archive or restore at the current revision. |
|
||||
| `plan_release` | no | `sets: [{set, quantity}]` (kits) and `drawings: [{drawing, quantity}]` (on their own) into material groups (`SetReleasePlan.Build`): each group's key, parts, warnings, refusal, and the Draft nests it could merge into (`SetReleasePlan.FindDraftsAsync`). |
|
||||
| `make_nests` | yes | The release; see below. |
|
||||
| `renest_nest` | yes | Re-nest a saved Draft or Quote nest; see below. |
|
||||
| `nest_summary` | no | A saved nest: status, material, plate defaults and options, sheets with sizes and utilization, each drawing's required and nested quantity. |
|
||||
| `get_release` | no | One release: sets, drawings, notes and its nests with undo state. |
|
||||
| `undo_release` | yes | `UndoReleaseAsync`, all or nothing. A nest changed since the release refuses it and is listed; pass its id in `skipNests` to leave it as it is. |
|
||||
|
||||
### make_nests
|
||||
|
||||
Takes the same `sets` and `drawings` as `plan_release`, plus `notes`, `sheetSizes`, `merge`,
|
||||
`includeArchived`, `nestAfterRelease` (default true), `useLedger` (default true),
|
||||
`skipRefusedGroups` (default false) and `engine`.
|
||||
|
||||
- Every group must be releasable, or nothing is created and the refusals are listed;
|
||||
`skipRefusedGroups` releases the others (the desktop's unticked rows).
|
||||
- `merge: [{group, draft}]` merges a group (its key from `plan_release`) into a Draft nest
|
||||
instead of a new one. The session re-checks the draft (status, units, material, cut type)
|
||||
and saves over the revision just read.
|
||||
- With `nestAfterRelease`, each nest is nested before anything is uploaded, as
|
||||
`ReleaseRenest.RunHeadlessAsync` does for the desktop (ledger first, then the plate
|
||||
defaults). A nest is saved even with parts unplaced, as on the desktop; the result lists them.
|
||||
- The result gives the release id (or why it was not recorded), and per group its outcome,
|
||||
nest name, id and revision, new or merged, each plate's size, count, parts and
|
||||
utilization, parts required and nested, unplaced parts, sheet trials and notes.
|
||||
|
||||
### Sheet sizes
|
||||
|
||||
`make_nests` and `renest_nest` take `sheetSizes`, such as `["60x120", "72x144", "12x72"]`:
|
||||
width × length in the nest's units. Without it a nest uses its plate defaults and plate
|
||||
options, as the desktop does. With one size, that size is the plate default and the plate
|
||||
options are cleared. With several, `SheetSizeTrials` nests a copy of the nest (read back
|
||||
from its archive) on each size alone and on all of them together as `Nest.PlateOptions`,
|
||||
which the engine may mix, without ledger stock. It keeps the layout that was kept at all,
|
||||
then leaves the fewest copies unplaced, then uses the fewest physical sheets, then the least
|
||||
sheet area, and the result lists every trial. The choice is then nested again on the release's
|
||||
own nest (with ledger stock first when set up), so the kept layout may differ slightly from
|
||||
its trial when the engine is not deterministic. The saved nest keeps the chosen size or options as its
|
||||
defaults. The engine's own stock choice with plate options minimizes net area, not sheet
|
||||
count, which is why sizes are also tried alone.
|
||||
|
||||
### renest_nest
|
||||
|
||||
Re-nests a Draft or Quote nest from scratch: every plate removed and every drawing's
|
||||
required quantity nested again on `sheetSizes` (or its own defaults), ledger stock first
|
||||
when `useLedger` and set up (codes on this nest are not counted as in use). It saves a new
|
||||
revision only when a layout was kept and every part is placed, with
|
||||
`UpdateFileAsync(id, archive, record, expectedRevision)`, so a nest saved since it was read
|
||||
is not overwritten. `save: false` only reports.
|
||||
|
||||
## Example
|
||||
|
||||
```text
|
||||
search_sets {"search": "element rack"}
|
||||
plan_release {"sets": [{"set": "4348 A21 Lower element rack", "quantity": 12}]}
|
||||
make_nests {"sets": [{"set": "4348 A21 Lower element rack", "quantity": 12}],
|
||||
"notes": "4348-102R: 12 lower element racks",
|
||||
"sheetSizes": ["12x72", "48x96", "60x120"]}
|
||||
nest_summary {"nest": "N26-2CP"}
|
||||
renest_nest {"nest": "N26-2CP", "sheetSizes": ["72x144"]}
|
||||
undo_release {"release": "<id from make_nests>"}
|
||||
```
|
||||
|
||||
## Tests
|
||||
|
||||
`OpenNest.Server.Tests/McpNestServerToolsTests.cs` runs the tools against the in-process
|
||||
server (sets by name, a two-material release on two sheet sizes with server-named drafts,
|
||||
a merge, guarded re-nests, a refused and a partial undo). Never point development or tests
|
||||
at the production nest server.
|
||||
@@ -739,6 +739,8 @@ review and Save; nothing is stored before then.
|
||||
<a id="make-nests-the-release-panel"></a>
|
||||
### Make Nests: the release panel (desktop)
|
||||
|
||||
Agents make the same release through `OpenNest.Mcp`; see [MCP nest server tools](mcp-nest-server-tools.md).
|
||||
|
||||
The release panel (`OpenNest.Controls.ReleasePanel`) sits beside the Library and
|
||||
Sets tabs and holds one release in progress for both. Adding is a double-click
|
||||
(or Enter) in either list: a set is read with its members' current drawings and
|
||||
|
||||
Reference in new issue
Block a user