J.Schmidt92/journal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of https://gitea.innovativedevsolutions.org/J.Schmidt92/journal

Browse Source
This commit is contained in:
Jacob Schmidt 2026-03-01 16:15:16 -06:00
commit 53204ec59e
122 changed files with 11345 additions and 1602 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
.gitignore vendored
View File

@ -50,4 +50,16 @@ logs/
journalapp.exe
Journal.App/node_modules.old/@rollup/.rollup-win32-x64-msvc-IjiZshxL/rollup.win32-x64-msvc.node
journalapp(1).exe
.cache/
.cache/
Journal.DevTool/node_modules/
scripts/__pycache__/
.sdt/
devtool.backup.json
sdt.deps.json
sdt.dll
sdt.exe
sdt.pdb
sdt.runtimeconfig.json
Spectre.Console.dll
Journal.DevTool/devtool.generated.workflows.json
Journal.DevTool/sdt-workspace.json

20
Journal.App/package-lock.json generated
View File

@ -11,7 +11,8 @@
"dependencies": {
"@tauri-apps/api": "^2",
"@tauri-apps/plugin-dialog": "^2.6.0",
"@tauri-apps/plugin-opener": "^2"
"@tauri-apps/plugin-opener": "^2",
"tauri-plugin-mic-recorder-api": "^2.0.0"
},
"devDependencies": {
"@sveltejs/adapter-static": "^3.0.6",
@ -908,6 +909,7 @@
"integrity": "sha512-NXsZLvalgI3HrHG6ogoEVzjyV7bSFQNqQeekfU7nNufQFrRyV3EBDfQKEwxx50peu7spZR42JuC1PFhwxuvBrg==",
"dev": true,
"license": "MIT",
"peer": true,
"dependencies": {
"@standard-schema/spec": "^1.0.0",
"@sveltejs/acorn-typescript": "^1.0.5",
@ -950,6 +952,7 @@
"integrity": "sha512-Y1Cs7hhTc+a5E9Va/xwKlAJoariQyHY+5zBgCZg4PFWNYQ1nMN9sjK1zhw1gK69DuqVP++sht/1GZg1aRwmAXQ==",
"dev": true,
"license": "MIT",
"peer": true,
"dependencies": {
"@sveltejs/vite-plugin-svelte-inspector": "^4.0.1",
"debug": "^4.4.1",
@ -1256,6 +1259,7 @@
"integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
"dev": true,
"license": "MIT",
"peer": true,
"bin": {
"acorn": "bin/acorn"
},
@ -1542,6 +1546,7 @@
"integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
"dev": true,
"license": "MIT",
"peer": true,
"engines": {
"node": ">=12"
},
@ -1584,6 +1589,7 @@
"integrity": "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==",
"dev": true,
"license": "MIT",
"peer": true,
"bin": {
"prettier": "bin/prettier.cjs"
},
@ -1715,6 +1721,7 @@
"integrity": "sha512-pRUBr6j6uQDgBi208gHnGRMykw0Rf2Yr1HmLyRucsvcaYgIUxswJkT93WZJflsmezu5s8Lq+q78EoyLv2yaFCg==",
"dev": true,
"license": "MIT",
"peer": true,
"dependencies": {
"@jridgewell/remapping": "^2.3.4",
"@jridgewell/sourcemap-codec": "^1.5.0",
@ -1761,6 +1768,15 @@
"typescript": ">=5.0.0"
}
},
"node_modules/tauri-plugin-mic-recorder-api": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/tauri-plugin-mic-recorder-api/-/tauri-plugin-mic-recorder-api-2.0.0.tgz",
"integrity": "sha512-04wqYCX4WIlYd6KUY7aS3+W4B5RtnSoVczaQCBSXKpQkEx9XdaaBN05XCee2unxGva0btSXBItFqQSdosnS4jQ==",
"license": "MIT",
"dependencies": {
"@tauri-apps/api": ">=2.0.0-beta.6"
}
},
"node_modules/tinyglobby": {
"version": "0.2.15",
"resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
@ -1794,6 +1810,7 @@
"integrity": "sha512-hjcS1mhfuyi4WW8IWtjP7brDrG2cuDZukyrYrSauoXGNgx0S7zceP07adYkJycEr56BOUTNPzbInooiN3fn1qw==",
"dev": true,
"license": "Apache-2.0",
"peer": true,
"bin": {
"tsc": "bin/tsc",
"tsserver": "bin/tsserver"
@ -1808,6 +1825,7 @@
"integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
"dev": true,
"license": "MIT",
"peer": true,
"dependencies": {
"esbuild": "^0.25.0",
"fdir": "^6.4.4",

15
Journal.DevTool/.gitignore vendored Normal file
View File

@ -0,0 +1,15 @@
bin/
obj/
__pycache__/
.cache/
.vscode/
.idea/
.vs/
.git/
.pip
.tmp
.venv
.dotnet_home
.nuget
publish-test/

626
Journal.DevTool/Config/ConfigBootstrapper.cs Normal file
View File

@ -0,0 +1,626 @@
using System.Text.Json;
namespace Sdt.Config;
public sealed record BootstrapScanResult(
string ProjectRoot,
string ProjectName,
IReadOnlyList<string> ToolFamilies,
string? NodeWorkingDir,
string? PythonRequirementsFile,
bool HasDockerCompose,
IReadOnlyList<string> RootHints);
public static class ConfigBootstrapper
{
private const int MaxScanDepth = 4;
private static readonly HashSet<string> ExcludedDirectories = new(StringComparer.OrdinalIgnoreCase)
{
".git",
"node_modules",
".venv",
"venv",
"bin",
"obj",
".idea",
".vscode",
"dist",
"build",
".sdt",
};
private static readonly string[] RequirementCandidates =
[
"requirements.txt",
"requirements-dev.txt",
"requirements_cpu_only.txt",
"requirements_gpu.txt",
];
private static readonly JsonSerializerOptions JsonOptions = new()
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
WriteIndented = true
};
public static BootstrapScanResult Scan(string startDir)
{
var root = FindProjectRoot(startDir);
var toolFamilies = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var rootHints = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
if (Directory.Exists(Path.Combine(root, ".git")))
{
toolFamilies.Add("git");
rootHints.Add(".git");
}
var hasTopLevelSln = Directory.EnumerateFiles(root, "*.sln", SearchOption.TopDirectoryOnly).Any();
var hasCsproj = hasTopLevelSln || EnumerateFilesBounded(root, "*.csproj", MaxScanDepth).Any();
if (hasCsproj)
{
toolFamilies.Add("dotnet");
rootHints.Add("*.sln");
}
var topLevelPackageJson = Path.Combine(root, "package.json");
var packageJson = File.Exists(topLevelPackageJson)
? topLevelPackageJson
: EnumerateFilesBounded(root, "package.json", MaxScanDepth)
.OrderBy(p => p.Length)
.FirstOrDefault();
string? nodeWorkingDir = null;
if (packageJson is not null)
{
toolFamilies.Add("node");
toolFamilies.Add("npm");
nodeWorkingDir = Path.GetRelativePath(root, Path.GetDirectoryName(packageJson)!);
rootHints.Add("package.json");
}
string? requirements = RequirementCandidates
.Select(name => Path.Combine(root, name))
.FirstOrDefault(File.Exists);
if (requirements is null)
{
var pyproject = Path.Combine(root, "pyproject.toml");
if (File.Exists(pyproject))
{
toolFamilies.Add("python");
rootHints.Add("pyproject.toml");
}
}
else
{
toolFamilies.Add("python");
rootHints.Add(Path.GetFileName(requirements)!);
}
var hasCargo = File.Exists(Path.Combine(root, "Cargo.toml")) ||
EnumerateFilesBounded(root, "Cargo.toml", MaxScanDepth).Any();
if (hasCargo)
{
toolFamilies.Add("cargo");
rootHints.Add("Cargo.toml");
}
var hasTauri = File.Exists(Path.Combine(root, "tauri.conf.json")) ||
EnumerateFilesBounded(root, "tauri.conf.json", MaxScanDepth).Any();
if (hasTauri)
{
toolFamilies.Add("tauri");
toolFamilies.Add("cargo");
toolFamilies.Add("node");
toolFamilies.Add("npm");
rootHints.Add("tauri.conf.json");
}
var hasDockerCompose = File.Exists(Path.Combine(root, "docker-compose.yml")) ||
File.Exists(Path.Combine(root, "docker-compose.yaml"));
if (hasDockerCompose || File.Exists(Path.Combine(root, "Dockerfile")))
{
toolFamilies.Add("docker");
rootHints.Add(hasDockerCompose ? "docker-compose.yml" : "Dockerfile");
}
var scriptsDir = Path.Combine(root, "scripts");
if (Directory.Exists(scriptsDir) &&
Directory.EnumerateFiles(scriptsDir, "*.py", SearchOption.TopDirectoryOnly).Any())
{
toolFamilies.Add("python");
rootHints.Add("scripts");
}
if (rootHints.Count == 0)
rootHints.Add("devtool.json");
return new BootstrapScanResult(
ProjectRoot: root,
ProjectName: new DirectoryInfo(root).Name,
ToolFamilies: toolFamilies.OrderBy(x => x, StringComparer.OrdinalIgnoreCase).ToList(),
NodeWorkingDir: nodeWorkingDir,
PythonRequirementsFile: requirements is null ? null : Path.GetRelativePath(root, requirements),
HasDockerCompose: hasDockerCompose,
RootHints: rootHints.OrderBy(x => x, StringComparer.OrdinalIgnoreCase).ToList());
}
public static DevToolConfig BuildDefaultConfig(BootstrapScanResult scan)
{
var workflows = BuildWorkflows(scan).ToList();
var toolingTools = scan.ToolFamilies
.Select(t => new ToolInstallDefinition { Tool = t, PreferredInstallCommands = [] })
.ToList();
var toolchains = new ToolchainConfig
{
Python = scan.ToolFamilies.Contains("python", StringComparer.OrdinalIgnoreCase)
? new PythonToolchain
{
Executable = "python",
WindowsExecutable = "py",
VenvDir = ".venv",
Profiles = []
}
: null,
Node = scan.ToolFamilies.Contains("node", StringComparer.OrdinalIgnoreCase)
? new NodeToolchain
{
PackageManager = "npm",
WorkingDir = string.IsNullOrWhiteSpace(scan.NodeWorkingDir) ? "." : scan.NodeWorkingDir
}
: null
};
var debugProfiles = BuildDebugProfiles(scan).ToList();
return new DevToolConfig
{
Name = scan.ProjectName,
Version = "0.1.0",
Project = new ProjectMetadata
{
Type = "generic",
RootHints = scan.RootHints.ToList(),
Artifacts = ["bin", "obj", ".sdt/debug"]
},
Toolchains = toolchains,
Tooling = new ToolingConfig { Tools = toolingTools },
Workflows = workflows,
Debug = new DebugConfig
{
Profiles = debugProfiles,
Diagnostics = new DebugDiagnosticsOptions
{
Enabled = true,
OutputDir = ".sdt/debug",
IncludeAllEnv = false,
CaptureEnvKeys =
[
"SDT_LOG_LEVEL",
"DOTNET_CLI_HOME",
"NUGET_PACKAGES",
"PIP_CACHE_DIR",
"NVM_HOME",
"NVM_SYMLINK",
],
BundleOnFailure = true
}
},
Env =
[
new EnvVarDef
{
Key = "SDT_LOG_LEVEL",
Description = "CLI log verbosity",
DefaultValue = "information",
Options = ["trace", "debug", "information", "warning", "error", "critical"]
}
]
};
}
public static string ToJson(DevToolConfig config) => JsonSerializer.Serialize(config, JsonOptions) + Environment.NewLine;
public static string WriteDefaultConfig(string projectRoot, DevToolConfig config, bool overwrite = false)
{
var path = Path.Combine(projectRoot, "devtool.json");
if (File.Exists(path) && !overwrite)
throw new InvalidOperationException($"devtool.json already exists at {path}");
File.WriteAllText(path, ToJson(config));
return path;
}
private static IEnumerable<WorkflowDefinition> BuildWorkflows(BootstrapScanResult scan)
{
var has = new Func<string, bool>(tool => scan.ToolFamilies.Contains(tool, StringComparer.OrdinalIgnoreCase));
var scripts = DetectScriptHelpers(scan.ProjectRoot);
if (scripts.Contains("publish-sidecar.py") ||
scripts.Contains("publish-app.py") ||
scripts.Contains("publish-webgateway.py") ||
scripts.Contains("publish-output.py") ||
scripts.Contains("sync-output.py") ||
scripts.Contains("run-webgateway.py"))
{
foreach (var workflow in BuildScriptDrivenWorkflows(scripts))
yield return workflow;
}
var buildSteps = new List<WorkflowStep>();
if (has("dotnet")) buildSteps.Add(StepAction("dotnet-build", "dotnet build", "dotnet-build"));
if (has("npm")) buildSteps.Add(StepAction("npm-build", "npm run build", "npm-build", scan.NodeWorkingDir));
if (has("cargo")) buildSteps.Add(StepAction("cargo-build", "cargo build", "cargo-build"));
if (has("tauri")) buildSteps.Add(StepAction("tauri-build", "tauri build", "tauri-build", scan.NodeWorkingDir ?? "."));
if (buildSteps.Count > 0)
{
yield return new WorkflowDefinition
{
Id = "build",
Label = "Build",
Description = "Build detected project stacks",
Group = "Build",
Steps = buildSteps
};
}
var depsSteps = new List<WorkflowStep>();
if (has("dotnet")) depsSteps.Add(StepAction("dotnet-restore", "dotnet restore", "dotnet-restore"));
if (has("npm")) depsSteps.Add(StepAction("npm-ci", "npm ci", "npm-ci", scan.NodeWorkingDir));
if (has("python") && !string.IsNullOrWhiteSpace(scan.PythonRequirementsFile))
{
depsSteps.Add(StepAction("python-pip-sync", "python pip sync", "python-pip-sync", ".", ["--requirements", scan.PythonRequirementsFile!]));
}
if (depsSteps.Count > 0)
{
yield return new WorkflowDefinition
{
Id = "deps-refresh",
Label = "Refresh Dependencies",
Description = "Restore/install dependency stacks",
Group = "Deps",
Steps = depsSteps
};
}
var testSteps = new List<WorkflowStep>();
if (has("dotnet")) testSteps.Add(StepAction("dotnet-test", "dotnet test", "dotnet-test"));
if (has("npm")) testSteps.Add(StepAction("npm-test", "npm test", "npm-test", scan.NodeWorkingDir));
if (has("python")) testSteps.Add(StepAction("python-pytest", "python -m pytest", "python-pytest"));
if (has("cargo")) testSteps.Add(StepAction("cargo-test", "cargo test", "cargo-test"));
if (testSteps.Count > 0)
{
yield return new WorkflowDefinition
{
Id = "test",
Label = "Run Tests",
Description = "Run detected test stacks",
Group = "Test",
Steps = testSteps
};
}
if (has("git"))
{
yield return new WorkflowDefinition
{
Id = "repo-health",
Label = "Repo Health",
Description = "Check repo status and fetch remotes",
Group = "Repo",
Steps =
[
StepAction("git-status", "git status", "git-status"),
StepAction("git-fetch", "git fetch", "git-fetch")
]
};
}
if (has("docker"))
{
yield return new WorkflowDefinition
{
Id = "containers",
Label = "Containers",
Description = scan.HasDockerCompose ? "Manage docker compose stack" : "Build docker image",
Group = "Containers",
Steps = scan.HasDockerCompose
? [StepAction("docker-compose-up", "docker compose up -d", "docker-compose-up")]
: [StepAction("docker-build", "docker build .", "docker-build")]
};
}
}
private static IEnumerable<DebugProfileDefinition> BuildDebugProfiles(BootstrapScanResult scan)
{
var has = new Func<string, bool>(tool => scan.ToolFamilies.Contains(tool, StringComparer.OrdinalIgnoreCase));
if (has("dotnet"))
{
yield return new DebugProfileDefinition
{
Id = "dotnet-run",
Label = "Run .NET app",
Type = "dotnet",
Command = "dotnet",
Args = ["run"],
WorkingDir = ".",
Requires = [new ToolRequirement { Tool = "dotnet", InstallPolicy = InstallPolicy.Prompt }],
Attach = new DebugAttachConfig
{
Kind = "manual",
Note = "Attach your IDE debugger to the running dotnet process."
}
};
}
if (has("npm"))
{
yield return new DebugProfileDefinition
{
Id = "npm-dev",
Label = "Run npm dev server",
Type = "node",
Command = "npm",
Args = ["run", "dev"],
WorkingDir = string.IsNullOrWhiteSpace(scan.NodeWorkingDir) ? "." : scan.NodeWorkingDir!,
Requires =
[
new ToolRequirement { Tool = "node", InstallPolicy = InstallPolicy.Prompt },
new ToolRequirement { Tool = "npm", InstallPolicy = InstallPolicy.Prompt }
]
};
}
}
private static WorkflowStep StepAction(
string id,
string label,
string action,
string? workingDir = null,
IReadOnlyList<string>? actionArgs = null)
{
return new WorkflowStep
{
Id = id,
Label = label,
Action = action,
ActionArgs = actionArgs?.ToList() ?? [],
WorkingDir = string.IsNullOrWhiteSpace(workingDir) ? "." : workingDir
};
}
private static HashSet<string> DetectScriptHelpers(string projectRoot)
{
var scriptsDir = Path.Combine(projectRoot, "scripts");
if (!Directory.Exists(scriptsDir))
return new HashSet<string>(StringComparer.OrdinalIgnoreCase);
return Directory.EnumerateFiles(scriptsDir, "*.py", SearchOption.TopDirectoryOnly)
.Select(Path.GetFileName)
.Where(f => !string.IsNullOrWhiteSpace(f))
.Cast<string>()
.ToHashSet(StringComparer.OrdinalIgnoreCase);
}
private static IEnumerable<WorkflowDefinition> BuildScriptDrivenWorkflows(HashSet<string> scripts)
{
static WorkflowStep ScriptStep(string id, string label, params string[] scriptArgs) => new()
{
Id = id,
Label = label,
Command = "python",
Args = scriptArgs.ToList(),
WorkingDir = ".",
Requires = [new ToolRequirement { Tool = "python", InstallPolicy = InstallPolicy.Prompt }]
};
if (scripts.Contains("publish-sidecar.py"))
{
yield return new WorkflowDefinition
{
Id = "sidecar",
Label = "Publish Sidecar",
Description = "Publish sidecar service",
Group = "Build",
Steps = [ScriptStep("sidecar:run", "python scripts/publish-sidecar.py", "scripts/publish-sidecar.py")]
};
}
if (scripts.Contains("publish-app.py"))
{
yield return new WorkflowDefinition
{
Id = "web",
Label = "Build Web UI",
Description = "Build frontend assets",
Group = "Build",
Steps =
[
ScriptStep("web:run", "python scripts/publish-app.py --target web", "scripts/publish-app.py", "--target", "web")
]
};
yield return new WorkflowDefinition
{
Id = "tauri",
Label = "Build Tauri Desktop App",
Description = "Build desktop binary",
Group = "Build",
DependsOn = scripts.Contains("publish-sidecar.py") ? ["sidecar"] : [],
Steps =
[
ScriptStep("tauri:run", "python scripts/publish-app.py --target tauri --tauri-bundles none",
"scripts/publish-app.py", "--target", "tauri", "--tauri-bundles", "none")
]
};
}
if (scripts.Contains("publish-webgateway.py"))
{
yield return new WorkflowDefinition
{
Id = "webgateway",
Label = "Publish WebGateway",
Description = "Publish ASP.NET gateway",
Group = "Build",
DependsOn = scripts.Contains("publish-app.py") ? ["web"] : [],
Steps = [ScriptStep("webgateway:run", "python scripts/publish-webgateway.py", "scripts/publish-webgateway.py")]
};
}
if (scripts.Contains("sync-output.py"))
{
yield return new WorkflowDefinition
{
Id = "sync-output",
Label = "Sync Output",
Description = "Sync newest artifacts to output",
Group = "Build",
Steps = [ScriptStep("sync-output:run", "python scripts/sync-output.py", "scripts/sync-output.py")]
};
}
if (scripts.Contains("publish-output.py"))
{
yield return new WorkflowDefinition
{
Id = "stage-output",
Label = "Stage Output Bundle",
Description = "Publish and stage distributable output",
Group = "Build",
Steps = [ScriptStep("stage-output:run", "python scripts/publish-output.py", "scripts/publish-output.py")]
};
}
if (scripts.Contains("run-webgateway.py"))
{
yield return new WorkflowDefinition
{
Id = "run-gateway-dev",
Label = "Run WebGateway Server (Dev)",
Description = "Run gateway in development mode",
Group = "Dev",
Steps =
[
ScriptStep("run-gateway-dev:run", "python scripts/run-webgateway.py --mode Dev",
"scripts/run-webgateway.py", "--mode", "Dev")
]
};
}
}
private static string FindProjectRoot(string startDir)
{
var start = Path.GetFullPath(startDir);
var gitRoot = TryGetGitRoot(start);
if (!string.IsNullOrWhiteSpace(gitRoot))
return gitRoot!;
var best = start;
var bestScore = ScoreRoot(start);
var cursor = new DirectoryInfo(start);
while (cursor.Parent is not null)
{
cursor = cursor.Parent;
var score = ScoreRoot(cursor.FullName);
if (score > bestScore)
{
best = cursor.FullName;
bestScore = score;
}
}
return best;
}
private static int ScoreRoot(string path)
{
var score = 0;
if (File.Exists(Path.Combine(path, "package.json"))) score += 2;
if (File.Exists(Path.Combine(path, "pyproject.toml"))) score += 2;
if (File.Exists(Path.Combine(path, "Cargo.toml"))) score += 2;
if (File.Exists(Path.Combine(path, "docker-compose.yml")) ||
File.Exists(Path.Combine(path, "docker-compose.yaml")) ||
File.Exists(Path.Combine(path, "Dockerfile"))) score += 1;
if (Directory.EnumerateFiles(path, "*.sln", SearchOption.TopDirectoryOnly).Any()) score += 3;
if (Directory.Exists(Path.Combine(path, ".git"))) score += 1;
return score;
}
private static string? TryGetGitRoot(string start)
{
try
{
var psi = new System.Diagnostics.ProcessStartInfo
{
FileName = "git",
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
WorkingDirectory = start
};
psi.ArgumentList.Add("rev-parse");
psi.ArgumentList.Add("--show-toplevel");
using var process = System.Diagnostics.Process.Start(psi);
if (process is null)
return null;
var stdout = process.StandardOutput.ReadToEnd();
process.WaitForExit(2000);
if (process.ExitCode == 0 && !string.IsNullOrWhiteSpace(stdout))
return stdout.Trim();
return null;
}
catch
{
return null;
}
}
private static IEnumerable<string> EnumerateFilesBounded(string root, string pattern, int maxDepth)
{
var queue = new Queue<(string Dir, int Depth)>();
queue.Enqueue((root, 0));
while (queue.Count > 0)
{
var (dir, depth) = queue.Dequeue();
IEnumerable<string> files = [];
try
{
files = Directory.EnumerateFiles(dir, pattern, SearchOption.TopDirectoryOnly);
}
catch
{
// Ignore unreadable directories.
}
foreach (var file in files)
yield return file;
if (depth >= maxDepth)
continue;
IEnumerable<string> subdirs = [];
try
{
subdirs = Directory.EnumerateDirectories(dir, "*", SearchOption.TopDirectoryOnly);
}
catch
{
// Ignore unreadable directories.
}
foreach (var subdir in subdirs)
{
var name = Path.GetFileName(subdir);
if (ExcludedDirectories.Contains(name))
continue;
queue.Enqueue((subdir, depth + 1));
}
}
}
}

209
Journal.DevTool/Config/ConfigLoader.cs
View File

@ -1,9 +1,24 @@
using System.Text.Json;
using System.Text.Json.Nodes;
using Sdt.Core;
namespace Sdt.Config;
public sealed record LoadedProjectConfig(
DevToolConfig Config,
string ProjectRoot,
IReadOnlyList<string> Warnings);
public sealed record LegacyMigrationApplyResult(
bool Success,
string Message,
string? BackupPath = null,
string? ConfigPath = null);
public static class ConfigLoader
{
public const string WorkspaceDefaultsFileName = "sdt-defaults.json";
private static readonly JsonSerializerOptions JsonOptions = new()
{
PropertyNameCaseInsensitive = true,
@ -16,29 +31,193 @@ public static class ConfigLoader
/// Walks up from <paramref name="startDir"/> (or CWD) until it finds devtool.json.
/// Returns null if not found.
/// </summary>
public static (DevToolConfig Config, string ProjectRoot)? FindAndLoad(string? startDir = null)
public static string? FindConfigPath(string? startDir = null)
{
var dir = new DirectoryInfo(startDir ?? Directory.GetCurrentDirectory());
while (dir is not null)
{
var candidate = Path.Combine(dir.FullName, "devtool.json");
if (File.Exists(candidate))
{
try
{
var json = File.ReadAllText(candidate);
var config = JsonSerializer.Deserialize<DevToolConfig>(json, JsonOptions)
?? throw new InvalidOperationException("devtool.json deserialized to null.");
return (config, dir.FullName);
}
catch (Exception ex)
{
throw new InvalidOperationException(
$"Failed to parse devtool.json at {candidate}: {ex.Message}", ex);
}
}
return candidate;
dir = dir.Parent!;
}
return null;
}
public static LoadedProjectConfig? FindAndLoad(string? startDir = null)
{
var configPath = FindConfigPath(startDir);
if (configPath is null)
return null;
var projectRoot = Path.GetDirectoryName(configPath)
?? throw new InvalidOperationException($"Could not resolve project root from {configPath}");
try
{
var effectiveConfig = LoadEffectiveConfig(projectRoot, configPath, out var defaultsPath);
var warnings = new List<string>();
if (!string.IsNullOrWhiteSpace(defaultsPath))
warnings.Add($"Applied workspace defaults from {defaultsPath}.");
var legacyMode = ResolveLegacyMode();
if (legacyMode == LegacyMode.Strict && effectiveConfig.Workflows.Count == 0 && effectiveConfig.Targets.Count > 0)
{
var previewPath = Path.Combine(projectRoot, "devtool.generated.workflows.json");
try
{
var previewConfig = WorkflowModelBuilder.BuildMigrationPreviewConfig(effectiveConfig, new RequirementResolver());
File.WriteAllText(previewPath, ConfigBootstrapper.ToJson(previewConfig));
}
catch
{
// Keep strict failure even if preview generation fails.
}
throw new InvalidOperationException(
$"Legacy targets-only config detected at {configPath}. Strict mode requires workflows. " +
"Use migration preview file 'devtool.generated.workflows.json' and migrate devtool.json. " +
"Temporary rollback: set SDT_LEGACY_MODE=compat.");
}
var normalized = WorkflowModelBuilder.Normalize(effectiveConfig, legacyMode, new RequirementResolver());
warnings.AddRange(normalized.Warnings);
return new LoadedProjectConfig(effectiveConfig, projectRoot, warnings);
}
catch (Exception ex)
{
throw new InvalidOperationException(
$"Failed to parse devtool.json at {configPath}: {ex.Message}", ex);
}
}
public static LegacyMigrationApplyResult ApplyLegacyTargetMigration(
string configPath,
bool createBackup = true)
{
try
{
if (!File.Exists(configPath))
return new LegacyMigrationApplyResult(false, $"Config file not found: {configPath}");
var json = File.ReadAllText(configPath);
var config = JsonSerializer.Deserialize<DevToolConfig>(json, JsonOptions)
?? throw new InvalidOperationException("devtool.json deserialized to null.");
if (config.Targets.Count == 0)
return new LegacyMigrationApplyResult(false, "No legacy targets found to migrate.", ConfigPath: configPath);
var migrated = WorkflowModelBuilder.BuildMigrationPreviewConfig(config, new RequirementResolver());
var backupPath = (string?)null;
if (createBackup)
{
backupPath = configPath + $".bak-{DateTimeOffset.Now:yyyyMMdd-HHmmss}";
File.Copy(configPath, backupPath, overwrite: false);
}
File.WriteAllText(configPath, ConfigBootstrapper.ToJson(migrated));
return new LegacyMigrationApplyResult(
true,
"Legacy targets migrated to workflows.",
BackupPath: backupPath,
ConfigPath: configPath);
}
catch (Exception ex)
{
return new LegacyMigrationApplyResult(false, ex.Message, ConfigPath: configPath);
}
}
private static LegacyMode ResolveLegacyMode()
{
var raw = Environment.GetEnvironmentVariable("SDT_LEGACY_MODE");
return string.Equals(raw, "compat", StringComparison.OrdinalIgnoreCase)
? LegacyMode.Compat
: LegacyMode.Strict;
}
private static DevToolConfig LoadEffectiveConfig(
string projectRoot,
string projectConfigPath,
out string? defaultsPath)
{
defaultsPath = FindWorkspaceDefaultsPath(projectRoot);
var projectObj = LoadJsonObject(projectConfigPath, "project config");
if (string.IsNullOrWhiteSpace(defaultsPath))
return DeserializeConfig(projectObj, projectConfigPath);
var defaultsObj = LoadJsonObject(defaultsPath!, "workspace defaults");
var merged = MergeObjects(defaultsObj, projectObj);
return DeserializeConfig(merged, projectConfigPath);
}
private static string? FindWorkspaceDefaultsPath(string startDir)
{
var workspaceBoundary = FindWorkspaceBoundary(startDir);
var dir = new DirectoryInfo(startDir);
while (dir is not null)
{
var candidate = Path.Combine(dir.FullName, WorkspaceDefaultsFileName);
if (File.Exists(candidate))
return candidate;
if (workspaceBoundary is not null &&
string.Equals(dir.FullName, workspaceBoundary, StringComparison.OrdinalIgnoreCase))
{
break;
}
if (workspaceBoundary is null)
break;
dir = dir.Parent;
}
return null;
}
private static string? FindWorkspaceBoundary(string startDir)
{
var dir = new DirectoryInfo(startDir);
while (dir is not null)
{
var workspacePath = Path.Combine(dir.FullName, WorkspaceLoader.FileName);
if (File.Exists(workspacePath))
return dir.FullName;
dir = dir.Parent;
}
return null;
}
private static JsonObject LoadJsonObject(string path, string label)
{
var json = File.ReadAllText(path);
var node = JsonNode.Parse(json)
?? throw new InvalidOperationException($"{label} at {path} deserialized to null.");
if (node is not JsonObject obj)
throw new InvalidOperationException($"{label} at {path} must be a JSON object.");
return obj;
}
private static DevToolConfig DeserializeConfig(JsonObject obj, string sourcePath)
{
return obj.Deserialize<DevToolConfig>(JsonOptions)
?? throw new InvalidOperationException($"devtool.json at {sourcePath} deserialized to null.");
}
private static JsonObject MergeObjects(JsonObject baseObj, JsonObject overlayObj)
{
var result = (JsonObject)baseObj.DeepClone();
foreach (var kv in overlayObj)
{
if (kv.Value is JsonObject overlayChild &&
result[kv.Key] is JsonObject baseChild)
{
result[kv.Key] = MergeObjects(baseChild, overlayChild);
continue;
}
result[kv.Key] = kv.Value?.DeepClone();
}
return result;
}
}

99
Journal.DevTool/Config/DevToolConfig.cs
View File

@ -1,3 +1,5 @@
using System.Text.Json.Serialization;
namespace Sdt.Config;
public sealed class DevToolConfig
@ -5,8 +7,12 @@ public sealed class DevToolConfig
public string Name { get; init; } = "SDT Project";
public string Version { get; init; } = "0.1.0";
public List<BuildTarget> Targets { get; init; } = [];
public List<WorkflowDefinition> Workflows { get; init; } = [];
public List<EnvVarDef> Env { get; init; } = [];
public ToolchainConfig? Toolchains { get; init; }
public ToolingConfig? Tooling { get; init; }
public ProjectMetadata? Project { get; init; }
public DebugConfig? Debug { get; init; }
}
public sealed class BuildTarget
@ -39,6 +45,99 @@ public sealed class EnvVarDef
public List<string> Options { get; init; } = [];
}
public sealed class WorkflowDefinition
{
public string Id { get; init; } = "";
public string Label { get; init; } = "";
public string Description { get; init; } = "";
public string Group { get; init; } = "General";
public List<string> DependsOn { get; init; } = [];
public List<WorkflowStep> Steps { get; init; } = [];
}
public sealed class WorkflowStep
{
public string Id { get; init; } = "";
public string Label { get; init; } = "";
public string? Command { get; init; }
public List<string> Args { get; init; } = [];
public string WorkingDir { get; init; } = ".";
public string? Action { get; init; }
public List<string> ActionArgs { get; init; } = [];
public List<ToolRequirement> Requires { get; init; } = [];
}
public sealed class ToolRequirement
{
public string Tool { get; init; } = "";
[JsonConverter(typeof(JsonStringEnumConverter))]
public InstallPolicy InstallPolicy { get; init; } = InstallPolicy.Prompt;
}
[JsonConverter(typeof(JsonStringEnumConverter))]
public enum InstallPolicy
{
Prompt,
Auto,
Never,
}
public sealed class ToolingConfig
{
public List<ToolInstallDefinition> Tools { get; init; } = [];
}
public sealed class ToolInstallDefinition
{
public string Tool { get; init; } = "";
public List<string> PreferredInstallCommands { get; init; } = [];
public List<string> Executables { get; init; } = [];
}
public sealed class ProjectMetadata
{
public string Type { get; init; } = "";
public List<string> RootHints { get; init; } = [];
public List<string> Artifacts { get; init; } = [];
}
public sealed class DebugConfig
{
public List<DebugProfileDefinition> Profiles { get; init; } = [];
public DebugDiagnosticsOptions Diagnostics { get; init; } = new();
}
public sealed class DebugProfileDefinition
{
public string Id { get; init; } = "";
public string Label { get; init; } = "";
public string Type { get; init; } = "generic";
public string Command { get; init; } = "";
public List<string> Args { get; init; } = [];
public string WorkingDir { get; init; } = ".";
public Dictionary<string, string> Env { get; init; } = new(StringComparer.OrdinalIgnoreCase);
public List<ToolRequirement> Requires { get; init; } = [];
public DebugAttachConfig? Attach { get; init; }
}
public sealed class DebugAttachConfig
{
public string Kind { get; init; } = "";
public int? Port { get; init; }
public string? ProcessName { get; init; }
public string? Note { get; init; }
}
public sealed class DebugDiagnosticsOptions
{
public bool Enabled { get; init; } = true;
public string OutputDir { get; init; } = ".sdt/debug";
public bool IncludeAllEnv { get; init; } = false;
public List<string> CaptureEnvKeys { get; init; } = [];
public bool BundleOnFailure { get; init; } = true;
}
// ── Toolchain config ──────────────────────────────────────────────────────────
public sealed class ToolchainConfig

100
Journal.DevTool/Config/WorkflowModelBuilder.cs Normal file
View File

@ -0,0 +1,100 @@
using Sdt.Core;
namespace Sdt.Config;
public enum LegacyMode
{
Strict,
Compat,
}
public sealed record WorkflowNormalizationResult(
IReadOnlyList<WorkflowDefinition> Workflows,
IReadOnlyList<string> Warnings);
public static class WorkflowModelBuilder
{
public static WorkflowNormalizationResult Normalize(
DevToolConfig config,
LegacyMode legacyMode = LegacyMode.Strict,
IRequirementResolver? requirementResolver = null)
{
requirementResolver ??= new RequirementResolver();
var warnings = new List<string>();
if (config.Workflows.Count > 0)
{
if (config.Targets.Count > 0)
{
warnings.Add("Both 'workflows' and legacy 'targets' are present. SDT will use 'workflows'.");
}
return new WorkflowNormalizationResult(config.Workflows, warnings);
}
if (config.Targets.Count == 0)
{
warnings.Add("No 'workflows' or legacy 'targets' were found.");
return new WorkflowNormalizationResult([], warnings);
}
if (legacyMode == LegacyMode.Strict)
{
throw new InvalidOperationException(
"Legacy 'targets' are not allowed in strict mode. Migrate to 'workflows' or set SDT_LEGACY_MODE=compat temporarily.");
}
warnings.Add("Using legacy 'targets' schema. Migrate to 'workflows' for v1+ features.");
return new WorkflowNormalizationResult(ConvertLegacyTargets(config.Targets, requirementResolver), warnings);
}
public static DevToolConfig BuildMigrationPreviewConfig(DevToolConfig config, IRequirementResolver? requirementResolver = null)
{
requirementResolver ??= new RequirementResolver();
return new DevToolConfig
{
Name = config.Name,
Version = config.Version,
Targets = [],
Workflows = ConvertLegacyTargets(config.Targets, requirementResolver),
Env = config.Env,
Toolchains = config.Toolchains,
Tooling = config.Tooling,
Project = config.Project,
Debug = config.Debug,
};
}
private static List<WorkflowDefinition> ConvertLegacyTargets(
IReadOnlyList<BuildTarget> targets,
IRequirementResolver requirementResolver)
{
var workflows = new List<WorkflowDefinition>(targets.Count);
foreach (var target in targets)
{
var step = target.Command is null
? null
: new WorkflowStep
{
Id = $"{target.Id}:run",
Label = string.IsNullOrWhiteSpace(target.Label) ? target.Id : target.Label,
Command = target.Command,
Args = target.Args,
WorkingDir = target.WorkingDir,
Requires = requirementResolver.Resolve(target),
};
workflows.Add(new WorkflowDefinition
{
Id = target.Id,
Label = target.Label,
Description = target.Description,
Group = target.Group,
DependsOn = target.DependsOn,
Steps = step is null ? [] : [step],
});
}
return workflows;
}
}

5
Journal.DevTool/Config/WorkspaceConfig.cs
View File

@ -12,8 +12,11 @@ public sealed class WorkspaceProject
public string Description { get; init; } = "";
/// <summary>
/// Relative path from the sdt-workspace.json directory to the project root
/// Relative or absolute path to the project root
/// (the directory containing devtool.json).
/// </summary>
public string Path { get; init; } = "";
public List<string> Tags { get; init; } = [];
public List<string> ToolFamilies { get; init; } = [];
public bool Disabled { get; init; } = false;
}

124
Journal.DevTool/Config/WorkspaceLoader.cs
View File

@ -4,7 +4,7 @@ namespace Sdt.Config;
public static class WorkspaceLoader
{
private const string FileName = "sdt-workspace.json";
public const string FileName = "sdt-workspace.json";
private static readonly JsonSerializerOptions JsonOptions = new()
{
@ -41,12 +41,130 @@ public static class WorkspaceLoader
}
dir = dir.Parent!;
}
return null;
// No workspace file found; synthesize one by scanning nearby project roots.
return TryAutoDiscover(startDir ?? Directory.GetCurrentDirectory());
}
/// <summary>
/// Resolves the absolute project root for a workspace project entry.
/// </summary>
public static string ResolveProjectRoot(string workspaceRoot, WorkspaceProject project)
=> Path.GetFullPath(Path.Combine(workspaceRoot, project.Path));
=> Path.GetFullPath(Path.IsPathRooted(project.Path)
? project.Path
: Path.Combine(workspaceRoot, project.Path));
public static string GetWorkspaceFilePath(string workspaceRoot)
=> Path.Combine(workspaceRoot, FileName);
public static void Save(string workspaceRoot, WorkspaceConfig workspace)
{
var path = GetWorkspaceFilePath(workspaceRoot);
var saveOptions = new JsonSerializerOptions(JsonOptions)
{
WriteIndented = true
};
var json = JsonSerializer.Serialize(workspace, saveOptions);
File.WriteAllText(path, json + Environment.NewLine);
}
private static (WorkspaceConfig Config, string WorkspaceRoot)? TryAutoDiscover(string startDir)
{
LoadedProjectConfig? loaded;
try
{
loaded = ConfigLoader.FindAndLoad(startDir);
}
catch
{
return null;
}
if (loaded is null)
return null;
var currentRoot = loaded.ProjectRoot;
var parent = Directory.GetParent(currentRoot);
var workspaceRoot = parent?.FullName ?? currentRoot;
var roots = DiscoverProjectRoots(workspaceRoot, currentRoot);
if (roots.Count == 0)
return null;
var projects = new List<WorkspaceProject>();
foreach (var root in roots)
{
LoadedProjectConfig? cfg;
try
{
cfg = ConfigLoader.FindAndLoad(root);
}
catch
{
continue;
}
var name = cfg?.Config.Name;
projects.Add(new WorkspaceProject
{
Name = string.IsNullOrWhiteSpace(name) ? new DirectoryInfo(root).Name : name!,
Description = $"Auto-discovered at {root}",
Path = Path.GetRelativePath(workspaceRoot, root),
});
}
return (
new WorkspaceConfig
{
Name = "SDT Auto Workspace",
Projects = projects
},
workspaceRoot);
}
private static List<string> DiscoverProjectRoots(string workspaceRoot, string currentRoot)
{
var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var excluded = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
{
"bin",
"obj",
".git",
".venv",
"node_modules",
};
void AddIfProject(string path)
{
var full = Path.GetFullPath(path);
if (File.Exists(Path.Combine(full, "devtool.json")))
set.Add(full);
}
AddIfProject(currentRoot);
AddIfProject(workspaceRoot);
try
{
foreach (var dir in Directory.EnumerateDirectories(workspaceRoot))
{
if (excluded.Contains(Path.GetFileName(dir)))
continue;
AddIfProject(dir);
foreach (var sub in Directory.EnumerateDirectories(dir))
{
if (excluded.Contains(Path.GetFileName(sub)))
continue;
AddIfProject(sub);
}
}
}
catch
{
// Ignore inaccessible directories during auto-discovery.
}
return set.OrderBy(p => p, StringComparer.OrdinalIgnoreCase).ToList();
}
}

207
Journal.DevTool/Core/ActionRunner.cs Normal file
View File

@ -0,0 +1,207 @@
using Sdt.Config;
using Sdt.Runner;
namespace Sdt.Core;
public sealed class ActionRunner : IActionRunner
{
public async Task<RunResult> RunStepAsync(
WorkflowStep step,
string projectRoot,
Action<string, bool> onOutput,
CancellationToken cancellationToken = default)
{
if (!string.IsNullOrWhiteSpace(step.Action))
{
var scriptPath = ScriptLocator.FindHelperScript(projectRoot, "build.py");
if (scriptPath is null)
throw new InvalidOperationException("build.py not found in bundled scripts or project scripts directory.");
var actionArgs = new List<string>
{
scriptPath,
step.Action,
"--project-root",
projectRoot,
};
actionArgs.AddRange(step.ActionArgs);
return await ProcessRunner.RunAsync(
PythonResolver.ResolveExecutable(),
actionArgs,
projectRoot,
onOutput,
cancellationToken: cancellationToken).ConfigureAwait(false);
}
if (string.IsNullOrWhiteSpace(step.Command))
return new RunResult(0, TimeSpan.Zero);
var workingDir = Path.GetFullPath(Path.Combine(projectRoot, step.WorkingDir));
var pwshReroute = await TryRunLegacyPwshScriptViaPythonAsync(
step,
projectRoot,
workingDir,
onOutput,
cancellationToken).ConfigureAwait(false);
if (pwshReroute is not null)
return pwshReroute;
return await ProcessRunner.RunAsync(
step.Command,
step.Args,
workingDir,
onOutput,
cancellationToken: cancellationToken).ConfigureAwait(false);
}
private static async Task<RunResult?> TryRunLegacyPwshScriptViaPythonAsync(
WorkflowStep step,
string projectRoot,
string workingDir,
Action<string, bool> onOutput,
CancellationToken cancellationToken)
{
if (!IsPowerShellCommand(step.Command))
return null;
var args = step.Args;
var fileIndex = FindArgIndex(args, "-File");
if (fileIndex < 0 || fileIndex + 1 >= args.Count)
return null;
var psScriptArg = args[fileIndex + 1];
if (!psScriptArg.EndsWith(".ps1", StringComparison.OrdinalIgnoreCase))
return null;
var pyScriptPath = ResolvePythonScriptPath(projectRoot, workingDir, psScriptArg);
if (pyScriptPath is null)
return null;
var translated = TranslatePowerShellArgsToPython(args.Skip(fileIndex + 2));
var pythonArgs = new List<string> { pyScriptPath };
pythonArgs.AddRange(translated);
onOutput($"Legacy PowerShell target detected. Trying Python script first: {Path.GetFileName(pyScriptPath)}", false);
var pyRun = await ProcessRunner.RunAsync(
PythonResolver.ResolveExecutable(),
pythonArgs,
workingDir,
onOutput,
cancellationToken: cancellationToken).ConfigureAwait(false);
if (pyRun.Success)
return pyRun;
var psScriptPath = ResolveScriptPath(workingDir, psScriptArg);
if (psScriptPath is null || !File.Exists(psScriptPath))
return pyRun;
onOutput(
$"Python script failed (exit {pyRun.ExitCode}). Falling back to legacy PowerShell script: {psScriptArg}",
true);
return null;
}
private static string? ResolvePythonScriptPath(string projectRoot, string workingDir, string psScriptArg)
{
var pyArg = Path.ChangeExtension(psScriptArg, ".py");
var candidate = ResolveScriptPath(workingDir, pyArg);
if (candidate is not null && File.Exists(candidate))
return candidate;
var fileName = Path.GetFileName(pyArg);
return ScriptLocator.FindHelperScript(projectRoot, fileName);
}
private static string? ResolveScriptPath(string workingDir, string scriptArg)
{
if (Path.IsPathRooted(scriptArg))
return scriptArg;
return Path.GetFullPath(Path.Combine(workingDir, scriptArg));
}
private static bool IsPowerShellCommand(string? command)
{
if (string.IsNullOrWhiteSpace(command))
return false;
var normalized = Path.GetFileNameWithoutExtension(command).ToLowerInvariant();
return normalized is "pwsh" or "powershell";
}
private static int FindArgIndex(IReadOnlyList<string> args, string name)
{
for (var i = 0; i < args.Count; i++)
{
if (string.Equals(args[i], name, StringComparison.OrdinalIgnoreCase))
return i;
}
return -1;
}
private static List<string> TranslatePowerShellArgsToPython(IEnumerable<string> inputArgs)
{
var result = new List<string>();
var list = inputArgs.ToList();
for (var i = 0; i < list.Count; i++)
{
var token = list[i];
if (!token.StartsWith("-", StringComparison.Ordinal) || token == "-")
{
result.Add(token);
continue;
}
var key = token.TrimStart('-');
if (key.Length == 0)
continue;
var mapped = MapPowerShellParameter(key);
var nextIsValue = (i + 1) < list.Count && !list[i + 1].StartsWith("-", StringComparison.Ordinal);
result.Add(mapped);
if (nextIsValue)
{
result.Add(list[i + 1]);
i++;
}
}
return result;
}
private static string MapPowerShellParameter(string key)
{
return key.ToLowerInvariant() switch
{
"tauribundles" => "--tauri-bundles",
"projectroot" => "--project-root",
"reporoot" => "--repo-root",
"outputzip" => "--output-zip",
"inputzip" => "--input-zip",
"workingdir" => "--working-dir",
"outputdir" => "--output-dir",
_ => "--" + ToKebabCase(key)
};
}
private static string ToKebabCase(string value)
{
if (string.IsNullOrWhiteSpace(value))
return value.ToLowerInvariant();
var chars = new List<char>(value.Length + 4);
for (var i = 0; i < value.Length; i++)
{
var c = value[i];
if (char.IsUpper(c) && i > 0 && value[i - 1] != '-')
chars.Add('-');
chars.Add(char.ToLowerInvariant(c));
}
return new string(chars.ToArray());
}
}

173
Journal.DevTool/Core/CommandResolver.cs Normal file
View File

@ -0,0 +1,173 @@
namespace Sdt.Core;
public enum CommandResolutionSource
{
Exact,
Path,
Shim,
NodeAdjacentShim,
ConfiguredOverride,
Fallback,
}
public sealed record CommandResolutionResult(
string Requested,
string Resolved,
CommandResolutionSource Source);
public static class CommandResolver
{
public static CommandResolutionResult ResolveWithTrace(string command, Config.DevToolConfig? config = null, string? tool = null)
{
if (string.IsNullOrWhiteSpace(command))
return new CommandResolutionResult(command, command, CommandResolutionSource.Exact);
if (!OperatingSystem.IsWindows())
return new CommandResolutionResult(command, command, CommandResolutionSource.Exact);
if (command.Contains(Path.DirectorySeparatorChar) || command.Contains(Path.AltDirectorySeparatorChar))
return new CommandResolutionResult(command, command, CommandResolutionSource.Exact);
var normalized = command.ToLowerInvariant();
if (Path.HasExtension(command))
{
var extensionResolved = ResolveFromPath(command);
return extensionResolved is null
? new CommandResolutionResult(command, command, CommandResolutionSource.Fallback)
: new CommandResolutionResult(command, extensionResolved, CommandResolutionSource.Path);
}
var overrideTool = string.IsNullOrWhiteSpace(tool) ? normalized : tool.ToLowerInvariant();
var configuredCandidates = config?.Tooling?.Tools
.FirstOrDefault(t => string.Equals(t.Tool, overrideTool, StringComparison.OrdinalIgnoreCase))
?.Executables
?.Where(x => !string.IsNullOrWhiteSpace(x))
.ToList();
if (configuredCandidates is not null)
{
foreach (var configured in configuredCandidates)
{
var resolvedConfigured = ResolveFromPath(configured!) ?? configured!;
if (IsUsableExecutable(resolvedConfigured))
return new CommandResolutionResult(command, resolvedConfigured, CommandResolutionSource.ConfiguredOverride);
}
}
foreach (var candidate in BuildWindowsCandidates(command, normalized))
{
var resolved = ResolveFromPath(candidate);
if (!string.IsNullOrWhiteSpace(resolved))
{
var source = candidate.EndsWith(".cmd", StringComparison.OrdinalIgnoreCase) ||
candidate.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) ||
candidate.EndsWith(".bat", StringComparison.OrdinalIgnoreCase)
? CommandResolutionSource.Shim
: CommandResolutionSource.Path;
return new CommandResolutionResult(command, resolved!, source);
}
}
if (normalized is "npm" or "npx" or "pnpm" or "yarn")
{
var nodePath = ResolveFromPath("node.exe") ?? ResolveFromPath("node");
if (!string.IsNullOrWhiteSpace(nodePath))
{
var nodeDir = Path.GetDirectoryName(nodePath);
if (!string.IsNullOrWhiteSpace(nodeDir))
{
var shim = Path.Combine(nodeDir, normalized + ".cmd");
if (File.Exists(shim))
return new CommandResolutionResult(command, shim, CommandResolutionSource.NodeAdjacentShim);
}
}
}
var fallback = BuildWindowsCandidates(command, normalized).LastOrDefault() ?? command;
return new CommandResolutionResult(command, fallback, CommandResolutionSource.Fallback);
}
public static string Resolve(string command)
{
return ResolveWithTrace(command).Resolved;
}
private static string? ResolveFromPath(string executable)
{
var pathValue = Environment.GetEnvironmentVariable("PATH");
if (string.IsNullOrWhiteSpace(pathValue))
return null;
foreach (var segment in pathValue.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries))
{
try
{
var expandedSegment = ExpandWindowsPathTokens(segment.Trim());
var candidate = Path.Combine(expandedSegment, executable);
if (File.Exists(candidate))
{
// If PATH lookup hit extensionless npm but npm.cmd exists beside it, prefer npm.cmd.
var fileName = Path.GetFileName(candidate).ToLowerInvariant();
if (fileName is "npm" or "npx" or "pnpm" or "yarn" or "tauri")
{
var shim = candidate + ".cmd";
if (File.Exists(shim))
return shim;
}
return candidate;
}
}
catch
{
// Ignore malformed PATH segments.
}
}
return null;
}
private static string ExpandWindowsPathTokens(string segment)
{
if (string.IsNullOrWhiteSpace(segment) || !OperatingSystem.IsWindows())
return segment;
var expanded = segment;
for (var i = 0; i < 4; i++)
{
var next = Environment.ExpandEnvironmentVariables(expanded);
if (string.Equals(next, expanded, StringComparison.Ordinal))
break;
expanded = next;
}
return expanded;
}
private static List<string> BuildWindowsCandidates(string command, string normalized)
{
var candidates = new List<string>();
if (normalized is "npm" or "npx" or "pnpm" or "yarn" or "tauri")
{
candidates.Add(command + ".cmd");
candidates.Add(command + ".exe");
candidates.Add(command + ".bat");
candidates.Add(command);
}
else
{
candidates.Add(command);
}
return candidates;
}
private static bool IsUsableExecutable(string resolved)
{
if (string.IsNullOrWhiteSpace(resolved))
return false;
if (Path.IsPathRooted(resolved))
return File.Exists(resolved);
return ResolveFromPath(resolved) is not null;
}
}

67
Journal.DevTool/Core/ConfigDoctorAutoFixService.cs Normal file
View File

@ -0,0 +1,67 @@
using Sdt.Config;
namespace Sdt.Core;
public sealed record DoctorAutoFixResult(
bool Success,
string Message,
int CreatedDirectories = 0,
string? BackupPath = null);
public sealed class ConfigDoctorAutoFixService
{
public IReadOnlyList<string> FindMissingWorkingDirectories(DevToolConfig config, string projectRoot)
{
var missing = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var workflow in config.Workflows)
{
foreach (var step in workflow.Steps)
{
if (string.IsNullOrWhiteSpace(step.WorkingDir))
continue;
var path = Path.GetFullPath(Path.Combine(projectRoot, step.WorkingDir));
if (!Directory.Exists(path))
missing.Add(path);
}
}
return missing.OrderBy(x => x, StringComparer.OrdinalIgnoreCase).ToList();
}
public DoctorAutoFixResult CreateMissingWorkingDirectories(IReadOnlyList<string> directories)
{
var created = 0;
try
{
foreach (var dir in directories)
{
if (Directory.Exists(dir))
continue;
Directory.CreateDirectory(dir);
created++;
}
return new DoctorAutoFixResult(
Success: true,
Message: created == 0 ? "No directories needed creation." : $"Created {created} missing working director{(created == 1 ? "y" : "ies")}.",
CreatedDirectories: created);
}
catch (Exception ex)
{
return new DoctorAutoFixResult(false, ex.Message, CreatedDirectories: created);
}
}
public DoctorAutoFixResult ApplyLegacyMigration(string projectRoot)
{
var configPath = ConfigLoader.FindConfigPath(projectRoot);
if (string.IsNullOrWhiteSpace(configPath))
return new DoctorAutoFixResult(false, "Could not find devtool.json for migration.");
var migration = ConfigLoader.ApplyLegacyTargetMigration(configPath, createBackup: true);
return new DoctorAutoFixResult(
Success: migration.Success,
Message: migration.Message,
BackupPath: migration.BackupPath);
}
}

270
Journal.DevTool/Core/ConfigDoctorService.cs Normal file
View File

@ -0,0 +1,270 @@
using Sdt.Config;
namespace Sdt.Core;
public enum DoctorStatus
{
Pass,
Warn,
Fail,
}
public sealed record DoctorCheck(
string Name,
DoctorStatus Status,
string Detail,
string? Fix = null);
public sealed record DoctorReport(
IReadOnlyList<DoctorCheck> Checks)
{
public bool HasFailures => Checks.Any(c => c.Status == DoctorStatus.Fail);
public bool HasWarnings => Checks.Any(c => c.Status == DoctorStatus.Warn);
}
public sealed class ConfigDoctorService(
IToolProbe? toolProbe = null,
IRequirementResolver? requirementResolver = null)
{
private readonly IToolProbe _toolProbe = toolProbe ?? new ToolProbeService();
private readonly IRequirementResolver _requirementResolver = requirementResolver ?? new RequirementResolver();
public async Task<DoctorReport> RunAsync(
DevToolConfig config,
string projectRoot,
CancellationToken cancellationToken = default)
{
var checks = new List<DoctorCheck>();
var workflowMap = config.Workflows.ToDictionary(w => w.Id, StringComparer.OrdinalIgnoreCase);
AddSchemaChecks(config, checks);
AddWorkflowChecks(config.Workflows, workflowMap, projectRoot, checks);
AddPathChecks(config, projectRoot, checks);
await AddToolProbeChecksAsync(config, projectRoot, checks, cancellationToken).ConfigureAwait(false);
return new DoctorReport(checks);
}
private static void AddSchemaChecks(DevToolConfig config, List<DoctorCheck> checks)
{
if (config.Workflows.Count == 0 && config.Targets.Count == 0)
{
checks.Add(new DoctorCheck(
"Config schema",
DoctorStatus.Fail,
"No workflows or legacy targets found.",
"Add workflows or run SDT init/bootstrap."));
return;
}
if (config.Workflows.Count == 0 && config.Targets.Count > 0)
{
checks.Add(new DoctorCheck(
"Legacy schema",
DoctorStatus.Fail,
"Targets-only config detected (strict mode will block execution).",
"Use SYSTEM -> Migrate legacy targets -> workflows."));
return;
}
if (config.Targets.Count > 0)
{
checks.Add(new DoctorCheck(
"Legacy schema",
DoctorStatus.Warn,
"Both workflows and legacy targets are present.",
"Prefer workflows-only config and remove legacy targets once migrated."));
}
else
{
checks.Add(new DoctorCheck("Config schema", DoctorStatus.Pass, "Workflow-first config detected."));
}
}
private static void AddWorkflowChecks(
IReadOnlyList<WorkflowDefinition> workflows,
IReadOnlyDictionary<string, WorkflowDefinition> workflowMap,
string projectRoot,
List<DoctorCheck> checks)
{
var duplicateIds = workflows
.GroupBy(w => w.Id, StringComparer.OrdinalIgnoreCase)
.Where(g => g.Count() > 1)
.Select(g => g.Key)
.ToList();
if (duplicateIds.Count > 0)
{
checks.Add(new DoctorCheck(
"Workflow IDs",
DoctorStatus.Fail,
$"Duplicate workflow IDs: {string.Join(", ", duplicateIds)}",
"Ensure each workflow has a unique id."));
}
else
{
checks.Add(new DoctorCheck("Workflow IDs", DoctorStatus.Pass, "No duplicate workflow IDs."));
}
var brokenDeps = new List<string>();
foreach (var workflow in workflows)
{
foreach (var dep in workflow.DependsOn)
{
if (!workflowMap.ContainsKey(dep))
brokenDeps.Add($"{workflow.Id} -> {dep}");
}
}
if (brokenDeps.Count > 0)
{
checks.Add(new DoctorCheck(
"Workflow dependencies",
DoctorStatus.Fail,
$"Missing dependencies: {string.Join("; ", brokenDeps)}",
"Fix dependsOn IDs to reference existing workflows."));
}
else
{
checks.Add(new DoctorCheck("Workflow dependencies", DoctorStatus.Pass, "All workflow dependencies are valid."));
}
var invalidSteps = new List<string>();
var missingWorkingDirs = new List<string>();
foreach (var workflow in workflows)
{
foreach (var step in workflow.Steps)
{
if (string.IsNullOrWhiteSpace(step.Command) && string.IsNullOrWhiteSpace(step.Action))
invalidSteps.Add($"{workflow.Id}/{step.Id}");
var stepDir = Path.GetFullPath(Path.Combine(projectRoot, step.WorkingDir));
if (!Directory.Exists(stepDir))
missingWorkingDirs.Add($"{workflow.Id}/{step.Id} -> {step.WorkingDir}");
}
}
if (invalidSteps.Count > 0)
{
checks.Add(new DoctorCheck(
"Step definitions",
DoctorStatus.Fail,
$"Steps missing command/action: {string.Join(", ", invalidSteps)}",
"Each step must define either action or command."));
}
else
{
checks.Add(new DoctorCheck("Step definitions", DoctorStatus.Pass, "All steps define an action or command."));
}
if (missingWorkingDirs.Count > 0)
{
checks.Add(new DoctorCheck(
"Working directories",
DoctorStatus.Warn,
$"Missing directories: {string.Join("; ", missingWorkingDirs)}",
"Create missing directories or fix step workingDir values."));
}
else
{
checks.Add(new DoctorCheck("Working directories", DoctorStatus.Pass, "All referenced working directories exist."));
}
}
private static void AddPathChecks(DevToolConfig config, string projectRoot, List<DoctorCheck> checks)
{
var configPath = Path.Combine(projectRoot, "devtool.json");
checks.Add(File.Exists(configPath)
? new DoctorCheck("Project root", DoctorStatus.Pass, $"Config found at {configPath}")
: new DoctorCheck("Project root", DoctorStatus.Fail, $"devtool.json not found at {configPath}", "Run SDT init/bootstrap."));
if (OperatingSystem.IsWindows())
{
var pathValue = Environment.GetEnvironmentVariable("PATH") ?? string.Empty;
var unresolvedSegments = pathValue
.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries)
.Where(s => s.Contains('%') && Environment.ExpandEnvironmentVariables(s) == s)
.Take(4)
.ToList();
if (unresolvedSegments.Count > 0)
{
checks.Add(new DoctorCheck(
"PATH expansion",
DoctorStatus.Warn,
$"Unresolved PATH tokens: {string.Join(" | ", unresolvedSegments)}",
"Set referenced env vars or remove invalid PATH segments."));
}
else
{
checks.Add(new DoctorCheck("PATH expansion", DoctorStatus.Pass, "No unresolved PATH token segments detected."));
}
}
if (config.Project?.RootHints.Count > 0)
{
checks.Add(new DoctorCheck("Root hints", DoctorStatus.Pass, $"Configured root hints: {string.Join(", ", config.Project.RootHints)}"));
}
else
{
checks.Add(new DoctorCheck(
"Root hints",
DoctorStatus.Warn,
"No project.rootHints configured.",
"Add rootHints markers (for example .git, *.sln, package.json)."));
}
}
private async Task AddToolProbeChecksAsync(
DevToolConfig config,
string projectRoot,
List<DoctorCheck> checks,
CancellationToken cancellationToken)
{
var requiredTools = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var workflow in config.Workflows)
{
foreach (var step in workflow.Steps)
{
foreach (var req in _requirementResolver.Resolve(step))
requiredTools.Add(req.Tool);
}
}
foreach (var profile in config.Debug?.Profiles ?? [])
{
foreach (var req in profile.Requires)
requiredTools.Add(req.Tool);
}
foreach (var toolDef in config.Tooling?.Tools ?? [])
requiredTools.Add(toolDef.Tool);
if (requiredTools.Count == 0)
{
checks.Add(new DoctorCheck("Tool probes", DoctorStatus.Warn, "No tools discovered from workflows/debug/tooling."));
return;
}
foreach (var tool in requiredTools.OrderBy(t => t, StringComparer.OrdinalIgnoreCase))
{
var probe = await _toolProbe.ProbeAsync(tool, projectRoot, config, cancellationToken).ConfigureAwait(false);
if (probe.IsAvailable)
{
checks.Add(new DoctorCheck(
$"Tool: {tool}",
DoctorStatus.Pass,
string.IsNullOrWhiteSpace(probe.Version) ? "available" : probe.Version!,
probe.Details));
}
else
{
checks.Add(new DoctorCheck(
$"Tool: {tool}",
DoctorStatus.Fail,
string.IsNullOrWhiteSpace(probe.Details) ? "not available" : probe.Details!,
$"Install/configure {tool} or set tooling.tools[].executables for non-standard paths."));
}
}
}
}

87
Journal.DevTool/Core/Contracts.cs Normal file
View File

@ -0,0 +1,87 @@
using Sdt.Config;
using Sdt.Runner;
namespace Sdt.Core;
public sealed record ProbeResult(
string Tool,
bool IsAvailable,
string? Version = null,
string? Details = null);
public sealed record InstallCommand(
string Command,
IReadOnlyList<string> Args);
public sealed record InstallPlan(
string Tool,
bool Supported,
string Summary,
IReadOnlyList<InstallCommand> Commands);
public sealed record WorkflowStepResult(
string WorkflowId,
string StepId,
string StepLabel,
RunResult Result);
public enum ExecutionStopReason
{
MissingPrereq,
InstallFailed,
CommandFailed,
ValidationFailed,
UserDeclined,
}
public sealed record WorkflowExecutionResult(
bool Success,
ExecutionStopReason? StopReason,
string Message,
IReadOnlyList<WorkflowStepResult> Steps);
public interface IToolProbe
{
Task<ProbeResult> ProbeAsync(
string tool,
string projectRoot,
DevToolConfig? config = null,
CancellationToken cancellationToken = default);
}
public interface IPrereqInstaller
{
Task<InstallPlan> GetInstallPlanAsync(
string tool,
string projectRoot,
DevToolConfig? config = null,
CancellationToken cancellationToken = default);
Task<RunResult> RunInstallAsync(
InstallCommand command,
string projectRoot,
Action<string, bool> onOutput,
CancellationToken cancellationToken = default);
}
public interface IActionRunner
{
Task<RunResult> RunStepAsync(
WorkflowStep step,
string projectRoot,
Action<string, bool> onOutput,
CancellationToken cancellationToken = default);
}
public interface IWorkflowPlanner
{
List<WorkflowDefinition> ResolvePlan(
WorkflowDefinition workflow,
IReadOnlyDictionary<string, WorkflowDefinition> allWorkflows);
}
public interface IRequirementResolver
{
List<ToolRequirement> Resolve(WorkflowStep step);
List<ToolRequirement> Resolve(BuildTarget target);
}

52
Journal.DevTool/Core/Debug/DebugContracts.cs Normal file
View File

@ -0,0 +1,52 @@
using Sdt.Config;
using Sdt.Runner;
namespace Sdt.Core.Debug;
public sealed record DebugRunResult(
bool Success,
ExecutionStopReason? StopReason,
string Message,
DebugProfileDefinition Profile,
RunResult? RunResult,
IReadOnlyList<string> OutputLines,
IReadOnlyList<ProbeResult> Probes);
public sealed record DiagnosticsBundleResult(
bool Success,
string BundleDirectory,
string? ZipPath,
string Message);
public sealed record DiagnosticsBundleRequest(
string Category,
string ProjectRoot,
string SummaryMessage,
IReadOnlyList<string> OutputLines,
IReadOnlyList<WorkflowStepResult> WorkflowSteps,
IReadOnlyList<ProbeResult> Probes,
DebugDiagnosticsOptions DiagnosticsOptions,
DevToolConfig Config,
ExecutionStopReason? StopReason = null,
RunResult? DebugRun = null,
DebugProfileDefinition? DebugProfile = null);
public interface IDebugProfileRunner
{
Task<DebugRunResult> RunAsync(
DebugProfileDefinition profile,
DevToolConfig config,
string projectRoot,
bool verbose,
Func<string, InstallPlan, Task<bool>> confirmInstallAsync,
Action<string, bool> onOutput,
Action<RunEvent>? onEvent = null,
CancellationToken cancellationToken = default);
}
public interface IDiagnosticsBundleService
{
Task<DiagnosticsBundleResult> WriteBundleAsync(
DiagnosticsBundleRequest request,
CancellationToken cancellationToken = default);
}

185
Journal.DevTool/Core/Debug/DebugProfileRunner.cs Normal file
View File

@ -0,0 +1,185 @@
using Sdt.Config;
using Sdt.Runner;
namespace Sdt.Core.Debug;
public sealed class DebugProfileRunner(
IToolProbe toolProbe,
IPrereqInstaller installer) : IDebugProfileRunner
{
private readonly IToolProbe _toolProbe = toolProbe;
private readonly IPrereqInstaller _installer = installer;
public async Task<DebugRunResult> RunAsync(
DebugProfileDefinition profile,
DevToolConfig config,
string projectRoot,
bool verbose,
Func<string, InstallPlan, Task<bool>> confirmInstallAsync,
Action<string, bool> onOutput,
Action<RunEvent>? onEvent = null,
CancellationToken cancellationToken = default)
{
var probes = new List<ProbeResult>();
var output = new List<string>();
onEvent?.Invoke(new RunEvent(
Category: "debug",
Type: RunEventType.DebugStarted,
Message: $"Debug profile '{profile.Id}' started."));
var requires = profile.Requires.Count > 0
? profile.Requires
: InferRequirements(profile);
foreach (var req in requires)
{
var probe = await _toolProbe.ProbeAsync(req.Tool, projectRoot, config, cancellationToken).ConfigureAwait(false);
probes.Add(probe);
if (probe.IsAvailable)
continue;
if (!string.IsNullOrWhiteSpace(probe.Details))
{
var line = $"Probe detail [{req.Tool}]: {probe.Details}";
output.Add("OUT: " + line);
if (verbose)
onOutput(line, false);
}
if (req.InstallPolicy == InstallPolicy.Never)
{
onEvent?.Invoke(new RunEvent(
Category: "debug",
Type: RunEventType.DebugCompleted,
Message: $"Missing prerequisite '{req.Tool}'.",
Tool: req.Tool,
Success: false));
return new DebugRunResult(
Success: false,
StopReason: ExecutionStopReason.MissingPrereq,
Message: $"Missing prerequisite '{req.Tool}' for debug profile '{profile.Label}'.",
Profile: profile,
RunResult: null,
OutputLines: output,
Probes: probes);
}
var installPlan = await _installer.GetInstallPlanAsync(req.Tool, projectRoot, config, cancellationToken).ConfigureAwait(false);
if (!installPlan.Supported || installPlan.Commands.Count == 0)
{
onEvent?.Invoke(new RunEvent(
Category: "debug",
Type: RunEventType.DebugCompleted,
Message: $"No installer plan available for '{req.Tool}'.",
Tool: req.Tool,
Success: false));
return new DebugRunResult(
Success: false,
StopReason: ExecutionStopReason.MissingPrereq,
Message: $"Missing prerequisite '{req.Tool}' and no installer plan is available.",
Profile: profile,
RunResult: null,
OutputLines: output,
Probes: probes);
}
var approved = req.InstallPolicy == InstallPolicy.Auto
? true
: await confirmInstallAsync(req.Tool, installPlan).ConfigureAwait(false);
if (!approved)
{
onEvent?.Invoke(new RunEvent(
Category: "debug",
Type: RunEventType.InstallDeclined,
Message: $"Install declined for '{req.Tool}'.",
Tool: req.Tool,
Success: false));
return new DebugRunResult(
Success: false,
StopReason: ExecutionStopReason.UserDeclined,
Message: $"Install declined for missing prerequisite '{req.Tool}'.",
Profile: profile,
RunResult: null,
OutputLines: output,
Probes: probes);
}
foreach (var cmd in installPlan.Commands)
{
var installResult = await _installer.RunInstallAsync(cmd, projectRoot, onOutput, cancellationToken).ConfigureAwait(false);
if (!installResult.Success)
{
onEvent?.Invoke(new RunEvent(
Category: "debug",
Type: RunEventType.DebugCompleted,
Message: $"Install failed for '{req.Tool}'.",
Tool: req.Tool,
Success: false,
ExitCode: installResult.ExitCode));
return new DebugRunResult(
Success: false,
StopReason: ExecutionStopReason.InstallFailed,
Message: $"Failed to install prerequisite '{req.Tool}'.",
Profile: profile,
RunResult: installResult,
OutputLines: output,
Probes: probes);
}
}
}
var cwd = Path.GetFullPath(Path.Combine(projectRoot, profile.WorkingDir));
var mergedEnv = profile.Env.Count > 0 ? profile.Env : null;
onEvent?.Invoke(new RunEvent(
Category: "debug",
Type: RunEventType.DebugCommandStarted,
Message: $"{profile.Command} {string.Join(" ", profile.Args)}"));
var run = await ProcessRunner.RunAsync(
profile.Command,
profile.Args,
cwd,
(line, isErr) =>
{
output.Add((isErr ? "ERR: " : "OUT: ") + line);
if (verbose)
onOutput(line, isErr);
},
mergedEnv,
cancellationToken).ConfigureAwait(false);
onEvent?.Invoke(new RunEvent(
Category: "debug",
Type: RunEventType.DebugCommandCompleted,
Message: $"Debug command exited {run.ExitCode}.",
Success: run.Success,
ExitCode: run.ExitCode));
onEvent?.Invoke(new RunEvent(
Category: "debug",
Type: RunEventType.DebugCompleted,
Message: run.Success ? "Debug run completed." : "Debug run failed.",
Success: run.Success,
ExitCode: run.ExitCode));
return new DebugRunResult(
Success: run.Success,
StopReason: run.Success ? null : ExecutionStopReason.CommandFailed,
Message: run.Success
? $"Debug profile '{profile.Label}' completed."
: $"Debug profile '{profile.Label}' exited with code {run.ExitCode}.",
Profile: profile,
RunResult: run,
OutputLines: output,
Probes: probes);
}
private static List<ToolRequirement> InferRequirements(DebugProfileDefinition profile)
{
return profile.Type.ToLowerInvariant() switch
{
"dotnet" => [new ToolRequirement { Tool = "dotnet" }],
"node" => [new ToolRequirement { Tool = "node" }, new ToolRequirement { Tool = "npm" }],
"python" => [new ToolRequirement { Tool = "python" }],
_ => string.IsNullOrWhiteSpace(profile.Command)
? []
: [new ToolRequirement { Tool = profile.Command }],
};
}
}

99
Journal.DevTool/Core/Debug/DiagnosticsBundleService.cs Normal file
View File

@ -0,0 +1,99 @@
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using Sdt.Config;
namespace Sdt.Core.Debug;
public sealed class DiagnosticsBundleService : IDiagnosticsBundleService
{
private static readonly JsonSerializerOptions JsonOptions = new()
{
WriteIndented = true
};
public async Task<DiagnosticsBundleResult> WriteBundleAsync(
DiagnosticsBundleRequest request,
CancellationToken cancellationToken = default)
{
try
{
var timestamp = DateTimeOffset.Now.ToString("yyyyMMdd-HHmmss");
var root = Path.GetFullPath(Path.Combine(request.ProjectRoot, request.DiagnosticsOptions.OutputDir));
var bundleDir = Path.Combine(root, $"{request.Category}-{timestamp}");
Directory.CreateDirectory(bundleDir);
var stepsPath = Path.Combine(bundleDir, "steps.json");
var toolsPath = Path.Combine(bundleDir, "tools.json");
var envPath = Path.Combine(bundleDir, "env.json");
var outputPath = Path.Combine(bundleDir, "output.log");
var summaryPath = Path.Combine(bundleDir, "summary.json");
await File.WriteAllTextAsync(stepsPath, JsonSerializer.Serialize(request.WorkflowSteps, JsonOptions), cancellationToken);
await File.WriteAllTextAsync(toolsPath, JsonSerializer.Serialize(request.Probes, JsonOptions), cancellationToken);
await File.WriteAllTextAsync(envPath, JsonSerializer.Serialize(CaptureEnvironment(request.DiagnosticsOptions), JsonOptions), cancellationToken);
await File.WriteAllLinesAsync(outputPath, request.OutputLines, cancellationToken);
var summary = new
{
category = request.Category,
stopReason = request.StopReason?.ToString(),
message = request.SummaryMessage,
createdAt = DateTimeOffset.Now,
configHash = HashConfig(request.Config),
debugProfile = request.DebugProfile?.Id,
debugExitCode = request.DebugRun?.ExitCode,
envCapture = BuildEnvCaptureSummary(request.DiagnosticsOptions),
};
await File.WriteAllTextAsync(summaryPath, JsonSerializer.Serialize(summary, JsonOptions), cancellationToken);
return new DiagnosticsBundleResult(
Success: true,
BundleDirectory: bundleDir,
ZipPath: null,
Message: "Diagnostics bundle generated.");
}
catch (Exception ex)
{
return new DiagnosticsBundleResult(
Success: false,
BundleDirectory: string.Empty,
ZipPath: null,
Message: ex.Message);
}
}
private static Dictionary<string, string> CaptureEnvironment(DebugDiagnosticsOptions options)
{
if (options.IncludeAllEnv)
{
return Environment.GetEnvironmentVariables()
.Cast<System.Collections.DictionaryEntry>()
.ToDictionary(e => e.Key?.ToString() ?? "", e => e.Value?.ToString() ?? "", StringComparer.OrdinalIgnoreCase);
}
if (options.CaptureEnvKeys.Count == 0)
return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
var captured = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var key in options.CaptureEnvKeys)
captured[key] = Environment.GetEnvironmentVariable(key) ?? "";
return captured;
}
private static string BuildEnvCaptureSummary(DebugDiagnosticsOptions options)
{
if (options.IncludeAllEnv)
return "full";
if (options.CaptureEnvKeys.Count == 0)
return "allowlist-empty (intentional minimal capture)";
return $"allowlist ({options.CaptureEnvKeys.Count} keys)";
}
private static string HashConfig(object config)
{
var json = JsonSerializer.Serialize(config);
var bytes = SHA256.HashData(Encoding.UTF8.GetBytes(json));
return Convert.ToHexString(bytes);
}
}

59
Journal.DevTool/Core/LegacyScriptRequirementResolver.cs Normal file
View File

@ -0,0 +1,59 @@
using Sdt.Config;
namespace Sdt.Core;
internal static class LegacyScriptRequirementResolver
{
public static List<ToolRequirement> InferForPowerShellArgs(IReadOnlyList<string> args)
{
var script = FindScriptArg(args);
if (string.IsNullOrWhiteSpace(script))
return [];
static ToolRequirement Req(string tool) => new() { Tool = tool, InstallPolicy = InstallPolicy.Prompt };
var file = Path.GetFileName(script).ToLowerInvariant();
var lowerArgs = args.Select(a => a.ToLowerInvariant()).ToList();
return file switch
{
"publish-app.ps1" => IsTauriTarget(lowerArgs)
? [Req("python"), Req("node"), Req("npm"), Req("cargo")]
: [Req("python"), Req("node"), Req("npm")],
"publish-sidecar.ps1" => [Req("python"), Req("dotnet")],
"publish-webgateway.ps1" => [Req("python"), Req("dotnet"), Req("node"), Req("npm")],
"run-webgateway.ps1" => [Req("python"), Req("dotnet")],
"migration-gate.ps1" => [Req("python"), Req("dotnet")],
"nuget-export-cache.ps1" => [Req("python"), Req("dotnet")],
"nuget-import-cache.ps1" => [Req("python"), Req("dotnet")],
"npm-clean.ps1" => [Req("python"), Req("node"), Req("npm")],
"publish-output.ps1" => [Req("python"), Req("dotnet"), Req("node"), Req("npm"), Req("cargo")],
"sync-output.ps1" => [Req("python")],
"dotnet-min.ps1" => [Req("python"), Req("dotnet")],
"pip-min.ps1" => [Req("python")],
_ => [Req("python")]
};
}
private static string? FindScriptArg(IReadOnlyList<string> args)
{
for (var i = 0; i < args.Count - 1; i++)
{
if (string.Equals(args[i], "-File", StringComparison.OrdinalIgnoreCase))
return args[i + 1];
}
return args.FirstOrDefault(a => a.EndsWith(".ps1", StringComparison.OrdinalIgnoreCase));
}
private static bool IsTauriTarget(IReadOnlyList<string> lowerArgs)
{
for (var i = 0; i < lowerArgs.Count - 1; i++)
{
if (lowerArgs[i] is "-target" or "--target" && lowerArgs[i + 1] == "tauri")
return true;
}
return false;
}
}

303
Journal.DevTool/Core/PrereqInstallerService.cs Normal file
View File

@ -0,0 +1,303 @@
using System.Diagnostics;
using System.Text.Json;
using System.Text.RegularExpressions;
using Sdt.Config;
using Sdt.Runner;
namespace Sdt.Core;
public sealed class PrereqInstallerService : IPrereqInstaller
{
public async Task<InstallPlan> GetInstallPlanAsync(
string tool,
string projectRoot,
DevToolConfig? config = null,
CancellationToken cancellationToken = default)
{
var fromConfig = TryGetPlanFromConfig(tool, config);
if (fromConfig is not null)
return fromConfig;
var scriptPath = ScriptLocator.FindHelperScript(projectRoot, "diag.py");
if (scriptPath is null)
return FallbackPlan(tool);
try
{
var psi = new ProcessStartInfo
{
FileName = PythonResolver.ResolveExecutable(),
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
WorkingDirectory = projectRoot,
};
psi.ArgumentList.Add(scriptPath);
psi.ArgumentList.Add("install-plan");
psi.ArgumentList.Add("--tool");
psi.ArgumentList.Add(tool);
psi.ArgumentList.Add("--json");
using var process = new Process { StartInfo = psi };
process.Start();
var stdout = await process.StandardOutput.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
var stderr = await process.StandardError.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
await process.WaitForExitAsync(cancellationToken).ConfigureAwait(false);
if (process.ExitCode != 0)
{
var fallback = FallbackPlan(tool);
return fallback with
{
Summary = $"diag.py install-plan failed for {tool}; using fallback templates. " +
$"{(string.IsNullOrWhiteSpace(stderr) ? "No stderr output." : stderr.Trim())}"
};
}
var parsed = JsonSerializer.Deserialize<InstallPlanJson>(stdout);
if (parsed is null)
{
var fallback = FallbackPlan(tool);
return fallback with { Summary = $"diag.py returned invalid JSON for {tool}; using fallback templates." };
}
var commands = parsed.Commands
.Select(c => new InstallCommand(c.Command ?? "", c.Args ?? []))
.Where(c => !string.IsNullOrWhiteSpace(c.Command))
.ToList();
if (!parsed.Supported || commands.Count == 0)
{
var fallback = FallbackPlan(tool);
return fallback with { Summary = $"diag.py returned no usable commands for {tool}; using fallback templates." };
}
return new InstallPlan(
parsed.Tool ?? tool,
parsed.Supported,
parsed.Summary ?? $"Install {tool}",
commands);
}
catch (Exception ex)
{
var fallback = FallbackPlan(tool);
return fallback with { Summary = $"diag.py install-plan exception for {tool}; using fallback templates. {ex.Message}" };
}
}
public Task<RunResult> RunInstallAsync(
InstallCommand command,
string projectRoot,
Action<string, bool> onOutput,
CancellationToken cancellationToken = default)
=> ProcessRunner.RunAsync(command.Command, command.Args, projectRoot, onOutput, cancellationToken: cancellationToken);
private static InstallPlan FallbackPlan(string tool)
{
var isWindows = OperatingSystem.IsWindows();
var normalized = tool.ToLowerInvariant();
if (normalized == "tauri")
return BuildTauriFallbackPlan();
var installCommand = normalized switch
{
"dotnet" => isWindows
? new InstallCommand("winget", ["install", "Microsoft.DotNet.SDK.10"])
: new InstallCommand("sh", ["-c", "echo Install dotnet SDK from your distro package manager"]),
"node" => isWindows
? new InstallCommand("winget", ["install", "OpenJS.NodeJS.LTS"])
: new InstallCommand("sh", ["-c", "echo Install nodejs via package manager"]),
"npm" => isWindows
? new InstallCommand("winget", ["install", "OpenJS.NodeJS.LTS"])
: new InstallCommand("sh", ["-c", "echo Install npm via package manager"]),
"cargo" => isWindows
? new InstallCommand("winget", ["install", "Rustlang.Rustup"])
: new InstallCommand("sh", ["-c", "curl https://sh.rustup.rs -sSf | sh"]),
"git" => isWindows
? new InstallCommand("winget", ["install", "Git.Git"])
: new InstallCommand("sh", ["-c", "echo Install git via package manager"]),
"docker" => isWindows
? new InstallCommand("winget", ["install", "Docker.DockerDesktop"])
: new InstallCommand("sh", ["-c", "echo Install docker engine via package manager"]),
"python" => isWindows
? new InstallCommand("winget", ["install", "Python.Python.3.12"])
: new InstallCommand("sh", ["-c", "echo Install python3 via package manager"]),
_ => new InstallCommand("sh", ["-c", $"echo No installer template for '{tool}'"]),
};
return new InstallPlan(
tool,
Supported: true,
Summary: $"Fallback install plan for {tool}",
Commands: [installCommand]);
}
private static InstallPlan BuildTauriFallbackPlan()
{
if (OperatingSystem.IsWindows())
{
return new InstallPlan(
"tauri",
Supported: true,
Summary: "Fallback tauri plan (Windows): install Node.js, Rust toolchain, and Tauri CLI. Visual Studio C++ build tools/WebView2 may also be required.",
Commands:
[
new InstallCommand("winget", ["install", "OpenJS.NodeJS.LTS"]),
new InstallCommand("winget", ["install", "Rustlang.Rustup"]),
new InstallCommand("npm", ["install", "-g", "@tauri-apps/cli"]),
]);
}
if (OperatingSystem.IsMacOS())
{
return new InstallPlan(
"tauri",
Supported: true,
Summary: "Fallback tauri plan (macOS): install Xcode command line tools, Rust toolchain, and Tauri CLI.",
Commands:
[
new InstallCommand("sh", ["-c", "xcode-select --install || true"]),
new InstallCommand("sh", ["-c", "curl https://sh.rustup.rs -sSf | sh -s -- -y"]),
new InstallCommand("npm", ["install", "-g", "@tauri-apps/cli"]),
]);
}
var linuxPlan = BuildLinuxTauriPrereqCommand();
return new InstallPlan(
"tauri",
Supported: true,
Summary: $"Fallback tauri plan (Linux): detected package manager `{linuxPlan.PackageManager}` for system deps, then install Rust toolchain and Tauri CLI.",
Commands:
[
new InstallCommand("sh", ["-c", linuxPlan.Command]),
new InstallCommand("sh", ["-c", "curl https://sh.rustup.rs -sSf | sh -s -- -y"]),
new InstallCommand("npm", ["install", "-g", "@tauri-apps/cli"]),
]);
}
private static (string PackageManager, string Command) BuildLinuxTauriPrereqCommand()
{
if (CommandExists("apt-get"))
{
return ("apt-get",
"sudo apt-get update && sudo apt-get install -y build-essential libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev");
}
if (CommandExists("dnf"))
{
return ("dnf",
"sudo dnf install -y gcc gcc-c++ make webkit2gtk4.1-devel gtk3-devel libappindicator-gtk3 librsvg2-devel");
}
if (CommandExists("pacman"))
{
return ("pacman",
"sudo pacman -S --needed base-devel webkit2gtk gtk3 libappindicator-gtk3 librsvg");
}
if (CommandExists("zypper"))
{
return ("zypper",
"sudo zypper install -y gcc gcc-c++ make webkit2gtk3-devel gtk3-devel libappindicator3-devel librsvg-devel");
}
if (CommandExists("apk"))
{
return ("apk",
"sudo apk add build-base webkit2gtk-dev gtk+3.0-dev libayatana-appindicator-dev librsvg-dev");
}
return ("unknown",
"echo Install tauri system dependencies using your distro package manager, then rerun SDT.");
}
private static bool CommandExists(string command)
{
try
{
var psi = new ProcessStartInfo
{
FileName = OperatingSystem.IsWindows() ? "where" : "which",
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
};
psi.ArgumentList.Add(command);
using var process = Process.Start(psi);
if (process is null)
return false;
process.WaitForExit(1500);
return process.ExitCode == 0;
}
catch
{
return false;
}
}
private static InstallPlan? TryGetPlanFromConfig(string tool, DevToolConfig? config)
{
var preferred = config?.Tooling?.Tools
.FirstOrDefault(t => string.Equals(t.Tool, tool, StringComparison.OrdinalIgnoreCase))
?.PreferredInstallCommands;
if (preferred is null || preferred.Count == 0)
return null;
var commands = new List<InstallCommand>();
foreach (var line in preferred)
{
var parts = SplitShellLike(line);
if (parts.Count == 0)
continue;
commands.Add(new InstallCommand(parts[0], parts.Skip(1).ToList()));
}
if (commands.Count == 0)
return null;
return new InstallPlan(
tool,
Supported: true,
Summary: $"Configured install commands for {tool}",
Commands: commands);
}
private static List<string> SplitShellLike(string input)
{
if (string.IsNullOrWhiteSpace(input))
return [];
var tokens = new List<string>();
var matches = Regex.Matches(input, "\"([^\"]*)\"|'([^']*)'|\\S+");
foreach (Match match in matches)
{
var value = match.Value.Trim();
if (value.Length >= 2 && (
(value.StartsWith("\"", StringComparison.Ordinal) && value.EndsWith("\"", StringComparison.Ordinal)) ||
(value.StartsWith("'", StringComparison.Ordinal) && value.EndsWith("'", StringComparison.Ordinal))))
{
value = value[1..^1];
}
if (!string.IsNullOrWhiteSpace(value))
tokens.Add(value);
}
return tokens;
}
private sealed class InstallPlanJson
{
public string? Tool { get; init; }
public bool Supported { get; init; }
public string? Summary { get; init; }
public List<InstallCommandJson> Commands { get; init; } = [];
}
private sealed class InstallCommandJson
{
public string? Command { get; init; }
public List<string>? Args { get; init; }
}
}

46
Journal.DevTool/Core/PythonResolver.cs Normal file
View File

@ -0,0 +1,46 @@
using System.Diagnostics;
namespace Sdt.Core;
internal static class PythonResolver
{
public static string ResolveExecutable()
{
var candidates = OperatingSystem.IsWindows()
? new[] { "python", "py" }
: new[] { "python3", "python" };
foreach (var candidate in candidates)
{
if (CanRun(candidate))
return candidate;
}
return "python";
}
private static bool CanRun(string exe)
{
try
{
var psi = new ProcessStartInfo
{
FileName = exe,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
};
psi.ArgumentList.Add("--version");
using var p = new Process { StartInfo = psi };
p.Start();
p.WaitForExit(2000);
return p.ExitCode == 0;
}
catch
{
return false;
}
}
}

67
Journal.DevTool/Core/RequirementResolver.cs Normal file
View File

@ -0,0 +1,67 @@
using Sdt.Config;
namespace Sdt.Core;
public sealed class RequirementResolver : IRequirementResolver
{
public List<ToolRequirement> Resolve(WorkflowStep step)
{
if (step.Requires.Count > 0)
return step.Requires.ToList();
if (!string.IsNullOrWhiteSpace(step.Action))
return InferActionRequirements(step.Action);
if (string.IsNullOrWhiteSpace(step.Command))
return [];
return InferCommandRequirements(step.Command, step.Args);
}
public List<ToolRequirement> Resolve(BuildTarget target)
{
if (string.IsNullOrWhiteSpace(target.Command))
return [];
return InferCommandRequirements(target.Command, target.Args);
}
private static List<ToolRequirement> InferActionRequirements(string action)
{
return action.ToLowerInvariant() switch
{
"dotnet-restore" or "dotnet-build" or "dotnet-test" or "dotnet-publish" => [Req("dotnet")],
"npm-install" or "npm-ci" or "npm-build" or "npm-test" or "npm-audit" => [Req("node"), Req("npm")],
"python-venv-create" or "python-pip-install" or "python-pip-sync" or "python-pytest" => [Req("python")],
"cargo-build" or "cargo-test" => [Req("cargo")],
"tauri-build" => [Req("cargo"), Req("node"), Req("npm")],
"git-status" or "git-fetch" or "git-pull" or "git-clean" => [Req("git")],
"docker-build" or "docker-compose-up" or "docker-compose-down" => [Req("docker")],
_ => [],
};
}
private static List<ToolRequirement> InferCommandRequirements(string command, IReadOnlyList<string> args)
{
return command.ToLowerInvariant() switch
{
"dotnet" => [Req("dotnet")],
"npm" => [Req("node"), Req("npm")],
"pnpm" => [Req("node"), Req("pnpm")],
"yarn" => [Req("node"), Req("yarn")],
"python" or "py" => [Req("python")],
"cargo" => [Req("cargo")],
"tauri" => [Req("cargo"), Req("node"), Req("npm")],
"git" => [Req("git")],
"docker" => [Req("docker")],
"pwsh" or "powershell" => LegacyScriptRequirementResolver.InferForPowerShellArgs(args),
_ => [],
};
}
private static ToolRequirement Req(string tool) => new()
{
Tool = tool,
InstallPolicy = InstallPolicy.Prompt,
};
}

65
Journal.DevTool/Core/RunEventJsonlRecorder.cs Normal file
View File

@ -0,0 +1,65 @@
using System.Text.Json;
using System.Text.Json.Serialization;
namespace Sdt.Core;
public sealed class RunEventJsonlRecorder : IDisposable
{
private static readonly JsonSerializerOptions JsonOptions = new()
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
WriteIndented = false
};
static RunEventJsonlRecorder()
{
JsonOptions.Converters.Add(new JsonStringEnumConverter());
}
private readonly StreamWriter _writer;
private readonly object _gate = new();
private bool _disposed;
public string FilePath { get; }
private RunEventJsonlRecorder(string filePath, StreamWriter writer)
{
FilePath = filePath;
_writer = writer;
}
public static RunEventJsonlRecorder Create(string projectRoot, string category)
{
var root = Path.Combine(projectRoot, ".sdt", "events");
Directory.CreateDirectory(root);
var fileName = $"{category}-{DateTimeOffset.Now:yyyyMMdd-HHmmss}.jsonl";
var path = Path.Combine(root, fileName);
var writer = new StreamWriter(new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read))
{
AutoFlush = true
};
return new RunEventJsonlRecorder(path, writer);
}
public void Write(RunEvent evt)
{
lock (_gate)
{
if (_disposed)
return;
var line = JsonSerializer.Serialize(evt, JsonOptions);
_writer.WriteLine(line);
}
}
public void Dispose()
{
lock (_gate)
{
if (_disposed)
return;
_disposed = true;
_writer.Dispose();
}
}
}

99
Journal.DevTool/Core/RunEventLogReader.cs Normal file
View File

@ -0,0 +1,99 @@
using System.Text.Json;
namespace Sdt.Core;
public sealed record RunEventLogFile(
string Path,
string Name,
DateTimeOffset LastWriteTime,
long SizeBytes);
public sealed class RunEventLogReader
{
public IReadOnlyList<RunEventLogFile> ListEventFiles(string projectRoot)
{
var eventsRoot = Path.Combine(projectRoot, ".sdt", "events");
if (!Directory.Exists(eventsRoot))
return [];
return Directory.EnumerateFiles(eventsRoot, "*.jsonl", SearchOption.TopDirectoryOnly)
.Select(path =>
{
var info = new FileInfo(path);
return new RunEventLogFile(
Path: path,
Name: info.Name,
LastWriteTime: info.LastWriteTime,
SizeBytes: info.Length);
})
.OrderByDescending(f => f.LastWriteTime)
.ToList();
}
public IReadOnlyList<RunEvent> ReadEvents(string filePath)
{
var results = new List<RunEvent>();
if (!File.Exists(filePath))
return results;
foreach (var line in File.ReadLines(filePath))
{
if (string.IsNullOrWhiteSpace(line))
continue;
if (TryParseLine(line, out var evt))
results.Add(evt!);
}
return results;
}
internal static bool TryParseLine(string jsonLine, out RunEvent? evt)
{
evt = null;
try
{
using var doc = JsonDocument.Parse(jsonLine);
var root = doc.RootElement;
var category = root.TryGetProperty("category", out var c) ? c.GetString() : null;
var typeRaw = root.TryGetProperty("type", out var t) ? t.GetString() : null;
var message = root.TryGetProperty("message", out var m) ? m.GetString() : null;
var workflowId = root.TryGetProperty("workflowId", out var wf) ? wf.GetString() : null;
var stepId = root.TryGetProperty("stepId", out var st) ? st.GetString() : null;
var tool = root.TryGetProperty("tool", out var tl) ? tl.GetString() : null;
var success = root.TryGetProperty("success", out var s) && s.ValueKind != JsonValueKind.Null ? s.GetBoolean() : (bool?)null;
var exitCode = root.TryGetProperty("exitCode", out var ec) && ec.ValueKind != JsonValueKind.Null ? ec.GetInt32() : (int?)null;
DateTimeOffset? occurred = null;
if (root.TryGetProperty("occurredAt", out var ts) && ts.ValueKind == JsonValueKind.String &&
DateTimeOffset.TryParse(ts.GetString(), out var parsed))
{
occurred = parsed;
}
if (string.IsNullOrWhiteSpace(category) ||
string.IsNullOrWhiteSpace(typeRaw) ||
string.IsNullOrWhiteSpace(message) ||
!Enum.TryParse<RunEventType>(typeRaw, ignoreCase: true, out var type))
{
return false;
}
evt = new RunEvent(
Category: category!,
Type: type,
Message: message!,
WorkflowId: workflowId,
StepId: stepId,
Tool: tool,
Success: success,
ExitCode: exitCode,
Timestamp: occurred);
return true;
}
catch
{
return false;
}
}
}

34
Journal.DevTool/Core/RunEvents.cs Normal file
View File

@ -0,0 +1,34 @@
namespace Sdt.Core;
public enum RunEventType
{
WorkflowStarted,
WorkflowPlanned,
WorkflowStepStarted,
WorkflowStepCompleted,
ProbeChecked,
ProbeFailed,
InstallPlanPrepared,
InstallDeclined,
InstallCommandStarted,
InstallCommandCompleted,
WorkflowCompleted,
DebugStarted,
DebugCommandStarted,
DebugCommandCompleted,
DebugCompleted,
}
public sealed record RunEvent(
string Category,
RunEventType Type,
string Message,
string? WorkflowId = null,
string? StepId = null,
string? Tool = null,
bool? Success = null,
int? ExitCode = null,
DateTimeOffset? Timestamp = null)
{
public DateTimeOffset OccurredAt { get; init; } = Timestamp ?? DateTimeOffset.Now;
}

19
Journal.DevTool/Core/ScriptLocator.cs Normal file
View File

@ -0,0 +1,19 @@
namespace Sdt.Core;
internal static class ScriptLocator
{
public static string? FindHelperScript(string projectRoot, string scriptFileName)
{
// Packaged location: alongside executable in ./scripts
var bundled = Path.Combine(AppContext.BaseDirectory, "scripts", scriptFileName);
if (File.Exists(bundled))
return bundled;
// Source/project location fallback
var project = Path.Combine(projectRoot, "scripts", scriptFileName);
if (File.Exists(project))
return project;
return null;
}
}

122
Journal.DevTool/Core/ToolProbeService.cs Normal file
View File

@ -0,0 +1,122 @@
using System.Diagnostics;
using System.Text.Json;
using Sdt.Config;
namespace Sdt.Core;
public sealed class ToolProbeService : IToolProbe
{
public async Task<ProbeResult> ProbeAsync(
string tool,
string projectRoot,
DevToolConfig? config = null,
CancellationToken cancellationToken = default)
{
var direct = await ProbeDirectAsync(tool, config, cancellationToken).ConfigureAwait(false);
if (direct.IsAvailable)
return direct;
var scriptPath = ScriptLocator.FindHelperScript(projectRoot, "diag.py");
if (scriptPath is null)
return direct;
if (!(await ProbeDirectAsync("python", config, cancellationToken).ConfigureAwait(false)).IsAvailable)
return direct;
try
{
var psi = new ProcessStartInfo
{
FileName = PythonResolver.ResolveExecutable(),
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
WorkingDirectory = projectRoot,
};
psi.ArgumentList.Add(scriptPath);
psi.ArgumentList.Add("probe");
psi.ArgumentList.Add("--tool");
psi.ArgumentList.Add(tool);
psi.ArgumentList.Add("--json");
using var process = new Process { StartInfo = psi };
process.Start();
var stdout = await process.StandardOutput.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
var stderr = await process.StandardError.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
await process.WaitForExitAsync(cancellationToken).ConfigureAwait(false);
if (process.ExitCode != 0)
return new ProbeResult(tool, false, Details: stderr.Trim());
var parsed = JsonSerializer.Deserialize<DiagProbeJson>(stdout);
if (parsed is null)
return new ProbeResult(tool, false, Details: "diag.py returned invalid JSON");
return new ProbeResult(parsed.Tool ?? tool, parsed.Available, parsed.Version, parsed.Details);
}
catch (Exception ex)
{
return new ProbeResult(tool, false, Details: ex.Message);
}
}
private static async Task<ProbeResult> ProbeDirectAsync(string tool, DevToolConfig? config, CancellationToken cancellationToken)
{
var command = tool.ToLowerInvariant() switch
{
"python" => PythonResolver.ResolveExecutable(),
"dotnet" => "dotnet",
"node" => "node",
"npm" => "npm",
"cargo" => "cargo",
"tauri" => "tauri",
"git" => "git",
"docker" => "docker",
_ => tool,
};
var resolution = CommandResolver.ResolveWithTrace(command, config, tool);
command = resolution.Resolved;
var versionArg = command is "python" ? "--version" : "--version";
try
{
var psi = new ProcessStartInfo
{
FileName = command,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
};
psi.ArgumentList.Add(versionArg);
using var process = new Process { StartInfo = psi };
process.Start();
var stdout = await process.StandardOutput.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
var stderr = await process.StandardError.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
await process.WaitForExitAsync(cancellationToken).ConfigureAwait(false);
if (process.ExitCode != 0)
{
var failDetails = string.IsNullOrWhiteSpace(stderr) ? stdout.Trim() : stderr.Trim();
var trace = $"{resolution.Source}: {resolution.Resolved}";
return new ProbeResult(tool, false, Details: string.IsNullOrWhiteSpace(failDetails) ? trace : $"{trace} | {failDetails}");
}
var version = string.IsNullOrWhiteSpace(stdout) ? stderr.Trim() : stdout.Trim();
return new ProbeResult(tool, true, Version: version, Details: $"{resolution.Source}: {resolution.Resolved}");
}
catch (Exception ex)
{
return new ProbeResult(tool, false, Details: $"{resolution.Source}: {resolution.Resolved} | {ex.Message}");
}
}
private sealed class DiagProbeJson
{
public string? Tool { get; init; }
public bool Available { get; init; }
public string? Version { get; init; }
public string? Details { get; init; }
}
}

273
Journal.DevTool/Core/WorkflowExecutor.cs Normal file
View File

@ -0,0 +1,273 @@
using Sdt.Config;
namespace Sdt.Core;
public sealed class WorkflowExecutor(
IWorkflowPlanner planner,
IToolProbe toolProbe,
IPrereqInstaller installer,
IActionRunner actionRunner,
IRequirementResolver requirementResolver)
{
private readonly IWorkflowPlanner _planner = planner;
private readonly IToolProbe _toolProbe = toolProbe;
private readonly IPrereqInstaller _installer = installer;
private readonly IActionRunner _actionRunner = actionRunner;
private readonly IRequirementResolver _requirementResolver = requirementResolver;
public async Task<WorkflowExecutionResult> ExecuteAsync(
WorkflowDefinition rootWorkflow,
IReadOnlyDictionary<string, WorkflowDefinition> allWorkflows,
DevToolConfig config,
string projectRoot,
Func<string, InstallPlan, Task<bool>> confirmInstallAsync,
Action<string, bool> onOutput,
Action<RunEvent>? onEvent = null,
CancellationToken cancellationToken = default)
{
var results = new List<WorkflowStepResult>();
var plan = _planner.ResolvePlan(rootWorkflow, allWorkflows);
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.WorkflowStarted,
Message: $"Workflow '{rootWorkflow.Id}' started.",
WorkflowId: rootWorkflow.Id));
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.WorkflowPlanned,
Message: $"Execution plan contains {plan.Count} workflow(s).",
WorkflowId: rootWorkflow.Id));
if (plan.Count == 0)
{
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.WorkflowCompleted,
Message: "No executable workflow steps were found.",
WorkflowId: rootWorkflow.Id,
Success: false));
return new WorkflowExecutionResult(
Success: false,
StopReason: ExecutionStopReason.ValidationFailed,
Message: "This workflow has no executable steps.",
Steps: results);
}
foreach (var workflow in plan)
{
foreach (var step in workflow.Steps)
{
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.WorkflowStepStarted,
Message: $"Step '{step.Label}' started.",
WorkflowId: workflow.Id,
StepId: step.Id));
var requires = _requirementResolver.Resolve(step);
foreach (var req in requires)
{
var probe = await _toolProbe.ProbeAsync(req.Tool, projectRoot, config, cancellationToken).ConfigureAwait(false);
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.ProbeChecked,
Message: probe.IsAvailable
? $"Tool '{req.Tool}' is available."
: $"Tool '{req.Tool}' is missing.",
WorkflowId: workflow.Id,
StepId: step.Id,
Tool: req.Tool,
Success: probe.IsAvailable));
if (probe.IsAvailable)
continue;
if (!string.IsNullOrWhiteSpace(probe.Details))
{
onOutput($"Probe detail [{req.Tool}]: {probe.Details}", false);
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.ProbeFailed,
Message: probe.Details,
WorkflowId: workflow.Id,
StepId: step.Id,
Tool: req.Tool,
Success: false));
}
if (req.InstallPolicy == InstallPolicy.Never)
{
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.WorkflowCompleted,
Message: $"Missing prerequisite '{req.Tool}'.",
WorkflowId: rootWorkflow.Id,
Tool: req.Tool,
Success: false));
return new WorkflowExecutionResult(
Success: false,
StopReason: ExecutionStopReason.MissingPrereq,
Message: $"Missing prerequisite '{req.Tool}' for step '{step.Label}'.",
Steps: results);
}
var installPlan = await _installer.GetInstallPlanAsync(
req.Tool,
projectRoot,
config,
cancellationToken).ConfigureAwait(false);
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.InstallPlanPrepared,
Message: installPlan.Summary,
WorkflowId: workflow.Id,
StepId: step.Id,
Tool: req.Tool,
Success: installPlan.Supported));
if (!installPlan.Supported || installPlan.Commands.Count == 0)
{
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.WorkflowCompleted,
Message: $"No installer plan available for '{req.Tool}'.",
WorkflowId: rootWorkflow.Id,
Tool: req.Tool,
Success: false));
return new WorkflowExecutionResult(
Success: false,
StopReason: ExecutionStopReason.MissingPrereq,
Message: $"Missing prerequisite '{req.Tool}' and no installer plan is available.",
Steps: results);
}
var approved = req.InstallPolicy == InstallPolicy.Auto
? true
: await confirmInstallAsync(req.Tool, installPlan).ConfigureAwait(false);
if (!approved)
{
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.InstallDeclined,
Message: $"Install declined for '{req.Tool}'.",
WorkflowId: workflow.Id,
StepId: step.Id,
Tool: req.Tool,
Success: false));
return new WorkflowExecutionResult(
Success: false,
StopReason: ExecutionStopReason.UserDeclined,
Message: $"Install declined for missing prerequisite '{req.Tool}'.",
Steps: results);
}
foreach (var installCommand in installPlan.Commands)
{
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.InstallCommandStarted,
Message: $"{installCommand.Command} {string.Join(" ", installCommand.Args)}",
WorkflowId: workflow.Id,
StepId: step.Id,
Tool: req.Tool));
var installResult = await _installer.RunInstallAsync(
installCommand,
projectRoot,
onOutput,
cancellationToken).ConfigureAwait(false);
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.InstallCommandCompleted,
Message: $"Install command exited {installResult.ExitCode}.",
WorkflowId: workflow.Id,
StepId: step.Id,
Tool: req.Tool,
Success: installResult.Success,
ExitCode: installResult.ExitCode));
if (!installResult.Success)
{
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.WorkflowCompleted,
Message: $"Install failed for '{req.Tool}'.",
WorkflowId: rootWorkflow.Id,
Tool: req.Tool,
Success: false));
return new WorkflowExecutionResult(
Success: false,
StopReason: ExecutionStopReason.InstallFailed,
Message: $"Failed to install prerequisite '{req.Tool}'.",
Steps: results);
}
}
var verifyProbe = await _toolProbe.ProbeAsync(req.Tool, projectRoot, config, cancellationToken).ConfigureAwait(false);
if (!verifyProbe.IsAvailable)
{
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.WorkflowCompleted,
Message: $"Tool '{req.Tool}' still missing after install.",
WorkflowId: rootWorkflow.Id,
Tool: req.Tool,
Success: false));
return new WorkflowExecutionResult(
Success: false,
StopReason: ExecutionStopReason.InstallFailed,
Message: $"Prerequisite '{req.Tool}' is still missing after install attempt.",
Steps: results);
}
}
var runResult = await _actionRunner.RunStepAsync(
step,
projectRoot,
onOutput,
cancellationToken).ConfigureAwait(false);
results.Add(new WorkflowStepResult(
workflow.Id,
step.Id,
string.IsNullOrWhiteSpace(step.Label) ? step.Id : step.Label,
runResult));
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.WorkflowStepCompleted,
Message: $"Step '{step.Label}' exited {runResult.ExitCode}.",
WorkflowId: workflow.Id,
StepId: step.Id,
Success: runResult.Success,
ExitCode: runResult.ExitCode));
if (!runResult.Success)
{
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.WorkflowCompleted,
Message: $"Step '{step.Label}' failed.",
WorkflowId: rootWorkflow.Id,
Success: false,
ExitCode: runResult.ExitCode));
return new WorkflowExecutionResult(
Success: false,
StopReason: ExecutionStopReason.CommandFailed,
Message: $"Step '{step.Label}' failed with exit code {runResult.ExitCode}.",
Steps: results);
}
}
}
onEvent?.Invoke(new RunEvent(
Category: "workflow",
Type: RunEventType.WorkflowCompleted,
Message: "Workflow completed successfully.",
WorkflowId: rootWorkflow.Id,
Success: true));
return new WorkflowExecutionResult(
Success: true,
StopReason: null,
Message: "Workflow completed successfully.",
Steps: results);
}
}

35
Journal.DevTool/Core/WorkflowPlanner.cs Normal file
View File

@ -0,0 +1,35 @@
using Sdt.Config;
namespace Sdt.Core;
public sealed class WorkflowPlanner : IWorkflowPlanner
{
public List<WorkflowDefinition> ResolvePlan(
WorkflowDefinition workflow,
IReadOnlyDictionary<string, WorkflowDefinition> allWorkflows)
{
var visited = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var plan = new List<WorkflowDefinition>();
Visit(workflow, allWorkflows, visited, plan);
return plan;
}
private static void Visit(
WorkflowDefinition workflow,
IReadOnlyDictionary<string, WorkflowDefinition> allWorkflows,
HashSet<string> visited,
List<WorkflowDefinition> plan)
{
if (!visited.Add(workflow.Id))
return;
foreach (var depId in workflow.DependsOn)
{
if (allWorkflows.TryGetValue(depId, out var dep))
Visit(dep, allWorkflows, visited, plan);
}
if (workflow.Steps.Count > 0)
plan.Add(workflow);
}
}

37
Journal.DevTool/DevTool.csproj Normal file
View File

@ -0,0 +1,37 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net10.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<AssemblyName>sdt</AssemblyName>
<RootNamespace>Sdt</RootNamespace>
<AllowUnsafeBlocks>false</AllowUnsafeBlocks>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Spectre.Console" Version="0.49.1" />
</ItemGroup>
<ItemGroup>
<Compile Remove="tests\**\*.cs" />
<None Include="tests\**\*" />
</ItemGroup>
<ItemGroup>
<Content Include="scripts\*.py">
<Link>scripts\%(Filename)%(Extension)</Link>
<TargetPath>scripts\%(Filename)%(Extension)</TargetPath>
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
<CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>
</Content>
<Content Include="scripts\dev-shell.ps1;scripts\dev-shell.sh;scripts\dev-shell.cmd;scripts\_pwsh-python-shim.ps1">
<Link>scripts\%(Filename)%(Extension)</Link>
<TargetPath>scripts\%(Filename)%(Extension)</TargetPath>
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
<CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>
</Content>
</ItemGroup>
</Project>

134
Journal.DevTool/Program.cs
View File

@ -2,30 +2,72 @@ using Sdt.Config;
using Sdt.Tui;
using Spectre.Console;
// ── Workspace + project discovery ────────────────────────────────────────────
var workspaceResult = WorkspaceLoader.FindAndLoad();
var projectResult = ConfigLoader.FindAndLoad();
if (projectResult is null)
{
AnsiConsole.MarkupLine($"[bold {Theme.Red}]SDT:[/] [{Theme.Amber}]No devtool.json found[/] in current directory or any parent.");
AnsiConsole.MarkupLine(Theme.Faint("Create a devtool.json in your project root to get started."));
return 1;
}
// ── Main run loop (handles workspace project switching) ───────────────────────
var (currentConfig, currentRoot) = projectResult.Value;
var (workspace, workspaceRoot) = workspaceResult.HasValue
? (workspaceResult.Value.Config, workspaceResult.Value.WorkspaceRoot)
: ((WorkspaceConfig?)null, (string?)null);
try
{
// ── Workspace + project discovery ────────────────────────────────────────
var workspaceResult = WorkspaceLoader.FindAndLoad();
var projectResult = ConfigLoader.FindAndLoad();
var cliArgs = Environment.GetCommandLineArgs().Skip(1).ToArray();
var forceInit = cliArgs.Any(a => string.Equals(a, "init", StringComparison.OrdinalIgnoreCase) ||
string.Equals(a, "--init", StringComparison.OrdinalIgnoreCase));
if (forceInit)
{
var scan = ConfigBootstrapper.Scan(Directory.GetCurrentDirectory());
var generated = ConfigBootstrapper.BuildDefaultConfig(scan);
var path = ConfigBootstrapper.WriteDefaultConfig(scan.ProjectRoot, generated, overwrite: false);
AnsiConsole.MarkupLine(Theme.Ok($"Initialized config at {path}"));
projectResult = ConfigLoader.FindAndLoad(scan.ProjectRoot);
}
if (projectResult is null)
{
AnsiConsole.MarkupLine($"[bold {Theme.Red}]SDT:[/] [{Theme.Amber}]No devtool.json found[/] in current directory or any parent.");
var bootstrap = AnsiConsole.Confirm(
$"[{Theme.Amber}]Generate a default devtool.json for this project now?[/]",
defaultValue: true);
if (!bootstrap)
{
AnsiConsole.MarkupLine(Theme.Faint("Create a devtool.json in your project root to get started."));
return 1;
}
var scan = ConfigBootstrapper.Scan(Directory.GetCurrentDirectory());
AnsiConsole.MarkupLine(Theme.Faint($"Detected project root: {scan.ProjectRoot}"));
if (scan.ToolFamilies.Count > 0)
AnsiConsole.MarkupLine(Theme.Faint($"Detected tool families: {string.Join(", ", scan.ToolFamilies)}"));
var generated = ConfigBootstrapper.BuildDefaultConfig(scan);
var preview = ConfigBootstrapper.ToJson(generated);
AnsiConsole.Write(new Panel(Markup.Escape(preview)).Header("Generated devtool.json preview").BorderStyle(Theme.DimStyle));
var confirmWrite = AnsiConsole.Confirm(
$"[{Theme.Amber}]Write generated devtool.json to {scan.ProjectRoot}?[/]",
defaultValue: true);
if (!confirmWrite)
return 1;
var path = ConfigBootstrapper.WriteDefaultConfig(scan.ProjectRoot, generated, overwrite: false);
AnsiConsole.MarkupLine(Theme.Ok($"Created {path}"));
projectResult = ConfigLoader.FindAndLoad(scan.ProjectRoot);
if (projectResult is null)
{
AnsiConsole.MarkupLine(Theme.Fail("Generated config could not be reloaded."));
return 1;
}
}
// ── Main run loop (handles workspace project switching) ────────────────
var currentLoaded = projectResult;
var (workspace, workspaceRoot) = workspaceResult.HasValue
? (workspaceResult.Value.Config, workspaceResult.Value.WorkspaceRoot)
: ((WorkspaceConfig?)null, (string?)null);
while (true)
{
var app = new App(currentConfig, currentRoot, workspace, workspaceRoot);
var app = new App(currentLoaded.Config, currentLoaded.ProjectRoot, currentLoaded.Warnings, workspace, workspaceRoot);
var result = await app.RunAsync();
if (result.Reason == AppExitReason.Quit)
@ -34,7 +76,18 @@ try
// User switched projects — reload config from new root
if (result.Reason == AppExitReason.SwitchProject && result.NewProjectRoot is not null)
{
var loaded = ConfigLoader.FindAndLoad(result.NewProjectRoot);
LoadedProjectConfig? loaded;
try
{
loaded = ConfigLoader.FindAndLoad(result.NewProjectRoot);
}
catch (Exception ex)
{
AnsiConsole.MarkupLine(Theme.Fail(ex.Message));
AnsiConsole.MarkupLine(Theme.Faint("Press any key to stay on current project..."));
Console.ReadKey(intercept: true);
continue;
}
if (loaded is null)
{
AnsiConsole.MarkupLine(Theme.Fail($"No devtool.json found at: {result.NewProjectRoot}"));
@ -43,7 +96,7 @@ try
continue; // go back to current app
}
(currentConfig, currentRoot) = loaded.Value;
currentLoaded = loaded;
}
}
@ -51,7 +104,40 @@ try
}
catch (Exception ex)
{
AnsiConsole.MarkupLine(Theme.Fail($"Fatal: {ex.Message}"));
AnsiConsole.WriteException(ex, ExceptionFormats.ShortenEverything);
var message = ex.Message;
var isExpectedMigrationError =
ex is InvalidOperationException &&
message.Contains("Legacy targets-only config detected", StringComparison.OrdinalIgnoreCase);
AnsiConsole.MarkupLine(Theme.Fail($"Fatal: {message}"));
if (isExpectedMigrationError)
{
var configPath = ConfigLoader.FindConfigPath();
if (!string.IsNullOrWhiteSpace(configPath))
{
var migrate = AnsiConsole.Confirm(
$"[{Theme.Amber}]Apply automatic migration now (creates backup + converts targets -> workflows)?[/]",
defaultValue: true);
if (migrate)
{
var result = ConfigLoader.ApplyLegacyTargetMigration(configPath, createBackup: true);
if (result.Success)
{
AnsiConsole.MarkupLine(Theme.Ok("Migration applied successfully."));
if (!string.IsNullOrWhiteSpace(result.BackupPath))
AnsiConsole.MarkupLine(Theme.Faint($"Backup: {result.BackupPath}"));
AnsiConsole.MarkupLine(Theme.Faint("Run sdt.exe again in strict mode."));
}
else
{
AnsiConsole.MarkupLine(Theme.Fail($"Migration failed: {result.Message}"));
}
}
}
}
if (!isExpectedMigrationError)
AnsiConsole.WriteException(ex, ExceptionFormats.ShortenEverything);
return 1;
}

350
Journal.DevTool/README.md
View File

@ -1,234 +1,200 @@
# SDT — Stan's Dev Tools
# SDT (Stan's Dev Tools)
> **Status: v0.1 — active development**
> Phosphor-green TUI build orchestrator. Currently embedded in Project Journal; long-term goal is a standalone universal dev tool.
Cross-platform terminal orchestrator for project workflows, toolchain checks, and prerequisite gating.
---
## Current State
## What It Is
- Standalone `.NET` TUI app (`net10.0`)
- Workflow-first config model in `devtool.json`
- Strict-by-default legacy migration (`targets`-only configs fail unless compat mode is enabled)
- Python-first diagnostics/build script layer under `scripts/`
- Fail-fast execution with install prompt gating for missing prerequisites
- Debug profiles with attach metadata and diagnostics bundle generation
- Workspace-first project switching with support for external project paths
- Workspace-level defaults layering via `sdt-defaults.json` (ancestor defaults merged, project config wins)
- Project status tracking is maintained in `ROADMAP.md`
- Core run-event stream (`RunEvent`) shared by workflow + debug execution (TUI consumes it; GUI-ready)
- Run events are persisted to JSONL at `.sdt/events/` for external tooling/GUI consumers
- TUI includes `SYSTEM -> View run events` to inspect persisted JSONL event logs
- `SYSTEM -> Run config doctor` can apply common autofixes (missing working dirs, legacy migration)
SDT is a terminal UI (TUI) application for managing builds, toolchains, and multi-project workspaces. It reads a `devtool.json` from your project root and presents a menu-driven interface so you never have to remember which script to run, in what order, with what flags.
```
____ ____ _____
/ ___|| _ \|_ _|
\___ \| | | | | |
___) | |_| | | |
|____/|____/ |_|
─────────── Project Journal v0.1.0 ─────────────
root: E:\stansshit\csharp\journal-master\journal
What would you like to do?
BUILD
> Publish Sidecar Build Journal.Sidecar as self-contained exe
Build Web UI Build SvelteKit bundle
Publish WebGateway Publish ASP.NET host with embedded web UI
Build Tauri Desktop App Build desktop exe (no installer)
Full Release Build ✦ Sidecar → Web → WebGateway → Tauri, in order
...
SYSTEM
⬡ Toolchain management python / node
⚙ Edit environment variables
✗ Quit
```
---
## Current Features (v0.1)
### Build Target Runner
- Menu driven by `devtool.json` — add/remove targets without touching SDT code
- **Dependency resolution**: targets declare `dependsOn`; SDT topologically sorts them and runs each step exactly once. Select `webgateway` and `web` runs first automatically. Select `all` and everything runs in the right order.
- **Live output streaming**: stdout in phosphor green, stderr in amber — you see the build as it happens
- Each step reports exit code and elapsed time
### Environment Variable Editor
- All configurable env vars declared in `devtool.json`
- Dropdown selection for known options (e.g. `none`/`python-sidecar` for AI provider)
- Free-text input for path overrides
- Changes apply to SDT's process environment for the current session
### Toolchain Management
Python:
- Detect system Python and venv status in one health-check table
- Create / recreate venv (`python -m venv`)
- Install requirements profile — select cpu / gpu / nlp, handles `--extra-index-url` automatically
- Upgrade pip
- Cross-platform venv path resolution (`Scripts/` on Windows, `bin/` on Linux/Mac)
Node / npm:
- Detect Node.js and npm versions
- Check `node_modules` status
- Run `npm install` (or `pnpm`/`yarn` — configurable per project)
### Multi-Project Workspace Switcher
- Place `sdt-workspace.json` in any parent directory listing your projects
- SDT detects it automatically on startup
- **Switch Project** appears in SYSTEM menu when workspace is loaded with more than one project
- Selecting a different project hot-reloads config in-process — no restart needed
- Project table shows current (`►`), path, and whether `devtool.json` exists
---
## Running SDT
From the project root (where `devtool.json` lives):
## Run
```powershell
dotnet run --project Journal.DevTool/Journal.DevTool.csproj
dotnet run --project DevTool.csproj
```
Or via `just`:
Run from any subdirectory inside a project; SDT walks up to find `devtool.json`.
If `devtool.json` is missing, SDT now offers to scan the repo and generate a default config.
Explicit bootstrap command:
```powershell
just sdt
dotnet run --project DevTool.csproj -- init
```
SDT walks up the directory tree from wherever you launch it to find `devtool.json`. You don't need to be in any specific directory.
Bootstrap detects common stacks (`dotnet`, `npm/node`, `python`, `cargo/tauri`, `git`, `docker`) and generates:
---
- default workflows
- toolchain/tooling defaults
- debug profiles + diagnostics defaults
## Config Files
## Config Model
### `devtool.json` (per project)
SDT supports both:
- `workflows` (preferred)
- `targets` (legacy; compat mode only)
### Legacy Migration Mode (v1.2)
- Default: strict mode
- Behavior: `targets`-only config fails early with migration instructions
- Preview file: SDT writes `devtool.generated.workflows.json` for migration help
- Temporary rollback: set `SDT_LEGACY_MODE=compat`
Permanent fix (recommended):
1. Open `devtool.generated.workflows.json`
2. Copy its `workflows` into `devtool.json`
3. Remove or empty legacy `targets`
4. Run `sdt.exe` again in strict mode
### Workflow shape (preferred)
```json
{
"name": "My Project",
"version": "1.0.0",
"toolchains": {
"python": {
"executable": "python3",
"venvDir": ".venv",
"profiles": [
{ "id": "default", "label": "Default", "requirementsFile": "requirements.txt" }
]
},
"node": { "packageManager": "npm", "workingDir": "frontend" }
},
"targets": [
"id": "build",
"label": "Build",
"description": "Build project",
"group": "Build",
"dependsOn": [],
"steps": [
{
"id": "build",
"label": "Build",
"description": "Build everything",
"group": "Build",
"command": "dotnet",
"args": ["build"],
"id": "dotnet-build",
"label": "dotnet build",
"action": "dotnet-build",
"actionArgs": [],
"workingDir": ".",
"dependsOn": []
}
],
"env": [
{
"key": "MY_VAR",
"description": "Controls something",
"default": "value",
"options": ["value", "other"]
"requires": [
{ "tool": "dotnet", "installPolicy": "Prompt" }
]
}
]
}
```
**Target fields:**
| Field | Description |
|-------|-------------|
| `id` | Unique identifier, referenced by `dependsOn` |
| `label` | Display name in the menu |
| `description` | Short hint shown in the menu |
| `group` | Menu category (BUILD / DEV / TEST / etc.) |
| `command` | Executable to run (`dotnet`, `pwsh`, `npm`, etc.) — `null` for virtual aggregator |
| `args` | Argument array passed to the executable |
| `workingDir` | Working directory relative to project root |
| `dependsOn` | List of target IDs that must run first |
### Extra sections
### `sdt-workspace.json` (per workspace, any parent directory)
- `tooling.tools[].preferredInstallCommands`: preferred install commands per tool
- `tooling.tools[].executables`: explicit executable candidates for non-standard PATH setups
- `project.rootHints`: files/folders that identify project root
- `env`: session-level environment variable editor values
- `debug.profiles[]`: run/attach debug profiles
- `debug.diagnostics`: diagnostics bundle policy (`.sdt/debug` by default)
- secure default: allowlist-only environment capture
- set `includeAllEnv=true` to opt into full environment capture
```json
{
"name": "My Dev Workspace",
"projects": [
{ "name": "Project A", "description": "Does X", "path": "project-a" },
{ "name": "Project B", "description": "Does Y", "path": "../other-repo/project-b" }
]
}
### Workspace Defaults Layering
If SDT finds `sdt-defaults.json` in the project directory tree (current project root or an ancestor), it merges it into the effective config before runtime:
- base layer: `sdt-defaults.json`
- override layer: project `devtool.json` (project values win)
Merge behavior:
- objects merge recursively
- arrays/scalars are replaced when project provides the property
This is useful for shared defaults like toolchains, diagnostics policies, and baseline env definitions across multiple projects in one workspace.
## Execution Behavior
For each workflow step:
1. Resolve dependencies (topological order)
2. Probe required tools
3. If missing, show install commands and prompt (`Prompt` policy)
4. On decline/install failure/step failure, stop immediately
5. Render step summary table with exit code + elapsed time
6. On workflow/debug failure, generate diagnostics bundle when enabled
Installer command precedence:
1. `tooling.tools[].preferredInstallCommands`
2. `scripts/diag.py install-plan`
3. built-in C# fallback templates (used automatically if script planning fails)
When a tool probe fails, SDT now prints probe diagnostics (including command resolution source/path) in run output before prompting for installs.
## Scripts
See [scripts/README.md](/e:/stansshit/csharp/DevTool-master/scripts/README.md).
Primary Python entrypoints:
- `scripts/diag.py`
- `scripts/build.py`
- `scripts/dotnet-min.py`
- `scripts/pip-min.py`
- `scripts/publish-*.py`
## Workspace Support
- Uses `sdt-workspace.json` when present
- If missing, can auto-discover nearby projects containing `devtool.json`
- Workspace screen can add external project roots (absolute paths supported)
- `projects[].disabled`, `projects[].tags`, and `projects[].toolFamilies` are supported
## Dev Shell Bootstrap
Python-first cross-shell dev environment bootstrap:
```powershell
# PowerShell
. ./scripts/dev-shell.ps1
# cmd
scripts\dev-shell.cmd
```
Paths are relative to the `sdt-workspace.json` file. Absolute paths also work.
---
## Project Structure
```
Journal.DevTool/
├── Journal.DevTool.csproj net10.0 exe, outputs as 'sdt'
├── Program.cs Entry point — discovers workspace + project, run loop
├── Config/
│ ├── DevToolConfig.cs devtool.json models (BuildTarget, EnvVarDef, ToolchainConfig)
│ ├── ConfigLoader.cs Walks up dirs to find and parse devtool.json
│ ├── WorkspaceConfig.cs sdt-workspace.json model
│ └── WorkspaceLoader.cs Finds and parses sdt-workspace.json
├── Runner/
│ ├── ProcessRunner.cs Runs a process with live stdout/stderr streaming
│ └── TargetRunner.cs Topological dependency resolver
└── Tui/
├── Theme.cs Phosphor green palette (#00FF41 + amber + red)
├── App.cs Main TUI loop — banner, menu, target runner, env editor
├── ToolchainScreen.cs Python venv/pip + Node/npm management
└── WorkspaceScreen.cs Project switcher
```bash
# bash/zsh
source ./scripts/dev-shell.sh
```
---
Underlying implementation is `scripts/dev_shell.py`:
## Roadmap
- `python scripts/dev_shell.py export --shell pwsh --json`
- `python scripts/dev_shell.py doctor`
### v0.2 — Usability & Polish
- [ ] `--target <id>` flag for non-interactive single-target run (CI use)
- [ ] `--list` flag to print targets and exit
- [ ] Config validation with clear error messages on startup
- [ ] Build history — last run result + timestamp per target (persisted to `.sdt-state.json`)
- [ ] Parallel target execution for independent steps (opt-in per target)
## Legacy PowerShell Compatibility
### v0.3 — Package Manager Depth
- [ ] Full pip environment health: list installed packages, outdated check
- [ ] npm/pnpm/yarn: show scripts from `package.json`, run arbitrary script
- [ ] Python version manager integration (pyenv, py launcher on Windows)
- [ ] Virtual environment activation hint for the current shell
Legacy `.ps1` scripts remain for migration compatibility only. New functionality is implemented in Python scripts first. `script-common.ps1` is legacy-only.
### v0.4 — Multi-Project & Workspace
- [ ] Workspace-level targets that span multiple projects (e.g. build all repos in order)
- [ ] Project dependency graph across workspace (project A's publish feeds project B's build)
- [ ] Workspace health dashboard — all projects' last-build status in one table
Legacy runtime behavior in v1.2:
### v0.5 — Env & Secrets
- [ ] `.env` file load/save support (per project and per workspace)
- [ ] Secret redaction in log output (already in Journal's LogRedactor — port to SDT)
- [ ] Environment profiles: save/load named env var sets (e.g. "dev", "staging")
- strict mode rejects `targets`-only configs by default
- compat mode (`SDT_LEGACY_MODE=compat`) temporarily allows legacy execution
- TUI `SYSTEM` includes `Migrate legacy targets -> workflows` to apply migration in place (with backup)
### v1.0 — Standalone Universal Tool
- [ ] Extract from Journal repo into its own standalone repository
- [ ] Publish as a `dotnet tool` (`dotnet tool install sdt`)
- [ ] Plugin system: projects can register custom SDT commands via `IsdtPlugin`
- [ ] GUI mode (Avalonia or web UI) as an optional launch mode — default CLI, `--gui` for graphical
- [ ] Linux and macOS first-class support (already mostly there — mainly path/exe resolution)
- [ ] JSON schema for `devtool.json` with IDE autocompletion
Deprecation target:
### Long-term Vision
SDT's goal is to be **the single tool you open when you sit down at a project** — regardless of language, framework, or OS. Instead of remembering 15 different CLI commands across `dotnet`, `npm`, `pip`, `cargo`, `just`, and `pwsh`, you open SDT and it knows your project's shape from `devtool.json`.
- v1.x: compatibility only (no new behavior guarantees)
- v2.0: remove legacy `.ps1` scripts from default SDT workflows and docs
The workspace layer means you can manage a portfolio of projects — switching between them, running cross-project builds, and keeping a consistent interface across everything you work on.
## Testing
---
Run unit/integration tests:
## Dependencies
```powershell
dotnet test tests/DevTool.Tests/DevTool.Tests.csproj
```
- [`Spectre.Console`](https://spectreconsole.net/) `0.49.1` — TUI rendering, selection prompts, tables, progress
Run Python script smoke checks:
No dependency on `Journal.Core` — SDT is intentionally standalone so it can be extracted cleanly.
---
## Notes
- SDT does **not** set background colour — it renders on whatever your terminal's background is. A dark terminal is strongly recommended for the phosphor look.
- Environment variable changes made in SDT apply to SDT's own process environment for the session. They are **not** written to your system or shell permanently — by design.
- When a build step fails, SDT stops the plan and does not run subsequent steps.
```powershell
python -m py_compile scripts/*.py
```

50
Journal.DevTool/ROADMAP.md Normal file
View File

@ -0,0 +1,50 @@
# SDT Roadmap / Kanban
## Done (v1.2 Stabilization)
- [x] Python-first runtime for diagnostics/build wrappers
- [x] Config bootstrap generator for missing `devtool.json`
- [x] Workflow-first execution + dual schema support
- [x] Strict legacy mode default (`targets`-only blocked)
- [x] Compatibility escape hatch (`SDT_LEGACY_MODE=compat`)
- [x] Auto-generated migration preview (`devtool.generated.workflows.json`)
- [x] In-app migration action: `Migrate legacy targets -> workflows`
- [x] Centralized requirement inference (`RequirementResolver`)
- [x] Installer planning precedence + fallback resilience
- [x] Windows resolver hardening (`%VAR%` PATH expansion)
- [x] Resolver tracing surfaced in probe details
- [x] Secure diagnostics default (allowlist-only env capture)
- [x] Workspace external project add flow
- [x] Shared run event stream (`RunEvent`) across workflow + debug execution
- [x] TUI event rendering layer wired on top of core run events (GUI-readiness slice)
- [x] Persist run-event stream to JSONL for external GUI/client consumption (`.sdt/events/*.jsonl`)
- [x] TUI events viewer for persisted run-event logs (`SYSTEM -> View run events`)
- [x] Config doctor (`SYSTEM -> Run config doctor`)
- [x] Doctor autofix actions (create missing working dirs + invoke legacy migration)
- [x] Rich probe diagnostics panel in workflow failure summary
- [x] Enhanced Tauri fallback guidance (Windows/macOS/Linux package manager aware)
- [x] Workspace-level defaults file layering (`sdt-defaults.json`) above per-project `devtool.json`
## In Progress (next focus)
- [x] Add dedicated TUI "Events" viewer for last run
- [x] Add doctor autofix actions for common issues (missing dirs, legacy schema migration)
## Next (v1.3 candidates)
- [ ] Setup wizard for first run (bootstrap + tool fixes)
- [ ] Env profiles (`dev`, `ci`, `release`) with deterministic merge order
- [ ] Managed secrets redaction policy for diagnostics bundles
- [ ] Favorites/quick actions across projects
## Later
- [ ] JSON event stream for GUI integration
- [ ] Native GUI shell over headless core services
- [ ] Remove legacy PowerShell wrappers in v2
## Current Milestone Status
- Robustness Sprint v1.2: **complete**
- v1.1 expansion items shipped partially (debug profiles + diagnostics + workspace add external)
- Remaining gaps for broader AIO vision are mainly UX/workspace scale and advanced env orchestration

9
Journal.DevTool/Runner/ProcessRunner.cs
View File

@ -18,11 +18,12 @@ public static class ProcessRunner
IEnumerable<string> args,
string workingDir,
Action<string, bool> onOutput,
IReadOnlyDictionary<string, string>? envOverrides = null,
CancellationToken cancellationToken = default)
{
var psi = new ProcessStartInfo
{
FileName = command,
FileName = Core.CommandResolver.Resolve(command),
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
@ -30,6 +31,12 @@ public static class ProcessRunner
WorkingDirectory = workingDir,
};
if (envOverrides is not null)
{
foreach (var kvp in envOverrides)
psi.Environment[kvp.Key] = kvp.Value;
}
foreach (var arg in args)
psi.ArgumentList.Add(arg);

673
Journal.DevTool/Tui/App.cs
View File

@ -1,28 +1,65 @@
using Sdt.Config;
using Sdt.Runner;
using Sdt.Core;
using Sdt.Core.Debug;
using Spectre.Console;
namespace Sdt.Tui;
/// <summary>Thin wrapper used in Spectre.Console selection prompts.</summary>
internal sealed record MenuItem(string Display, string Value);
public enum AppExitReason { Quit, SwitchProject }
public sealed record AppResult(AppExitReason Reason, string? NewProjectRoot = null);
public sealed class App(
DevToolConfig config,
string projectRoot,
WorkspaceConfig? workspace = null,
string? workspaceRoot = null)
public sealed class App
{
private DevToolConfig _config = config;
private string _projectRoot = projectRoot;
private readonly WorkspaceConfig? _workspace = workspace;
private readonly string? _workspaceRoot = workspaceRoot;
private DevToolConfig _config;
private string _projectRoot;
private readonly WorkspaceConfig? _workspace;
private readonly string? _workspaceRoot;
private List<WorkflowDefinition> _workflows;
private readonly List<string> _warnings;
private readonly IDebugProfileRunner _debugRunner;
private readonly IDiagnosticsBundleService _diagnostics;
private readonly IRequirementResolver _requirementResolver = new RequirementResolver();
private IReadOnlyDictionary<string, BuildTarget> TargetMap =>
_config.Targets.ToDictionary(t => t.Id, StringComparer.OrdinalIgnoreCase);
private readonly WorkflowExecutor _executor = new(
new WorkflowPlanner(),
new ToolProbeService(),
new PrereqInstallerService(),
new ActionRunner(),
new RequirementResolver());
private IReadOnlyDictionary<string, WorkflowDefinition> WorkflowMap =>
_workflows.ToDictionary(t => t.Id, StringComparer.OrdinalIgnoreCase);
public App(
DevToolConfig config,
string projectRoot,
IReadOnlyList<string>? warnings = null,
WorkspaceConfig? workspace = null,
string? workspaceRoot = null)
{
_config = config;
_projectRoot = projectRoot;
_workspace = workspace;
_workspaceRoot = workspaceRoot;
var normalized = WorkflowModelBuilder.Normalize(config, ResolveLegacyMode(), _requirementResolver);
_workflows = normalized.Workflows.ToList();
_warnings = [];
_debugRunner = new DebugProfileRunner(new ToolProbeService(), new PrereqInstallerService());
_diagnostics = new DiagnosticsBundleService();
if (warnings is not null)
_warnings.AddRange(warnings);
_warnings.AddRange(normalized.Warnings);
}
private static LegacyMode ResolveLegacyMode()
{
var raw = Environment.GetEnvironmentVariable("SDT_LEGACY_MODE");
return string.Equals(raw, "compat", StringComparison.OrdinalIgnoreCase)
? LegacyMode.Compat
: LegacyMode.Strict;
}
public async Task<AppResult> RunAsync()
{
@ -31,8 +68,14 @@ public sealed class App(
AnsiConsole.Clear();
RenderBanner();
var choice = ShowMainMenu();
if (_warnings.Count > 0)
{
foreach (var warning in _warnings.Distinct(StringComparer.OrdinalIgnoreCase))
AnsiConsole.MarkupLine(Theme.Warn("Config warning: " + warning));
AnsiConsole.WriteLine();
}
var choice = ShowMainMenu();
switch (choice)
{
case "__env__":
@ -43,6 +86,14 @@ public sealed class App(
await new ToolchainScreen(_config, _projectRoot).RunAsync();
break;
case "__doctor__":
await RunConfigDoctorAsync();
break;
case "__events__":
new EventsScreen(_projectRoot, _config.Name, _config.Version).Run();
break;
case "__workspace__":
if (_workspace is not null && _workspaceRoot is not null)
{
@ -53,14 +104,33 @@ public sealed class App(
}
break;
case "__migrate_legacy__":
ApplyLegacyMigration();
break;
case "__quit__":
AnsiConsole.MarkupLine("\n" + Theme.Faint("Later.") + "\n");
return new AppResult(AppExitReason.Quit);
default:
var targetMap = TargetMap;
if (targetMap.TryGetValue(choice, out var target))
await RunTargetAsync(target, targetMap);
if (choice.StartsWith("__debugattach__:", StringComparison.Ordinal))
{
var profileId = choice["__debugattach__:".Length..];
ShowAttachInstructions(profileId);
break;
}
if (choice.StartsWith("__debug__:", StringComparison.Ordinal))
{
var parts = choice.Split(':', 3, StringSplitOptions.None);
if (parts.Length == 3)
await RunDebugProfileAsync(parts[1], string.Equals(parts[2], "verbose", StringComparison.OrdinalIgnoreCase));
break;
}
var workflowMap = WorkflowMap;
if (workflowMap.TryGetValue(choice, out var workflow))
await RunWorkflowAsync(workflow, workflowMap);
break;
}
@ -72,14 +142,9 @@ public sealed class App(
}
}
// ── Banner ────────────────────────────────────────────────────────────────
private void RenderBanner()
{
// Phosphor green figlet
AnsiConsole.Write(new FigletText("SDT").Color(Theme.GreenColor));
// Project + workspace info line
var wsInfo = _workspace is not null
? $" [{Theme.GreenDim}]∙ {Markup.Escape(_workspace.Name)}[/]"
: string.Empty;
@ -87,12 +152,9 @@ public sealed class App(
AnsiConsole.Write(
new Rule($"[bold {Theme.GreenBold}]{Markup.Escape(_config.Name)}[/] [{Theme.GreenDim}]v{Markup.Escape(_config.Version)}[/]{wsInfo}")
.RuleStyle(Theme.DimStyle));
AnsiConsole.MarkupLine(Theme.Faint($"root: {_projectRoot}") + "\n");
}
// ── Main menu ─────────────────────────────────────────────────────────────
private string ShowMainMenu()
{
var prompt = new SelectionPrompt<MenuItem>()
@ -101,8 +163,7 @@ public sealed class App(
.MoreChoicesText(Theme.Faint("(scroll to see more)"))
.UseConverter(m => m.Display);
// Targets, grouped
var groups = _config.Targets
var groups = _workflows
.Where(t => !string.IsNullOrWhiteSpace(t.Label))
.GroupBy(t => string.IsNullOrWhiteSpace(t.Group) ? "General" : t.Group);
@ -119,9 +180,35 @@ public sealed class App(
prompt.AddChoiceGroup(header, items);
}
// System actions
var debugProfiles = _config.Debug?.Profiles ?? [];
if (debugProfiles.Count > 0)
{
var debugItems = new List<MenuItem>();
foreach (var profile in debugProfiles)
{
debugItems.Add(new MenuItem(
$"[{Theme.Green}]Run {Markup.Escape(profile.Label)}[/] [{Theme.GreenDim}]debug profile[/]",
$"__debug__:{profile.Id}:normal"));
debugItems.Add(new MenuItem(
$"[{Theme.Green}]Run {Markup.Escape(profile.Label)} (verbose)[/] [{Theme.GreenDim}]stream full output[/]",
$"__debug__:{profile.Id}:verbose"));
if (profile.Attach is not null)
{
debugItems.Add(new MenuItem(
$"[{Theme.Green}]Attach instructions: {Markup.Escape(profile.Label)}[/]",
$"__debugattach__:{profile.Id}"));
}
}
prompt.AddChoiceGroup(
new MenuItem($"[bold {Theme.Amber}]DEBUG[/]", "__group__"),
debugItems);
}
var systemItems = new List<MenuItem>
{
new($"[{Theme.Green}]🩺 Run config doctor[/] [{Theme.GreenDim}]validate config, tools, paths[/]", "__doctor__"),
new($"[{Theme.Green}]📜 View run events[/] [{Theme.GreenDim}].sdt/events JSONL viewer[/]", "__events__"),
new($"[{Theme.Green}]⚙ Edit environment variables[/]", "__env__"),
};
@ -130,11 +217,16 @@ public sealed class App(
$"[{Theme.Green}]⬡ Toolchain management[/] [{Theme.GreenDim}]python / node[/]",
"__toolchains__"));
if (_workspace is not null && (_workspace.Projects.Count > 1))
if (_workspace is not null)
systemItems.Insert(0, new MenuItem(
$"[{Theme.Green}]⇄ Switch project[/] [{Theme.GreenDim}]{Markup.Escape(_workspace.Name)}[/]",
$"[{Theme.Green}]⇄ Workspace projects[/] [{Theme.GreenDim}]{Markup.Escape(_workspace.Name)}[/]",
"__workspace__"));
if (_config.Targets.Count > 0)
systemItems.Insert(0, new MenuItem(
$"[{Theme.Green}]⇪ Migrate legacy targets → workflows[/] [{Theme.GreenDim}]writes devtool.json + backup[/]",
"__migrate_legacy__"));
systemItems.Add(new MenuItem($"[{Theme.GreenDim}]✗ Quit[/]", "__quit__"));
prompt.AddChoiceGroup(
@ -144,84 +236,489 @@ public sealed class App(
return AnsiConsole.Prompt(prompt).Value;
}
// ── Target execution ──────────────────────────────────────────────────────
private async Task RunTargetAsync(BuildTarget target, IReadOnlyDictionary<string, BuildTarget> targetMap)
private async Task RunWorkflowAsync(
WorkflowDefinition workflow,
IReadOnlyDictionary<string, WorkflowDefinition> workflowMap)
{
AnsiConsole.Clear();
AnsiConsole.Write(Theme.SectionRule(target.Label));
var plan = TargetRunner.ResolvePlan(target, targetMap);
AnsiConsole.Write(Theme.SectionRule(workflow.Label));
var plan = new WorkflowPlanner().ResolvePlan(workflow, workflowMap);
if (plan.Count == 0)
{
AnsiConsole.MarkupLine(Theme.Warn("This target has no executable steps."));
AnsiConsole.MarkupLine(Theme.Warn("This workflow has no executable steps."));
return;
}
if (plan.Count > 1)
{
AnsiConsole.MarkupLine(Theme.Faint($"Execution plan — {plan.Count} steps:"));
foreach (var step in plan)
AnsiConsole.MarkupLine($" [{Theme.GreenDim}]→[/] [{Theme.Green}]{Markup.Escape(step.Label)}[/]");
AnsiConsole.MarkupLine(Theme.Faint($"Execution plan — {plan.Count} workflow(s):"));
foreach (var item in plan)
AnsiConsole.MarkupLine($" [{Theme.GreenDim}]→[/] [{Theme.Green}]{Markup.Escape(item.Label)}[/]");
AnsiConsole.WriteLine();
}
var allOk = true;
var totalSw = System.Diagnostics.Stopwatch.StartNew();
var outputLines = new List<string>();
using var eventRecorder = RunEventJsonlRecorder.Create(_projectRoot, "workflow");
foreach (var step in plan)
{
AnsiConsole.Write(Theme.DimRule());
var workingDir = Path.GetFullPath(Path.Combine(_projectRoot, step.WorkingDir));
var cmdDisplay = $"{step.Command} {string.Join(" ", step.Args)}";
AnsiConsole.MarkupLine($"[{Theme.GreenDim}]$ {Markup.Escape(cmdDisplay)}[/]");
AnsiConsole.MarkupLine($"[{Theme.GreenDim}] {Markup.Escape(workingDir)}[/]\n");
RunResult result;
try
var result = await _executor.ExecuteAsync(
workflow,
workflowMap,
_config,
_projectRoot,
confirmInstallAsync: ConfirmInstallAsync,
onOutput: (line, isErr) =>
{
result = await ProcessRunner.RunAsync(
step.Command!,
step.Args,
workingDir,
(line, isErr) =>
{
var escaped = Markup.Escape(line);
AnsiConsole.MarkupLine(isErr
? $"[{Theme.Amber}]{escaped}[/]"
: $"[{Theme.Green}]{escaped}[/]");
});
}
catch (Exception ex)
outputLines.Add((isErr ? "ERR: " : "OUT: ") + line);
var escaped = Markup.Escape(line);
AnsiConsole.MarkupLine(isErr
? $"[{Theme.Amber}]{escaped}[/]"
: $"[{Theme.Green}]{escaped}[/]");
},
onEvent: evt =>
{
AnsiConsole.MarkupLine("\n" + Theme.Fail($"Failed to launch: {ex.Message}"));
allOk = false;
break;
}
eventRecorder.Write(evt);
RenderRunEvent(evt);
});
AnsiConsole.WriteLine();
if (result.Success)
AnsiConsole.MarkupLine(Theme.Ok($"{step.Label} ({result.Elapsed.TotalSeconds:F1}s)"));
else
{
AnsiConsole.MarkupLine(Theme.Fail($"{step.Label} — exited {result.ExitCode} ({result.Elapsed.TotalSeconds:F1}s)"));
allOk = false;
break;
}
}
totalSw.Stop();
AnsiConsole.Write(Theme.SectionRule());
AnsiConsole.MarkupLine(allOk
? "\n" + Theme.Ok($"Done! Total: {totalSw.Elapsed.TotalSeconds:F1}s")
: "\n" + Theme.Fail("Build failed. Check output above."));
RenderStepSummary(result);
RenderProbeDiagnosticsSummary(outputLines);
if (result.Success)
{
var totalSeconds = result.Steps.Sum(s => s.Result.Elapsed.TotalSeconds);
AnsiConsole.MarkupLine("\n" + Theme.Ok($"Done! Total: {totalSeconds:F1}s"));
AnsiConsole.MarkupLine(Theme.Faint($"Run events: {eventRecorder.FilePath}"));
return;
}
AnsiConsole.MarkupLine("\n" + Theme.Fail($"{result.StopReason}: {result.Message}"));
AnsiConsole.MarkupLine(Theme.Faint($"Run events: {eventRecorder.FilePath}"));
await WriteWorkflowDiagnosticsAsync(workflow, workflowMap, result, outputLines);
}
// ── Environment editor ────────────────────────────────────────────────────
private static void RenderStepSummary(WorkflowExecutionResult result)
{
if (result.Steps.Count == 0)
return;
var table = new Table()
.Border(TableBorder.Rounded)
.BorderStyle(Theme.DimStyle)
.AddColumn(new TableColumn($"[{Theme.Amber}]Workflow[/]"))
.AddColumn(new TableColumn($"[{Theme.Amber}]Step[/]"))
.AddColumn(new TableColumn($"[{Theme.Amber}]Exit[/]").Width(8))
.AddColumn(new TableColumn($"[{Theme.Amber}]Seconds[/]").Width(10))
.AddColumn(new TableColumn($"[{Theme.Amber}]Status[/]").Width(12));
foreach (var step in result.Steps)
{
var ok = step.Result.Success;
table.AddRow(
Theme.Faint(step.WorkflowId),
Theme.G(step.StepLabel),
Theme.Bold(step.Result.ExitCode.ToString()),
Theme.Faint($"{step.Result.Elapsed.TotalSeconds:F1}"),
ok ? Theme.Ok("ok") : Theme.Fail("failed"));
}
AnsiConsole.Write(table);
}
private async Task RunDebugProfileAsync(string profileId, bool verbose)
{
var profile = _config.Debug?.Profiles.FirstOrDefault(p => string.Equals(p.Id, profileId, StringComparison.OrdinalIgnoreCase));
if (profile is null)
{
AnsiConsole.MarkupLine(Theme.Fail($"Debug profile not found: {profileId}"));
return;
}
AnsiConsole.Clear();
AnsiConsole.Write(Theme.SectionRule($"DEBUG — {profile.Label}"));
using var eventRecorder = RunEventJsonlRecorder.Create(_projectRoot, "debug");
if (profile.Attach is not null)
{
AnsiConsole.MarkupLine(Theme.Faint($"Attach: {profile.Attach.Kind}"));
if (profile.Attach.Port is not null)
AnsiConsole.MarkupLine(Theme.Faint($"Port: {profile.Attach.Port}"));
if (!string.IsNullOrWhiteSpace(profile.Attach.ProcessName))
AnsiConsole.MarkupLine(Theme.Faint($"Process: {profile.Attach.ProcessName}"));
if (!string.IsNullOrWhiteSpace(profile.Attach.Note))
AnsiConsole.MarkupLine(Theme.Faint(profile.Attach.Note!));
AnsiConsole.WriteLine();
}
var result = await _debugRunner.RunAsync(
profile,
_config,
_projectRoot,
verbose,
ConfirmInstallAsync,
(line, isErr) =>
{
var escaped = Markup.Escape(line);
AnsiConsole.MarkupLine(isErr
? $"[{Theme.Amber}]{escaped}[/]"
: $"[{Theme.Green}]{escaped}[/]");
},
evt =>
{
eventRecorder.Write(evt);
RenderRunEvent(evt);
});
if (result.Success)
{
var seconds = result.RunResult?.Elapsed.TotalSeconds ?? 0;
AnsiConsole.MarkupLine("\n" + Theme.Ok($"Debug run completed in {seconds:F1}s"));
AnsiConsole.MarkupLine(Theme.Faint($"Run events: {eventRecorder.FilePath}"));
return;
}
AnsiConsole.MarkupLine("\n" + Theme.Fail($"{result.StopReason}: {result.Message}"));
AnsiConsole.MarkupLine(Theme.Faint($"Run events: {eventRecorder.FilePath}"));
var diagnostics = _config.Debug?.Diagnostics ?? new DebugDiagnosticsOptions();
if (!diagnostics.Enabled || !diagnostics.BundleOnFailure)
return;
var bundle = await _diagnostics.WriteBundleAsync(
new DiagnosticsBundleRequest(
Category: "debug",
ProjectRoot: _projectRoot,
SummaryMessage: result.Message,
OutputLines: result.OutputLines,
WorkflowSteps: [],
Probes: result.Probes,
DiagnosticsOptions: diagnostics,
Config: _config,
StopReason: result.StopReason,
DebugRun: result.RunResult,
DebugProfile: result.Profile));
if (bundle.Success)
AnsiConsole.MarkupLine(Theme.Warn($"Diagnostics bundle: {bundle.BundleDirectory}"));
else
AnsiConsole.MarkupLine(Theme.Warn($"Diagnostics bundle failed: {bundle.Message}"));
}
private static void RenderProbeDiagnosticsSummary(IReadOnlyList<string> outputLines)
{
var diagnostics = new List<(string Tool, string Detail)>();
foreach (var line in outputLines)
{
const string marker = "Probe detail [";
var markerIndex = line.IndexOf(marker, StringComparison.OrdinalIgnoreCase);
if (markerIndex < 0)
continue;
var toolStart = markerIndex + marker.Length;
var toolEnd = line.IndexOf(']', toolStart);
if (toolEnd <= toolStart)
continue;
var tool = line[toolStart..toolEnd].Trim();
var detailStart = line.IndexOf(':', toolEnd);
var detail = detailStart >= 0 && detailStart + 1 < line.Length
? line[(detailStart + 1)..].Trim()
: "";
if (!string.IsNullOrWhiteSpace(tool))
diagnostics.Add((tool, detail));
}
if (diagnostics.Count == 0)
return;
var table = new Table()
.Border(TableBorder.Rounded)
.BorderStyle(Theme.DimStyle)
.AddColumn(new TableColumn($"[{Theme.Amber}]Probe Tool[/]").Width(14))
.AddColumn(new TableColumn($"[{Theme.Amber}]Resolver / Probe Detail[/]"))
.AddColumn(new TableColumn($"[{Theme.Amber}]Suggested Fix[/]"));
foreach (var diag in diagnostics.Distinct())
{
table.AddRow(
Theme.Warn(diag.Tool),
Theme.Faint(diag.Detail),
Theme.Faint(GetProbeFixHint(diag.Tool, diag.Detail)));
}
AnsiConsole.WriteLine();
AnsiConsole.Write(Theme.SectionRule("PROBE DIAGNOSTICS"));
AnsiConsole.Write(table);
}
private static string GetProbeFixHint(string tool, string detail)
{
if (detail.Contains("ConfiguredOverride", StringComparison.OrdinalIgnoreCase))
return "Check tooling.tools[].executables paths.";
if (detail.Contains("NodeAdjacentShim", StringComparison.OrdinalIgnoreCase))
return "Node found; verify npm/yarn shim in node directory.";
if (detail.Contains("Fallback", StringComparison.OrdinalIgnoreCase))
return $"Add {tool} to PATH or set tooling.tools[].executables.";
return $"Install/configure {tool} then rerun.";
}
private static void RenderRunEvent(RunEvent evt)
{
var shouldRender = evt.Type is
RunEventType.WorkflowStarted or
RunEventType.WorkflowStepStarted or
RunEventType.WorkflowStepCompleted or
RunEventType.ProbeFailed or
RunEventType.InstallPlanPrepared or
RunEventType.DebugStarted or
RunEventType.DebugCommandStarted or
RunEventType.DebugCommandCompleted or
RunEventType.WorkflowCompleted or
RunEventType.DebugCompleted;
if (!shouldRender)
return;
var prefix = evt.Category.Equals("debug", StringComparison.OrdinalIgnoreCase) ? "DBG" : "RUN";
var tone = evt.Success is false ? Theme.Amber : Theme.GreenDim;
AnsiConsole.MarkupLine($"[{tone}]{prefix} {Markup.Escape(evt.Message)}[/]");
}
private void ShowAttachInstructions(string profileId)
{
var profile = _config.Debug?.Profiles.FirstOrDefault(p => string.Equals(p.Id, profileId, StringComparison.OrdinalIgnoreCase));
if (profile?.Attach is null)
{
AnsiConsole.MarkupLine(Theme.Warn("No attach instructions configured for this profile."));
return;
}
AnsiConsole.Clear();
AnsiConsole.Write(Theme.SectionRule($"ATTACH — {profile.Label}"));
AnsiConsole.MarkupLine(Theme.Faint($"Kind: {profile.Attach.Kind}"));
if (profile.Attach.Port is not null)
AnsiConsole.MarkupLine(Theme.Faint($"Port: {profile.Attach.Port}"));
if (!string.IsNullOrWhiteSpace(profile.Attach.ProcessName))
AnsiConsole.MarkupLine(Theme.Faint($"Process: {profile.Attach.ProcessName}"));
if (!string.IsNullOrWhiteSpace(profile.Attach.Note))
AnsiConsole.MarkupLine(Theme.G(profile.Attach.Note!));
}
private async Task WriteWorkflowDiagnosticsAsync(
WorkflowDefinition workflow,
IReadOnlyDictionary<string, WorkflowDefinition> workflowMap,
WorkflowExecutionResult result,
IReadOnlyList<string> outputLines)
{
var diagnostics = _config.Debug?.Diagnostics ?? new DebugDiagnosticsOptions();
if (!diagnostics.Enabled || !diagnostics.BundleOnFailure)
return;
var probes = await SnapshotWorkflowToolsAsync(workflow, workflowMap);
var bundle = await _diagnostics.WriteBundleAsync(
new DiagnosticsBundleRequest(
Category: "workflow",
ProjectRoot: _projectRoot,
SummaryMessage: result.Message,
OutputLines: outputLines,
WorkflowSteps: result.Steps,
Probes: probes,
DiagnosticsOptions: diagnostics,
Config: _config,
StopReason: result.StopReason));
if (bundle.Success)
AnsiConsole.MarkupLine(Theme.Warn($"Diagnostics bundle: {bundle.BundleDirectory}"));
else
AnsiConsole.MarkupLine(Theme.Warn($"Diagnostics bundle failed: {bundle.Message}"));
}
private async Task<IReadOnlyList<ProbeResult>> SnapshotWorkflowToolsAsync(
WorkflowDefinition workflow,
IReadOnlyDictionary<string, WorkflowDefinition> workflowMap)
{
var plan = new WorkflowPlanner().ResolvePlan(workflow, workflowMap);
var tools = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var item in plan)
{
foreach (var step in item.Steps)
{
foreach (var req in _requirementResolver.Resolve(step))
{
if (!string.IsNullOrWhiteSpace(req.Tool))
tools.Add(req.Tool);
}
}
}
var probeService = new ToolProbeService();
var probes = new List<ProbeResult>();
foreach (var tool in tools)
probes.Add(await probeService.ProbeAsync(tool, _projectRoot, _config));
return probes;
}
private Task<bool> ConfirmInstallAsync(string tool, InstallPlan plan)
{
AnsiConsole.MarkupLine(Theme.Warn($"Missing prerequisite: {tool}"));
AnsiConsole.MarkupLine(Theme.Faint(plan.Summary));
foreach (var cmd in plan.Commands)
AnsiConsole.MarkupLine(Theme.Faint($" $ {cmd.Command} {string.Join(" ", cmd.Args)}"));
var allow = AnsiConsole.Confirm(
$"[{Theme.Amber}]Run install commands for {Markup.Escape(tool)} now?[/]",
defaultValue: false);
return Task.FromResult(allow);
}
private async Task RunConfigDoctorAsync()
{
AnsiConsole.Clear();
AnsiConsole.Write(Theme.SectionRule("CONFIG DOCTOR"));
AnsiConsole.WriteLine();
var service = new ConfigDoctorService(new ToolProbeService(), _requirementResolver);
var report = await service.RunAsync(_config, _projectRoot);
var table = new Table()
.Border(TableBorder.Rounded)
.BorderStyle(Theme.DimStyle)
.AddColumn(new TableColumn($"[{Theme.Amber}]Check[/]").Width(26))
.AddColumn(new TableColumn($"[{Theme.Amber}]Status[/]").Width(10))
.AddColumn(new TableColumn($"[{Theme.Amber}]Detail[/]"))
.AddColumn(new TableColumn($"[{Theme.Amber}]Fix[/]"));
foreach (var check in report.Checks)
{
var statusText = check.Status switch
{
DoctorStatus.Pass => Theme.Ok("ok"),
DoctorStatus.Warn => Theme.Warn("warn"),
DoctorStatus.Fail => Theme.Fail("fail"),
_ => Theme.Faint("n/a"),
};
table.AddRow(
Theme.G(check.Name),
statusText,
Theme.Faint(check.Detail),
string.IsNullOrWhiteSpace(check.Fix) ? Theme.Faint("-") : Theme.Faint(check.Fix));
}
AnsiConsole.Write(table);
AnsiConsole.WriteLine();
if (report.HasFailures)
AnsiConsole.MarkupLine(Theme.Fail("Doctor found blocking issues."));
else if (report.HasWarnings)
AnsiConsole.MarkupLine(Theme.Warn("Doctor completed with warnings."));
else
AnsiConsole.MarkupLine(Theme.Ok("Doctor completed: no issues found."));
if (!report.HasFailures && !report.HasWarnings)
return;
var applyFixes = AnsiConsole.Confirm(
$"[{Theme.Amber}]Apply common autofixes now?[/]",
defaultValue: false);
if (!applyFixes)
return;
var fixer = new ConfigDoctorAutoFixService();
var missingDirs = fixer.FindMissingWorkingDirectories(_config, _projectRoot);
if (missingDirs.Count > 0)
{
var createDirs = AnsiConsole.Confirm(
$"[{Theme.Amber}]Create {missingDirs.Count} missing working director{(missingDirs.Count == 1 ? "y" : "ies")}?[/]",
defaultValue: true);
if (createDirs)
{
var dirFix = fixer.CreateMissingWorkingDirectories(missingDirs);
AnsiConsole.MarkupLine(dirFix.Success ? Theme.Ok(dirFix.Message) : Theme.Fail(dirFix.Message));
}
}
if (_config.Targets.Count > 0)
{
var migrate = AnsiConsole.Confirm(
$"[{Theme.Amber}]Migrate legacy targets to workflows now?[/]",
defaultValue: true);
if (migrate)
{
var migration = fixer.ApplyLegacyMigration(_projectRoot);
if (migration.Success)
{
AnsiConsole.MarkupLine(Theme.Ok("Legacy migration applied from doctor."));
if (!string.IsNullOrWhiteSpace(migration.BackupPath))
AnsiConsole.MarkupLine(Theme.Faint($"Backup: {migration.BackupPath}"));
var reloaded = ConfigLoader.FindAndLoad(_projectRoot);
if (reloaded is not null)
{
_config = reloaded.Config;
var normalized = WorkflowModelBuilder.Normalize(_config, ResolveLegacyMode(), _requirementResolver);
_workflows = normalized.Workflows.ToList();
_warnings.Clear();
_warnings.AddRange(reloaded.Warnings);
_warnings.AddRange(normalized.Warnings);
}
}
else
{
AnsiConsole.MarkupLine(Theme.Fail(migration.Message));
}
}
}
}
private void ApplyLegacyMigration()
{
if (_config.Targets.Count == 0)
{
AnsiConsole.MarkupLine(Theme.Warn("No legacy targets found in this config."));
return;
}
var configPath = ConfigLoader.FindConfigPath(_projectRoot);
if (string.IsNullOrWhiteSpace(configPath))
{
AnsiConsole.MarkupLine(Theme.Fail("Could not locate devtool.json to migrate."));
return;
}
var confirm = AnsiConsole.Confirm(
$"[{Theme.Amber}]Migrate legacy targets to workflows and overwrite devtool.json (with backup)?[/]",
defaultValue: true);
if (!confirm)
return;
var result = ConfigLoader.ApplyLegacyTargetMigration(configPath, createBackup: true);
if (!result.Success)
{
AnsiConsole.MarkupLine(Theme.Fail(result.Message));
return;
}
var reloaded = ConfigLoader.FindAndLoad(_projectRoot);
if (reloaded is null)
{
AnsiConsole.MarkupLine(Theme.Fail("Migration wrote config, but reload failed."));
return;
}
_config = reloaded.Config;
var normalized = WorkflowModelBuilder.Normalize(_config, ResolveLegacyMode(), _requirementResolver);
_workflows = normalized.Workflows.ToList();
_warnings.Clear();
_warnings.AddRange(reloaded.Warnings);
_warnings.AddRange(normalized.Warnings);
AnsiConsole.MarkupLine(Theme.Ok("Migration complete."));
if (!string.IsNullOrWhiteSpace(result.BackupPath))
AnsiConsole.MarkupLine(Theme.Faint($"Backup: {result.BackupPath}"));
}
private void EditEnvironment()
{

126
Journal.DevTool/Tui/EventsScreen.cs Normal file
View File

@ -0,0 +1,126 @@
using Sdt.Core;
using Spectre.Console;
namespace Sdt.Tui;
public sealed class EventsScreen(string projectRoot, string projectName, string version)
{
private readonly string _projectRoot = projectRoot;
private readonly string _projectName = projectName;
private readonly string _version = version;
private readonly RunEventLogReader _reader = new();
public void Run()
{
while (true)
{
AnsiConsole.Clear();
RenderHeader("EVENTS");
var files = _reader.ListEventFiles(_projectRoot);
if (files.Count == 0)
{
AnsiConsole.MarkupLine(Theme.Warn("No event logs found yet."));
AnsiConsole.MarkupLine(Theme.Faint("Run a workflow/debug action first, then return here."));
AnsiConsole.MarkupLine("\n" + Theme.Faint("Press any key to go back..."));
Console.ReadKey(intercept: true);
return;
}
var table = new Table()
.Border(TableBorder.Rounded)
.BorderStyle(Theme.DimStyle)
.AddColumn(new TableColumn($"[{Theme.Amber}]File[/]"))
.AddColumn(new TableColumn($"[{Theme.Amber}]Updated[/]").Width(21))
.AddColumn(new TableColumn($"[{Theme.Amber}]Size[/]").Width(10));
foreach (var file in files.Take(12))
{
table.AddRow(
Theme.G(file.Name),
Theme.Faint(file.LastWriteTime.ToString("yyyy-MM-dd HH:mm:ss")),
Theme.Faint($"{Math.Max(1, file.SizeBytes / 1024)} KB"));
}
AnsiConsole.Write(table);
AnsiConsole.WriteLine();
var choices = files
.Take(20)
.Select(f => new MenuItem(
$"[{Theme.Green}]{Markup.Escape(f.Name)}[/] [{Theme.GreenDim}]{f.LastWriteTime:yyyy-MM-dd HH:mm:ss}[/]",
f.Path))
.ToList();
choices.Add(new MenuItem(Theme.Faint("← Back"), "__back__"));
var selected = AnsiConsole.Prompt(
new SelectionPrompt<MenuItem>()
.Title($"[{Theme.Green}]Select an event log to view:[/]")
.PageSize(20)
.UseConverter(m => m.Display)
.AddChoices(choices));
if (selected.Value == "__back__")
return;
ShowEventFile(selected.Value);
}
}
private void ShowEventFile(string filePath)
{
var events = _reader.ReadEvents(filePath);
AnsiConsole.Clear();
RenderHeader("EVENTS VIEWER");
AnsiConsole.MarkupLine(Theme.Faint(Path.GetFileName(filePath)));
AnsiConsole.MarkupLine(Theme.Faint(filePath));
AnsiConsole.WriteLine();
if (events.Count == 0)
{
AnsiConsole.MarkupLine(Theme.Warn("No parseable events in selected file."));
AnsiConsole.MarkupLine("\n" + Theme.Faint("Press any key to return..."));
Console.ReadKey(intercept: true);
return;
}
var table = new Table()
.Border(TableBorder.Rounded)
.BorderStyle(Theme.DimStyle)
.AddColumn(new TableColumn($"[{Theme.Amber}]Time[/]").Width(12))
.AddColumn(new TableColumn($"[{Theme.Amber}]Type[/]").Width(26))
.AddColumn(new TableColumn($"[{Theme.Amber}]Message[/]"))
.AddColumn(new TableColumn($"[{Theme.Amber}]Status[/]").Width(10));
foreach (var evt in events.TakeLast(120))
{
var status = evt.Success switch
{
true => Theme.Ok("ok"),
false => Theme.Fail("fail"),
null => Theme.Faint("-"),
};
var message = evt.Message;
if (!string.IsNullOrWhiteSpace(evt.Tool))
message += $" [{evt.Tool}]";
if (evt.ExitCode is not null)
message += $" (exit {evt.ExitCode})";
table.AddRow(
Theme.Faint(evt.OccurredAt.ToString("HH:mm:ss")),
Theme.G(evt.Type.ToString()),
Theme.Faint(message),
status);
}
AnsiConsole.Write(table);
AnsiConsole.MarkupLine("\n" + Theme.Faint("Press any key to return..."));
Console.ReadKey(intercept: true);
}
private void RenderHeader(string section)
{
AnsiConsole.Write(new FigletText("SDT").Color(Theme.GreenColor));
AnsiConsole.Write(
new Rule($"[bold {Theme.GreenBold}]{Markup.Escape(_projectName)}[/] [{Theme.GreenDim}]v{Markup.Escape(_version)}[/] [{Theme.Amber}]{Markup.Escape(section)}[/]")
.RuleStyle(Theme.DimStyle));
AnsiConsole.MarkupLine(Theme.Faint($"root: {_projectRoot}") + "\n");
}
}

44
Journal.DevTool/Tui/ToolchainScreen.cs
View File

@ -1,4 +1,5 @@
using Sdt.Config;
using Sdt.Core;
using Sdt.Runner;
using Sdt.Tui;
using Spectre.Console;
@ -178,7 +179,7 @@ public sealed class ToolchainScreen(DevToolConfig config, string projectRoot)
// Upgrade pip first
AnsiConsole.MarkupLine(Theme.Faint("Upgrading pip..."));
await RunLiveAsync(venvPy, ["-m", "pip", "install", "--upgrade", "pip"], _projectRoot);
await RunPipAsync(py, venvPy, ["install", "--upgrade", "pip"]);
// Build install args
var installArgs = new List<string> { "-m", "pip", "install" };
@ -193,7 +194,7 @@ public sealed class ToolchainScreen(DevToolConfig config, string projectRoot)
AnsiConsole.WriteLine();
AnsiConsole.MarkupLine(Theme.G($"Installing {profile.Label}..."));
AnsiConsole.WriteLine();
await RunLiveAsync(venvPy, installArgs, _projectRoot);
await RunPipAsync(py, venvPy, installArgs.Skip(2)); // strip leading "-m pip"
// Post-install commands
foreach (var cmd in profile.PostInstallCommands)
@ -211,10 +212,9 @@ public sealed class ToolchainScreen(DevToolConfig config, string projectRoot)
var venvPath = Path.GetFullPath(Path.Combine(_projectRoot, py.VenvDir));
var venvPy = GetVenvPython(venvPath);
var exe = File.Exists(venvPy) ? venvPy : ResolvePythonExe(py);
AnsiConsole.MarkupLine(Theme.G($"Upgrading pip using: {exe}"));
AnsiConsole.WriteLine();
await RunLiveAsync(exe, ["-m", "pip", "install", "--upgrade", "pip"], _projectRoot);
await RunPipAsync(py, exe, ["install", "--upgrade", "pip"]);
}
// ── Node ──────────────────────────────────────────────────────────────────
@ -278,7 +278,7 @@ public sealed class ToolchainScreen(DevToolConfig config, string projectRoot)
{
var psi = new System.Diagnostics.ProcessStartInfo
{
FileName = command,
FileName = CommandResolver.Resolve(command),
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
@ -310,4 +310,38 @@ public sealed class ToolchainScreen(DevToolConfig config, string projectRoot)
? Theme.Ok($"Done ({result.Elapsed.TotalSeconds:F1}s)")
: Theme.Fail($"Exited {result.ExitCode} ({result.Elapsed.TotalSeconds:F1}s)"));
}
private async Task RunPipAsync(PythonToolchain py, string pythonExe, IEnumerable<string> pipArgs)
{
if (!string.IsNullOrWhiteSpace(py.PipScript))
{
var pipScriptPath = ResolvePipScriptPath(py.PipScript);
if (File.Exists(pipScriptPath))
{
var ext = Path.GetExtension(pipScriptPath).ToLowerInvariant();
if (ext == ".py")
{
await RunLiveAsync(ResolvePythonExe(py), [pipScriptPath, .. pipArgs], _projectRoot);
return;
}
AnsiConsole.MarkupLine(Theme.Warn($"Ignoring non-Python pipScript: {pipScriptPath}"));
}
}
await RunLiveAsync(pythonExe, ["-m", "pip", .. pipArgs], _projectRoot);
}
private string ResolvePipScriptPath(string pipScriptConfigPath)
{
if (Path.IsPathRooted(pipScriptConfigPath))
return pipScriptConfigPath;
var fileName = Path.GetFileName(pipScriptConfigPath);
var bundled = ScriptLocator.FindHelperScript(_projectRoot, fileName);
if (bundled is not null)
return bundled;
return Path.GetFullPath(Path.Combine(_projectRoot, pipScriptConfigPath));
}
}

209
Journal.DevTool/Tui/WorkspaceScreen.cs
View File

@ -15,86 +15,159 @@ public sealed class WorkspaceScreen(WorkspaceConfig workspace, string workspaceR
/// </summary>
public string? SelectProject()
{
AnsiConsole.Clear();
AnsiConsole.Write(Theme.SectionRule("WORKSPACE — " + _workspace.Name));
AnsiConsole.WriteLine();
var projects = _workspace.Projects;
if (projects.Count == 0)
while (true)
{
AnsiConsole.MarkupLine(Theme.Warn("No projects defined in sdt-workspace.json."));
AnsiConsole.MarkupLine(Theme.Faint("Add entries to the \"projects\" array."));
AnsiConsole.MarkupLine("\n" + Theme.Faint("Press any key to go back..."));
Console.ReadKey(intercept: true);
return null;
AnsiConsole.Clear();
AnsiConsole.Write(Theme.SectionRule("WORKSPACE — " + _workspace.Name));
AnsiConsole.WriteLine();
var projects = _workspace.Projects;
if (projects.Count == 0)
{
AnsiConsole.MarkupLine(Theme.Warn("No projects defined in sdt-workspace.json."));
AnsiConsole.MarkupLine(Theme.Faint("Add entries to the \"projects\" array."));
if (AnsiConsole.Confirm($"[{Theme.Amber}]Add an external project now?[/]", defaultValue: true))
{
AddExternalProject();
continue;
}
AnsiConsole.MarkupLine("\n" + Theme.Faint("Press any key to go back..."));
Console.ReadKey(intercept: true);
return null;
}
// Build choice list with current project marked
var choices = new List<WorkspaceMenuItem>();
foreach (var proj in projects)
{
var absPath = WorkspaceLoader.ResolveProjectRoot(_workspaceRoot, proj);
var devtoolPath = Path.Combine(absPath, "devtool.json");
var isCurrent = string.Equals(absPath, _currentProjectRoot, StringComparison.OrdinalIgnoreCase);
var exists = File.Exists(devtoolPath);
var label = isCurrent
? $"[bold {Theme.GreenBold}]► {Markup.Escape(proj.Name)}[/] [{Theme.GreenDim}](current)[/]"
: $"[{Theme.Green}] {Markup.Escape(proj.Name)}[/]";
if (proj.Disabled)
label += $" [{Theme.Amber}](disabled)[/]";
var desc = !exists
? $" [{Theme.Red}]devtool.json not found[/]"
: string.IsNullOrWhiteSpace(proj.Description)
? $" [{Theme.GreenDim}]{Markup.Escape(absPath)}[/]"
: $" [{Theme.GreenDim}]{Markup.Escape(proj.Description)}[/]";
if (proj.Tags.Count > 0)
desc += $" [{Theme.GreenDim}]tags: {Markup.Escape(string.Join(",", proj.Tags))}[/]";
choices.Add(new WorkspaceMenuItem(label + "\n" + desc, absPath, exists && !isCurrent && !proj.Disabled));
}
choices.Add(new WorkspaceMenuItem($"[{Theme.Green}]＋ Add external project[/]", "__add__", true));
choices.Add(new WorkspaceMenuItem($"[{Theme.GreenDim}]← Cancel[/]", null, true));
// Show project table for overview
var table = new Table()
.Border(TableBorder.Rounded)
.BorderStyle(Theme.DimStyle)
.AddColumn(new TableColumn($"[{Theme.Amber}]Project[/]"))
.AddColumn(new TableColumn($"[{Theme.Amber}]Path[/]"))
.AddColumn(new TableColumn($"[{Theme.Amber}]Status[/]").Width(12));
foreach (var proj in projects)
{
var absPath = WorkspaceLoader.ResolveProjectRoot(_workspaceRoot, proj);
var isCurrent = string.Equals(absPath, _currentProjectRoot, StringComparison.OrdinalIgnoreCase);
var hasConfig = File.Exists(Path.Combine(absPath, "devtool.json"));
var status = proj.Disabled
? Theme.Warn("disabled")
: hasConfig ? Theme.Ok("ready") : Theme.Fail("no config");
table.AddRow(
isCurrent
? $"[bold {Theme.GreenBold}]► {Markup.Escape(proj.Name)}[/]"
: Theme.G(proj.Name),
Theme.Faint(proj.Path),
status);
}
AnsiConsole.Write(table);
AnsiConsole.WriteLine();
var switchable = choices.Where(c => c.Selectable).ToList();
if (switchable.Count == 1) // only Cancel
{
AnsiConsole.MarkupLine(Theme.Warn("No other projects available to switch to."));
AnsiConsole.MarkupLine("\n" + Theme.Faint("Press any key to go back..."));
Console.ReadKey(intercept: true);
return null;
}
var selected = AnsiConsole.Prompt(
new SelectionPrompt<WorkspaceMenuItem>()
.Title($"[{Theme.Green}]Switch to project:[/]")
.PageSize(15)
.UseConverter(m => m.Display)
.AddChoices(switchable));
if (selected.AbsPath == "__add__")
{
AddExternalProject();
continue;
}
return selected.AbsPath; // null = cancelled
}
}
private void AddExternalProject()
{
var raw = AnsiConsole.Ask<string>($"[{Theme.Amber}]Project root path[/]");
if (string.IsNullOrWhiteSpace(raw))
return;
var absolutePath = Path.GetFullPath(raw.Trim());
if (!Directory.Exists(absolutePath))
{
AnsiConsole.MarkupLine(Theme.Fail("Directory does not exist."));
Thread.Sleep(700);
return;
}
// Build choice list with current project marked
var choices = new List<WorkspaceMenuItem>();
foreach (var proj in projects)
var configPath = Path.Combine(absolutePath, "devtool.json");
if (!File.Exists(configPath))
{
var absPath = WorkspaceLoader.ResolveProjectRoot(_workspaceRoot, proj);
var devtoolPath = Path.Combine(absPath, "devtool.json");
var isCurrent = string.Equals(absPath, _currentProjectRoot, StringComparison.OrdinalIgnoreCase);
var exists = File.Exists(devtoolPath);
var create = AnsiConsole.Confirm(
$"[{Theme.Amber}]No devtool.json found. Create a minimal template?[/]",
defaultValue: true);
if (!create)
return;
var label = isCurrent
? $"[bold {Theme.GreenBold}]► {Markup.Escape(proj.Name)}[/] [{Theme.GreenDim}](current)[/]"
: $"[{Theme.Green}] {Markup.Escape(proj.Name)}[/]";
var desc = !exists
? $" [{Theme.Red}]devtool.json not found[/]"
: string.IsNullOrWhiteSpace(proj.Description)
? $" [{Theme.GreenDim}]{Markup.Escape(absPath)}[/]"
: $" [{Theme.GreenDim}]{Markup.Escape(proj.Description)}[/]";
choices.Add(new WorkspaceMenuItem(label + "\n" + desc, absPath, exists && !isCurrent));
File.WriteAllText(configPath, "{\n \"name\": \"SDT Project\",\n \"version\": \"0.1.0\",\n \"workflows\": []\n}\n");
}
choices.Add(new WorkspaceMenuItem($"[{Theme.GreenDim}]← Cancel[/]", null, true));
// Show project table for overview
var table = new Table()
.Border(TableBorder.Rounded)
.BorderStyle(Theme.DimStyle)
.AddColumn(new TableColumn($"[{Theme.Amber}]Project[/]"))
.AddColumn(new TableColumn($"[{Theme.Amber}]Path[/]"))
.AddColumn(new TableColumn($"[{Theme.Amber}]Status[/]").Width(12));
foreach (var proj in projects)
if (_workspace.Projects.Any(p =>
string.Equals(WorkspaceLoader.ResolveProjectRoot(_workspaceRoot, p), absolutePath, StringComparison.OrdinalIgnoreCase)))
{
var absPath = WorkspaceLoader.ResolveProjectRoot(_workspaceRoot, proj);
var isCurrent = string.Equals(absPath, _currentProjectRoot, StringComparison.OrdinalIgnoreCase);
var hasConfig = File.Exists(Path.Combine(absPath, "devtool.json"));
table.AddRow(
isCurrent
? $"[bold {Theme.GreenBold}]► {Markup.Escape(proj.Name)}[/]"
: Theme.G(proj.Name),
Theme.Faint(proj.Path),
hasConfig ? Theme.Ok("ready") : Theme.Fail("no config"));
AnsiConsole.MarkupLine(Theme.Warn("Project already exists in workspace."));
Thread.Sleep(700);
return;
}
AnsiConsole.Write(table);
AnsiConsole.WriteLine();
var switchable = choices.Where(c => c.Selectable).ToList();
if (switchable.Count == 1) // only Cancel
var relativePath = Path.GetRelativePath(_workspaceRoot, absolutePath);
var useRelative = !relativePath.StartsWith("..", StringComparison.OrdinalIgnoreCase) && !Path.IsPathRooted(relativePath);
var projectEntry = new WorkspaceProject
{
AnsiConsole.MarkupLine(Theme.Warn("No other projects available to switch to."));
AnsiConsole.MarkupLine("\n" + Theme.Faint("Press any key to go back..."));
Console.ReadKey(intercept: true);
return null;
}
Name = new DirectoryInfo(absolutePath).Name,
Description = $"External project at {absolutePath}",
Path = useRelative ? relativePath : absolutePath,
Disabled = false,
};
var selected = AnsiConsole.Prompt(
new SelectionPrompt<WorkspaceMenuItem>()
.Title($"[{Theme.Green}]Switch to project:[/]")
.PageSize(15)
.UseConverter(m => m.Display)
.AddChoices(switchable));
return selected.AbsPath; // null = cancelled
_workspace.Projects.Add(projectEntry);
WorkspaceLoader.Save(_workspaceRoot, _workspace);
AnsiConsole.MarkupLine(Theme.Ok("Project added to workspace."));
Thread.Sleep(700);
}
private sealed record WorkspaceMenuItem(string Display, string? AbsPath, bool Selectable);

31
Journal.DevTool/package-lock.json generated Normal file
View File

@ -0,0 +1,31 @@
{
"name": "DevTool-master",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"dependencies": {
"tauri-plugin-mic-recorder-api": "^2.0.0"
}
},
"node_modules/@tauri-apps/api": {
"version": "2.10.1",
"resolved": "https://registry.npmjs.org/@tauri-apps/api/-/api-2.10.1.tgz",
"integrity": "sha512-hKL/jWf293UDSUN09rR69hrToyIXBb8CjGaWC7gfinvnQrBVvnLr08FeFi38gxtugAVyVcTa5/FD/Xnkb1siBw==",
"license": "Apache-2.0 OR MIT",
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/tauri"
}
},
"node_modules/tauri-plugin-mic-recorder-api": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/tauri-plugin-mic-recorder-api/-/tauri-plugin-mic-recorder-api-2.0.0.tgz",
"integrity": "sha512-04wqYCX4WIlYd6KUY7aS3+W4B5RtnSoVczaQCBSXKpQkEx9XdaaBN05XCee2unxGva0btSXBItFqQSdosnS4jQ==",
"license": "MIT",
"dependencies": {
"@tauri-apps/api": ">=2.0.0-beta.6"
}
}
}
}

5
Journal.DevTool/package.json Normal file
View File

@ -0,0 +1,5 @@
{
"dependencies": {
"tauri-plugin-mic-recorder-api": "^2.0.0"
}
}

63
Journal.DevTool/scripts/README.md Normal file
View File

@ -0,0 +1,63 @@
# Scripts (Python-first, cross-platform)
This folder now uses Python as the default runtime for orchestration and diagnostics.
## Preferred scripts
- `diag.py`: tool probing and install-plan generation (`dotnet`, `python`, `node`, `npm`, `cargo`, `tauri`)
- `build.py`: normalized build actions used by SDT workflows
- `dev_shell.py`: cross-platform shell bootstrap export/doctor helper
- `dotnet-min.py`: resilient `dotnet` wrapper with local cache env
- `pip-min.py`: resilient `pip` wrapper with local cache env and repo-local target default
- `npm-clean.py`: remove `node_modules` cross-platform
- `migration-gate.py`: build/test quality gate
- `nuget-export-cache.py`: archive `.nuget` cache
- `nuget-import-cache.py`: restore `.nuget` cache from archive
- `publish-app.py`: build web or tauri app (cross-platform)
- `publish-sidecar.py`: publish sidecar .NET service
- `publish-webgateway.py`: publish gateway .NET service and optional web assets
- `run-webgateway.py`: run gateway in dev or published-output mode
- `publish-output.py`: orchestrate sidecar/web/gateway/desktop publish steps
- `sync-output.py`: sweep newest build artifacts into `output/`
- `script_common.py`: shared helpers (repo root resolution, env shaping, command runner)
- `project.rootHints` supports glob markers (for example `*.sln`) and directory/file markers (`.git`, `package.json`)
- Windows PATH token expansion (`%NVM_HOME%`, `%NVM_SYMLINK%`, etc.) is applied during command resolution
## Shell bootstrap wrappers
- `dev-shell.ps1`: PowerShell wrapper over `dev_shell.py`
- `dev-shell.sh`: bash/zsh wrapper over `dev_shell.py`
- `dev-shell.cmd`: cmd wrapper over `dev_shell.py`
## Legacy scripts
Existing `.ps1` entrypoints are now compatibility wrappers that forward to Python scripts.
`script-common.ps1` is legacy-only compatibility and not used by active SDT workflows.
Original PowerShell implementations are archived under `scripts/legacy/` as `*.legacy.ps1` for reference during transition.
## Root Hint Semantics
`project.rootHints` is evaluated in this order:
1. Exact marker exists at candidate root (file or directory)
2. Root-level glob match (`glob`)
3. Recursive glob match (`rglob`)
Examples:
- `"*.sln"`
- `".git"`
- `"package.json"`
- `"src-tauri/tauri.conf.json"`
## Quick usage
```powershell
python scripts/diag.py probe --tool dotnet --json
python scripts/dotnet-min.py build
python scripts/migration-gate.py
python scripts/nuget-export-cache.py --output-zip nuget-cache-export.zip
python scripts/nuget-import-cache.py --input-zip nuget-cache-export.zip
python scripts/npm-clean.py --working-dir .
python scripts/dev_shell.py export --shell pwsh --json
python scripts/dev_shell.py doctor
```

57
Journal.DevTool/scripts/WORKFLOWS.md Normal file
View File

@ -0,0 +1,57 @@
# Cross-Platform Script Workflows
## 1) Probe toolchain availability
```powershell
python scripts/diag.py probe --tool dotnet --json
python scripts/diag.py probe --tool python --json
python scripts/diag.py probe --tool node --json
python scripts/diag.py probe --tool npm --json
python scripts/diag.py probe --tool cargo --json
python scripts/diag.py probe --tool tauri --json
python scripts/diag.py probe --tool git --json
python scripts/diag.py probe --tool docker --json
```
## Shell bootstrap (cross-platform)
```powershell
python scripts/dev_shell.py export --shell pwsh --json
python scripts/dev_shell.py doctor
```
## 2) Build and run SDT
```powershell
python scripts/dotnet-min.py build
dotnet run --project DevTool.csproj
```
## 3) Run migration gate
```powershell
python scripts/migration-gate.py
```
## 4) Manage NuGet cache
```powershell
python scripts/nuget-export-cache.py --output-zip nuget-cache-export.zip
python scripts/nuget-import-cache.py --input-zip nuget-cache-export.zip
```
## 5) Clean Node modules
```powershell
python scripts/npm-clean.py --working-dir .
```
## 6) Build app/gateway bundles
```powershell
python scripts/publish-app.py --target web
python scripts/publish-sidecar.py --project path/to/sidecar.csproj
python scripts/publish-webgateway.py --project path/to/gateway.csproj --skip-web-assets
python scripts/publish-output.py --dry-run
python scripts/sync-output.py
```

39
Journal.DevTool/scripts/_pwsh-python-shim.ps1 Normal file
View File

@ -0,0 +1,39 @@
Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'
function Resolve-SdtPython {
$candidates = @('python')
if ($IsWindows) { $candidates += 'py' } else { $candidates += 'python3' }
foreach ($c in $candidates) {
try {
& $c --version *> $null
if ($LASTEXITCODE -eq 0) { return $c }
} catch {}
}
return 'python'
}
function Resolve-SdtScriptPath {
param([Parameter(Mandatory=$true)][string]$ScriptName)
$bundled = Join-Path $PSScriptRoot $ScriptName
if (Test-Path $bundled) { return $bundled }
$project = Join-Path (Join-Path $PSScriptRoot '..') ('scripts\\' + $ScriptName)
if (Test-Path $project) { return (Resolve-Path $project).Path }
throw "Python helper script not found: $ScriptName"
}
function Invoke-SdtPythonScript {
param(
[Parameter(Mandatory=$true)][string]$ScriptName,
[string[]]$ForwardArgs = @()
)
$python = Resolve-SdtPython
$scriptPath = Resolve-SdtScriptPath -ScriptName $ScriptName
& $python $scriptPath @ForwardArgs
exit $LASTEXITCODE
}

419
Journal.DevTool/scripts/build.py Normal file
View File

@ -0,0 +1,419 @@
#!/usr/bin/env python3
import argparse
import hashlib
import json
import os
import pathlib
import shutil
import subprocess
import sys
import time
from script_common import resolve_command
def run_step(command, args, cwd):
resolved = resolve_command(command)
if shutil.which(resolved) is None and not pathlib.Path(resolved).exists():
return {
"command": resolved,
"args": args,
"cwd": cwd,
"exit_code": 127,
"elapsed_seconds": 0.0,
"status": "failed",
"failure_reason": f"command_not_found:{resolved}",
}
started = time.time()
proc = subprocess.run([resolved, *args], cwd=cwd, check=False)
elapsed = round(time.time() - started, 3)
return {
"command": resolved,
"args": args,
"cwd": cwd,
"exit_code": proc.returncode,
"elapsed_seconds": elapsed,
"status": "ok" if proc.returncode == 0 else "failed",
"failure_reason": None if proc.returncode == 0 else f"non_zero_exit:{proc.returncode}",
}
def resolve_python_executable():
candidates = ["py", "python"] if os.name == "nt" else ["python3", "python"]
for c in candidates:
if shutil.which(c):
return c
return "python"
def parse_common(parser):
parser.add_argument("--project-root", required=True)
parser.add_argument("--working-dir", default=".")
parser.add_argument("--json", action="store_true")
def resolve_cwd(project_root, working_dir):
return os.path.abspath(os.path.join(project_root, working_dir))
EXCLUDED_SCAN_DIRS = {".git", "node_modules", "bin", "obj", ".venv", "venv", ".sdt", "dist", "build"}
def discover_dotnet_target(project_root: str, cwd: str):
# Prefer nearest/top-level solution from cwd, then csproj, then bounded scan from project root.
local_sln = sorted(pathlib.Path(cwd).glob("*.sln"))
if len(local_sln) == 1:
return str(local_sln[0])
local_csproj = sorted(pathlib.Path(cwd).glob("*.csproj"))
if len(local_csproj) == 1:
return str(local_csproj[0])
sln_hits = bounded_find_files(project_root, ".sln", max_depth=4)
if len(sln_hits) == 1:
return sln_hits[0]
csproj_hits = bounded_find_files(project_root, ".csproj", max_depth=4)
if len(csproj_hits) == 1:
return csproj_hits[0]
return None
def bounded_find_files(root: str, extension: str, max_depth: int):
root_path = pathlib.Path(root).resolve()
results = []
for current_root, dirs, files in os.walk(root_path):
rel = pathlib.Path(current_root).resolve().relative_to(root_path)
depth = len(rel.parts)
dirs[:] = [d for d in dirs if d not in EXCLUDED_SCAN_DIRS]
if depth > max_depth:
dirs[:] = []
continue
for name in files:
if name.lower().endswith(extension.lower()):
results.append(str(pathlib.Path(current_root) / name))
return sorted(results)
def run_dotnet_action(project_root, working_dir, verb):
cwd = resolve_cwd(project_root, working_dir)
args = [verb]
target = discover_dotnet_target(project_root, cwd)
if target:
args.append(target)
step = run_step("dotnet", args, cwd)
if target:
step["resolved_target"] = target
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def _deps_hash(app_root):
h = hashlib.sha256()
for name in ("package.json", "package-lock.json"):
p = pathlib.Path(app_root) / name
if p.exists():
h.update(p.read_bytes())
return h.hexdigest()
def ensure_npm_dependencies(app_root):
node_modules = pathlib.Path(app_root) / "node_modules"
deps_hash_file = node_modules / ".sdt-deps.sha256"
expected = _deps_hash(app_root)
should_install = not node_modules.exists()
if not should_install:
if not deps_hash_file.exists():
should_install = True
else:
current = deps_hash_file.read_text(encoding="utf-8").strip()
should_install = current != expected
if not should_install:
return {"installed": False, "reason": "deps_unchanged"}
lock_exists = (pathlib.Path(app_root) / "package-lock.json").exists()
install_args = ["ci", "--no-audit", "--fund=false"] if lock_exists else ["install", "--no-audit", "--fund=false"]
install_step = run_step("npm", install_args, app_root)
if install_step["exit_code"] != 0:
if lock_exists and install_args[0] == "ci":
fallback = run_step("npm", ["install", "--no-audit", "--fund=false"], app_root)
if fallback["exit_code"] != 0:
fallback["failure_reason"] = "deps_install_failed_after_ci_fallback"
return {"installed": True, "reason": "install_failed", "step": fallback}
install_step = fallback
else:
return {"installed": True, "reason": "install_failed", "step": install_step}
node_modules.mkdir(parents=True, exist_ok=True)
deps_hash_file.write_text(expected, encoding="utf-8")
return {"installed": True, "reason": "installed", "step": install_step}
def action_dotnet_build(args):
return run_dotnet_action(args.project_root, args.working_dir, "build")
def action_dotnet_restore(args):
return run_dotnet_action(args.project_root, args.working_dir, "restore")
def action_dotnet_test(args):
return run_dotnet_action(args.project_root, args.working_dir, "test")
def action_dotnet_publish(args):
return run_dotnet_action(args.project_root, args.working_dir, "publish")
def action_npm_install(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step("npm", ["install"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_npm_ci(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step("npm", ["ci"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_npm_build(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
deps = ensure_npm_dependencies(cwd)
if deps.get("reason") == "install_failed":
step = deps["step"]
step["failure_reason"] = "deps_install_failed"
return step["exit_code"], step
step = run_step("npm", ["run", "build"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_npm_test(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
deps = ensure_npm_dependencies(cwd)
if deps.get("reason") == "install_failed":
step = deps["step"]
step["failure_reason"] = "deps_install_failed"
return step["exit_code"], step
step = run_step("npm", ["test"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_npm_audit(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step("npm", ["audit"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_python_venv_create(args):
cwd = resolve_cwd(args.project_root, ".")
venv_dir = args.venv_dir or ".venv"
step = run_step(resolve_python_executable(), ["-m", "venv", venv_dir], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_python_pip_install(args):
cwd = resolve_cwd(args.project_root, ".")
req = args.requirements
step = run_step(resolve_python_executable(), ["-m", "pip", "install", "-r", req], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_python_pip_sync(args):
cwd = resolve_cwd(args.project_root, ".")
req = args.requirements
step = run_step(resolve_python_executable(), ["-m", "pip", "install", "-r", req], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_python_pytest(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step(resolve_python_executable(), ["-m", "pytest"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_cargo_build(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step("cargo", ["build"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_cargo_test(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step("cargo", ["test"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_tauri_build(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
deps = ensure_npm_dependencies(cwd)
if deps.get("reason") == "install_failed":
step = deps["step"]
step["failure_reason"] = "deps_install_failed"
return step["exit_code"], step
tauri_args = ["run", "tauri", "build"]
if args.no_bundle:
tauri_args.extend(["--", "--no-bundle"])
step = run_step("npm", tauri_args, cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_git_status(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step("git", ["status"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_git_fetch(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step("git", ["fetch"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_git_pull(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step("git", ["pull"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_git_clean(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step("git", ["clean", "-fd"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_docker_build(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step("docker", ["build", "."], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_docker_compose_up(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step("docker", ["compose", "up", "-d"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def action_docker_compose_down(args):
cwd = resolve_cwd(args.project_root, args.working_dir)
step = run_step("docker", ["compose", "down"], cwd)
return 0 if step["exit_code"] == 0 else step["exit_code"], step
def main():
parser = argparse.ArgumentParser(description="SDT normalized build actions")
sub = parser.add_subparsers(dest="action", required=True)
p0 = sub.add_parser("dotnet-restore")
parse_common(p0)
p1 = sub.add_parser("dotnet-build")
parse_common(p1)
p1b = sub.add_parser("dotnet-test")
parse_common(p1b)
p1c = sub.add_parser("dotnet-publish")
parse_common(p1c)
p2 = sub.add_parser("npm-install")
parse_common(p2)
p2b = sub.add_parser("npm-ci")
parse_common(p2b)
p3 = sub.add_parser("npm-build")
parse_common(p3)
p3b = sub.add_parser("npm-test")
parse_common(p3b)
p3c = sub.add_parser("npm-audit")
parse_common(p3c)
p4 = sub.add_parser("python-venv-create")
parse_common(p4)
p4.add_argument("--venv-dir", default=".venv")
p5 = sub.add_parser("python-pip-install")
parse_common(p5)
p5.add_argument("--requirements", required=True)
p5b = sub.add_parser("python-pip-sync")
parse_common(p5b)
p5b.add_argument("--requirements", required=True)
p5c = sub.add_parser("python-pytest")
parse_common(p5c)
p6 = sub.add_parser("cargo-build")
parse_common(p6)
p6b = sub.add_parser("cargo-test")
parse_common(p6b)
p7 = sub.add_parser("tauri-build")
parse_common(p7)
p7.add_argument("--no-bundle", action="store_true")
p8 = sub.add_parser("git-status")
parse_common(p8)
p9 = sub.add_parser("git-fetch")
parse_common(p9)
p10 = sub.add_parser("git-pull")
parse_common(p10)
p11 = sub.add_parser("git-clean")
parse_common(p11)
p12 = sub.add_parser("docker-build")
parse_common(p12)
p13 = sub.add_parser("docker-compose-up")
parse_common(p13)
p14 = sub.add_parser("docker-compose-down")
parse_common(p14)
args = parser.parse_args()
handlers = {
"dotnet-restore": action_dotnet_restore,
"dotnet-build": action_dotnet_build,
"dotnet-test": action_dotnet_test,
"dotnet-publish": action_dotnet_publish,
"npm-install": action_npm_install,
"npm-ci": action_npm_ci,
"npm-build": action_npm_build,
"npm-test": action_npm_test,
"npm-audit": action_npm_audit,
"python-venv-create": action_python_venv_create,
"python-pip-install": action_python_pip_install,
"python-pip-sync": action_python_pip_sync,
"python-pytest": action_python_pytest,
"cargo-build": action_cargo_build,
"cargo-test": action_cargo_test,
"tauri-build": action_tauri_build,
"git-status": action_git_status,
"git-fetch": action_git_fetch,
"git-pull": action_git_pull,
"git-clean": action_git_clean,
"docker-build": action_docker_build,
"docker-compose-up": action_docker_compose_up,
"docker-compose-down": action_docker_compose_down,
}
code, summary = handlers[args.action](args)
if args.json:
print(json.dumps(summary))
return code
if __name__ == "__main__":
sys.exit(main())

17
Journal.DevTool/scripts/dev-shell.cmd Normal file
View File

@ -0,0 +1,17 @@
@echo off
set "SCRIPT_DIR=%~dp0"
where py >nul 2>nul
if %ERRORLEVEL%==0 (
set "PYEXE=py"
) else (
where python >nul 2>nul
if not %ERRORLEVEL%==0 (
echo python not found.
exit /b 1
)
set "PYEXE=python"
)
for /f "usebackq delims=" %%L in (`"%PYEXE%" "%SCRIPT_DIR%dev_shell.py" export --shell cmd`) do %%L
echo Development shell initialized from Python bootstrap script.

21
Journal.DevTool/scripts/dev-shell.ps1 Normal file
View File

@ -0,0 +1,21 @@
# Run this in PowerShell before development commands:
# . ./scripts/dev-shell.ps1
Set-StrictMode -Version Latest
$ErrorActionPreference = "Stop"
. (Join-Path $PSScriptRoot '_pwsh-python-shim.ps1')
$scriptPath = Resolve-SdtScriptPath -ScriptName 'dev_shell.py'
$python = Resolve-SdtPython
$lines = & $python $scriptPath export --shell pwsh
if ($LASTEXITCODE -ne 0) {
throw "Failed to initialize development shell via dev_shell.py"
}
foreach ($line in $lines) {
Invoke-Expression $line
}
Write-Host "Development shell initialized from Python bootstrap script."

16
Journal.DevTool/scripts/dev-shell.sh Normal file
View File

@ -0,0 +1,16 @@
#!/usr/bin/env sh
set -eu
SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
if command -v python3 >/dev/null 2>&1; then
PYTHON_EXE="python3"
elif command -v python >/dev/null 2>&1; then
PYTHON_EXE="python"
else
echo "python3/python not found." >&2
exit 1
fi
eval "$("$PYTHON_EXE" "$SCRIPT_DIR/dev_shell.py" export --shell bash)"
echo "Development shell initialized from Python bootstrap script."

148
Journal.DevTool/scripts/dev_shell.py Normal file
View File

@ -0,0 +1,148 @@
#!/usr/bin/env python3
import argparse
import json
import pathlib
import sys
from script_common import PROXY_VARS, clean_proxy_env, dotnet_env, ensure_dirs, pip_env, resolve_repo_root
def huggingface_env(repo_root: pathlib.Path) -> dict[str, str]:
env = {}
hf_home = repo_root / ".cache" / "huggingface"
hf_hub_cache = hf_home / "hub"
ensure_dirs([hf_hub_cache])
env["HF_HOME"] = str(hf_home)
env["HUGGINGFACE_HUB_CACHE"] = str(hf_hub_cache)
env["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
return env
def resolved_env(repo_root: pathlib.Path) -> dict[str, str]:
env = {}
dotnet = dotnet_env(repo_root)
pip = pip_env(repo_root)
hf = huggingface_env(repo_root)
dotnet_keys = [
"DOTNET_CLI_HOME",
"NUGET_PACKAGES",
"NUGET_HTTP_CACHE_PATH",
"DOTNET_SKIP_FIRST_TIME_EXPERIENCE",
"DOTNET_ADD_GLOBAL_TOOLS_TO_PATH",
"DOTNET_GENERATE_ASPNET_CERTIFICATE",
"DOTNET_CLI_TELEMETRY_OPTOUT",
"NUGET_CERT_REVOCATION_MODE",
]
pip_keys = [
"PIP_CACHE_DIR",
"PIP_DISABLE_PIP_VERSION_CHECK",
"PIP_DEFAULT_TIMEOUT",
"PIP_RETRIES",
"TEMP",
"TMP",
]
for key in dotnet_keys:
env[key] = dotnet[key]
for key in pip_keys:
env[key] = pip[key]
env.update(hf)
clean_proxy_env(env)
return env
def export_lines(shell: str, env_map: dict[str, str]) -> list[str]:
def sh_quote(value: str) -> str:
return "'" + value.replace("'", "'\"'\"'") + "'"
if shell == "pwsh":
lines = [f"Remove-Item Env:{k} -ErrorAction SilentlyContinue" for k in PROXY_VARS]
lines.extend(f"$env:{k} = \"{v.replace('\"', '`\"')}\"" for k, v in env_map.items())
return lines
if shell in ("bash", "zsh"):
lines = [f"unset {k}" for k in PROXY_VARS]
lines.extend(f"export {k}={sh_quote(v)}" for k, v in env_map.items())
return lines
if shell == "cmd":
lines = [f"set {k}=" for k in PROXY_VARS]
lines.extend(f"set {k}={v}" for k, v in env_map.items())
return lines
raise ValueError(shell)
def cmd_export(args):
try:
repo_root = resolve_repo_root(args.project_root)
except Exception as ex:
print(f"Failed to resolve project root: {ex}", file=sys.stderr)
return 2
env_map = resolved_env(repo_root)
payload = {
"projectRoot": str(repo_root),
"env": env_map,
"createdDirs": [
str(repo_root / ".dotnet_home"),
str(repo_root / ".nuget" / "packages"),
str(repo_root / ".nuget" / "http-cache"),
str(repo_root / ".pip" / "cache"),
str(repo_root / ".tmp" / "pip-temp"),
str(repo_root / ".cache" / "huggingface" / "hub"),
],
"warnings": [],
}
try:
lines = export_lines(args.shell, env_map)
except ValueError:
print(f"Unsupported shell target: {args.shell}", file=sys.stderr)
return 3
if args.json:
print(json.dumps(payload))
else:
for line in lines:
print(line)
return 0
def cmd_doctor(args):
try:
repo_root = resolve_repo_root(args.project_root)
except Exception as ex:
print(f"Failed to resolve project root: {ex}", file=sys.stderr)
return 2
env_map = resolved_env(repo_root)
checks = {
"repo_root": str(repo_root),
"dotnet_home_exists": (repo_root / ".dotnet_home").exists(),
"nuget_cache_exists": (repo_root / ".nuget" / "packages").exists(),
"pip_cache_exists": (repo_root / ".pip" / "cache").exists(),
"hf_cache_exists": (repo_root / ".cache" / "huggingface" / "hub").exists(),
"env_count": len(env_map),
}
print(json.dumps(checks))
return 0
def main():
parser = argparse.ArgumentParser(description="SDT cross-platform shell bootstrap helper")
sub = parser.add_subparsers(dest="command", required=True)
p_export = sub.add_parser("export", help="Print env exports for a shell")
p_export.add_argument("--shell", required=True)
p_export.add_argument("--project-root")
p_export.add_argument("--json", action="store_true")
p_doctor = sub.add_parser("doctor", help="Validate env bootstrap paths")
p_doctor.add_argument("--project-root")
args = parser.parse_args()
if args.command == "export":
return cmd_export(args)
return cmd_doctor(args)
if __name__ == "__main__":
sys.exit(main())

128
Journal.DevTool/scripts/diag.py Normal file
View File

@ -0,0 +1,128 @@
#!/usr/bin/env python3
import argparse
import json
import os
import platform
import shutil
import subprocess
import sys
from script_common import resolve_command
def run_capture(cmd):
try:
proc = subprocess.run(cmd, capture_output=True, text=True, check=False)
out = (proc.stdout or "").strip()
err = (proc.stderr or "").strip()
text = out if out else err
return proc.returncode == 0, text
except Exception as ex:
return False, str(ex)
def probe_tool(tool):
mapping = {
"dotnet": ["dotnet", "--version"],
"node": ["node", "--version"],
"npm": ["npm", "--version"],
"python": ["python", "--version"],
"cargo": ["cargo", "--version"],
"tauri": ["tauri", "--version"],
"git": ["git", "--version"],
"docker": ["docker", "--version"],
}
cmd = mapping.get(tool, [tool, "--version"])
resolved = resolve_command(cmd[0])
if shutil.which(resolved) is None and not os.path.exists(resolved):
return {"tool": tool, "available": False, "version": None, "details": f"{cmd[0]} not found in PATH"}
cmd = [resolved, *cmd[1:]]
ok, text = run_capture(cmd)
return {"tool": tool, "available": ok, "version": text if ok else None, "details": None if ok else text}
def install_plan(tool):
is_windows = platform.system().lower().startswith("win")
if is_windows:
plans = {
"dotnet": [("winget", ["install", "Microsoft.DotNet.SDK.10"])],
"node": [("winget", ["install", "OpenJS.NodeJS.LTS"])],
"npm": [("winget", ["install", "OpenJS.NodeJS.LTS"])],
"python": [("winget", ["install", "Python.Python.3.12"])],
"cargo": [("winget", ["install", "Rustlang.Rustup"])],
"tauri": [("npm", ["install", "-g", "@tauri-apps/cli"])],
"git": [("winget", ["install", "Git.Git"])],
"docker": [("winget", ["install", "Docker.DockerDesktop"])],
}
else:
plans = {
"dotnet": [("sh", ["-c", "echo install dotnet sdk with your package manager"])],
"node": [("sh", ["-c", "echo install nodejs with your package manager"])],
"npm": [("sh", ["-c", "echo install npm with your package manager"])],
"python": [("sh", ["-c", "echo install python3 with your package manager"])],
"cargo": [("sh", ["-c", "curl https://sh.rustup.rs -sSf | sh"])],
"tauri": [("npm", ["install", "-g", "@tauri-apps/cli"])],
"git": [("sh", ["-c", "echo install git with your package manager"])],
"docker": [("sh", ["-c", "echo install docker with your package manager"])],
}
cmds = plans.get(tool, [])
return {
"tool": tool,
"supported": len(cmds) > 0,
"summary": f"Install plan for {tool} on {platform.system()}",
"commands": [{"command": c, "args": a} for c, a in cmds],
}
def run_install(tool):
plan = install_plan(tool)
if not plan["supported"]:
return 2
for cmd in plan["commands"]:
proc = subprocess.run([cmd["command"], *cmd["args"]], check=False)
if proc.returncode != 0:
return proc.returncode
return 0
def main():
parser = argparse.ArgumentParser(description="SDT diagnostics and install planner")
sub = parser.add_subparsers(dest="cmd", required=True)
p_probe = sub.add_parser("probe")
p_probe.add_argument("--tool", required=True)
p_probe.add_argument("--json", action="store_true")
p_plan = sub.add_parser("install-plan")
p_plan.add_argument("--tool", required=True)
p_plan.add_argument("--json", action="store_true")
p_run = sub.add_parser("install-run")
p_run.add_argument("--tool", required=True)
args = parser.parse_args()
if args.cmd == "probe":
result = probe_tool(args.tool.lower())
if args.json:
print(json.dumps(result))
else:
print(result)
return 0 if result["available"] else 1
if args.cmd == "install-plan":
result = install_plan(args.tool.lower())
if args.json:
print(json.dumps(result))
else:
print(result)
return 0 if result["supported"] else 2
if args.cmd == "install-run":
return run_install(args.tool.lower())
return 1
if __name__ == "__main__":
sys.exit(main())

34
Journal.DevTool/scripts/dotnet-min.py Normal file
View File

@ -0,0 +1,34 @@
#!/usr/bin/env python3
import argparse
import sys
from script_common import dotnet_env, resolve_repo_root, run
DOTNET_SAFE_CMDS = {"restore", "build", "run", "test", "publish", "pack"}
def main() -> int:
parser = argparse.ArgumentParser(description="Cross-platform minimal dotnet wrapper")
parser.add_argument("dotnet_args", nargs=argparse.REMAINDER)
parser.add_argument("--repo-root", default=None)
args = parser.parse_args()
if not args.dotnet_args:
print("Usage: python scripts/dotnet-min.py <dotnet args>", file=sys.stderr)
return 2
repo_root = resolve_repo_root(args.repo_root)
dotnet_args = list(args.dotnet_args)
cmd = dotnet_args[0].lower()
if cmd in DOTNET_SAFE_CMDS:
dotnet_args.extend(["-p:RestoreIgnoreFailedSources=true", "-p:NuGetAudit=false"])
if cmd == "restore":
dotnet_args.append("--ignore-failed-sources")
return run("dotnet", dotnet_args, repo_root, env=dotnet_env(repo_root))
if __name__ == "__main__":
raise SystemExit(main())

0
scripts/dotnet-min.ps1 → Journal.DevTool/scripts/legacy/dotnet-min.legacy.ps1
View File

0
scripts/migration-gate.ps1 → Journal.DevTool/scripts/legacy/migration-gate.legacy.ps1
View File

0
scripts/npm-clean.ps1 → Journal.DevTool/scripts/legacy/npm-clean.legacy.ps1
View File

0
scripts/nuget-export-cache.ps1 → Journal.DevTool/scripts/legacy/nuget-export-cache.legacy.ps1
View File

0
scripts/nuget-import-cache.ps1 → Journal.DevTool/scripts/legacy/nuget-import-cache.legacy.ps1
View File

0
scripts/pip-min.ps1 → Journal.DevTool/scripts/legacy/pip-min.legacy.ps1
View File

0
scripts/publish-app.ps1 → Journal.DevTool/scripts/legacy/publish-app.legacy.ps1
View File

0
scripts/publish-output.ps1 → Journal.DevTool/scripts/legacy/publish-output.legacy.ps1
View File

0
scripts/publish-sidecar.ps1 → Journal.DevTool/scripts/legacy/publish-sidecar.legacy.ps1
View File

0
scripts/publish-webgateway.ps1 → Journal.DevTool/scripts/legacy/publish-webgateway.legacy.ps1
View File

0
scripts/run-webgateway.ps1 → Journal.DevTool/scripts/legacy/run-webgateway.legacy.ps1
View File

0
scripts/sync-output.ps1 → Journal.DevTool/scripts/legacy/sync-output.legacy.ps1
View File

44
Journal.DevTool/scripts/migration-gate.py Normal file
View File

@ -0,0 +1,44 @@
#!/usr/bin/env python3
import argparse
import subprocess
import sys
from pathlib import Path
from script_common import resolve_repo_root
def run_step(repo_root: Path, title: str, command: list[str]) -> int:
print(f"\n== {title} ==")
print("$", " ".join(command))
proc = subprocess.run(command, cwd=str(repo_root), check=False)
return proc.returncode
def main() -> int:
parser = argparse.ArgumentParser(description="Cross-platform migration quality gate")
parser.add_argument("--repo-root", default=None)
parser.add_argument("--skip-tests", action="store_true")
parser.add_argument("--test-project", default=None, help="Optional test csproj path")
args = parser.parse_args()
repo_root = resolve_repo_root(args.repo_root)
code = run_step(repo_root, "Build", [sys.executable, "scripts/dotnet-min.py", "build"])
if code != 0:
return code
if not args.skip_tests:
if args.test_project:
test_cmd = [sys.executable, "scripts/dotnet-min.py", "test", args.test_project]
else:
test_cmd = [sys.executable, "scripts/dotnet-min.py", "test"]
code = run_step(repo_root, "Tests", test_cmd)
if code != 0:
return code
print("\nMigration gate passed.")
return 0
if __name__ == "__main__":
raise SystemExit(main())

35
Journal.DevTool/scripts/npm-clean.py Normal file
View File

@ -0,0 +1,35 @@
#!/usr/bin/env python3
import argparse
import shutil
from pathlib import Path
from script_common import resolve_repo_root
def main() -> int:
parser = argparse.ArgumentParser(description="Cross-platform node_modules cleanup")
parser.add_argument("--repo-root", default=None)
parser.add_argument("--working-dir", default=".")
parser.add_argument("--also-cache", action="store_true")
args = parser.parse_args()
repo_root = resolve_repo_root(args.repo_root)
work_dir = (repo_root / args.working_dir).resolve()
node_modules = work_dir / "node_modules"
if node_modules.exists():
shutil.rmtree(node_modules)
print(f"Removed: {node_modules}")
else:
print(f"Not found: {node_modules}")
if args.also_cache:
npm_cache = repo_root / ".npm" / "cache"
if npm_cache.exists():
shutil.rmtree(npm_cache)
print(f"Removed: {npm_cache}")
return 0
if __name__ == "__main__":
raise SystemExit(main())

42
Journal.DevTool/scripts/nuget-export-cache.py Normal file
View File

@ -0,0 +1,42 @@
#!/usr/bin/env python3
import argparse
import shutil
import tempfile
from pathlib import Path
from script_common import resolve_repo_root
def main() -> int:
parser = argparse.ArgumentParser(description="Export local NuGet cache to zip")
parser.add_argument("--repo-root", default=None)
parser.add_argument("--output-zip", default="nuget-cache-export.zip")
parser.add_argument("--include-dotnet-home", action="store_true")
args = parser.parse_args()
repo_root = resolve_repo_root(args.repo_root)
output_zip = (repo_root / args.output_zip).resolve()
nuget_dir = repo_root / ".nuget"
dotnet_home = repo_root / ".dotnet_home"
if not nuget_dir.exists():
print(f"NuGet cache not found: {nuget_dir}")
return 2
with tempfile.TemporaryDirectory() as td:
stage = Path(td) / "cache-export"
stage.mkdir(parents=True, exist_ok=True)
shutil.copytree(nuget_dir, stage / ".nuget")
if args.include_dotnet_home and dotnet_home.exists():
shutil.copytree(dotnet_home, stage / ".dotnet_home")
manifest = stage / "nuget-cache-manifest.txt"
manifest.write_text("exported_by=nuget-export-cache.py\n", encoding="utf-8")
archive_base = str(output_zip.with_suffix(""))
shutil.make_archive(archive_base, "zip", root_dir=str(stage))
print(f"Exported cache: {output_zip}")
return 0
if __name__ == "__main__":
raise SystemExit(main())

28
Journal.DevTool/scripts/nuget-import-cache.py Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env python3
import argparse
import shutil
from pathlib import Path
from script_common import resolve_repo_root
def main() -> int:
parser = argparse.ArgumentParser(description="Import NuGet cache from zip")
parser.add_argument("--repo-root", default=None)
parser.add_argument("--input-zip", default="nuget-cache-export.zip")
args = parser.parse_args()
repo_root = resolve_repo_root(args.repo_root)
input_zip = (repo_root / args.input_zip).resolve()
if not input_zip.exists():
print(f"Input zip not found: {input_zip}")
return 2
shutil.unpack_archive(str(input_zip), extract_dir=str(repo_root))
print(f"Imported cache from: {input_zip}")
print("Run `python scripts/dotnet-min.py restore` to validate restore in this repo.")
return 0
if __name__ == "__main__":
raise SystemExit(main())

35
Journal.DevTool/scripts/pip-min.py Normal file
View File

@ -0,0 +1,35 @@
#!/usr/bin/env python3
import argparse
import os
import sys
from script_common import pip_env, resolve_repo_root, run
def main() -> int:
parser = argparse.ArgumentParser(description="Cross-platform minimal pip wrapper")
parser.add_argument("pip_args", nargs=argparse.REMAINDER)
parser.add_argument("--repo-root", default=None)
args = parser.parse_args()
if not args.pip_args:
print("Usage: python scripts/pip-min.py <pip args>", file=sys.stderr)
return 2
repo_root = resolve_repo_root(args.repo_root)
pip_args = list(args.pip_args)
# Preserve legacy behavior: for bare install, default target to repo-local deps.
if pip_args and pip_args[0].lower() == "install":
has_target = any(a in ("--target", "--prefix") for a in pip_args)
if not has_target:
pip_args = [a for a in pip_args if a != "--user"]
target = repo_root / ".pydeps" / f"py{sys.version_info.major}{sys.version_info.minor}"
os.makedirs(target, exist_ok=True)
pip_args.extend(["--target", str(target)])
return run(sys.executable, ["-m", "pip", *pip_args], repo_root, env=pip_env(repo_root))
if __name__ == "__main__":
raise SystemExit(main())

46
Journal.DevTool/scripts/pip_safe.py Normal file
View File

@ -0,0 +1,46 @@
from __future__ import annotations
import os
import tempfile
from typing import Callable
def _mkdtemp_compat(
suffix: str | None = None,
prefix: str | None = None,
dir: str | None = None,
) -> str:
# Python 3.14 on some Windows hosts creates mkdtemp dirs that are
# immediately non-writable by the same process when mode=0o700 is used.
# pip relies heavily on tempfile; force 0o777 for compatibility.
if dir is None:
dir = tempfile.gettempdir()
if prefix is None:
prefix = tempfile.template
if suffix is None:
suffix = ""
names = tempfile._get_candidate_names()
for _ in range(tempfile.TMP_MAX):
name = next(names)
path = os.path.join(dir, f"{prefix}{name}{suffix}")
try:
os.mkdir(path, 0o777)
return path
except FileExistsError:
continue
raise FileExistsError("No usable temporary directory name found.")
def main(argv: list[str]) -> int:
tempfile.mkdtemp = _mkdtemp_compat # type: ignore[assignment]
from pip._internal.cli.main import main as pip_main
return int(pip_main(argv))
if __name__ == "__main__":
raise SystemExit(main(__import__("sys").argv[1:]))

91
Journal.DevTool/scripts/publish-app.py Normal file
View File

@ -0,0 +1,91 @@
#!/usr/bin/env python3
import argparse
from pathlib import Path
from script_common import find_node_app_root, resolve_repo_root, run, sha256_files
def main() -> int:
parser = argparse.ArgumentParser(description="Cross-platform web/tauri publish helper")
parser.add_argument("--target", choices=["web", "tauri"], default="web")
parser.add_argument("--configuration", choices=["Release", "Debug"], default="Release")
parser.add_argument("--tauri-bundles", choices=["none", "nsis", "msi"], default="none")
parser.add_argument("--install-deps", action="store_true")
parser.add_argument("--skip-install", action="store_true")
parser.add_argument("--dry-run", action="store_true")
parser.add_argument("--repo-root", default=None)
parser.add_argument("--app-root", default=None, help="Relative or absolute app root with package.json")
args = parser.parse_args()
repo_root = resolve_repo_root(args.repo_root)
app_root = find_node_app_root(repo_root, args.app_root)
if app_root is None:
print("Unable to locate app root (no unique package.json found).")
return 2
package_json = app_root / "package.json"
lock_file = app_root / "package-lock.json"
node_modules = app_root / "node_modules"
deps_hash_file = node_modules / ".sdt-deps.sha256"
expected_hash = sha256_files([package_json, lock_file])
should_install = args.install_deps or not node_modules.exists()
if not should_install and not args.skip_install:
if not deps_hash_file.exists():
should_install = True
else:
current = deps_hash_file.read_text(encoding="utf-8").strip()
should_install = current != expected_hash
if args.skip_install:
should_install = False
print(f"App root: {app_root}")
print(f"Target: {args.target} ({args.configuration})")
if should_install:
install_args = ["ci", "--no-audit", "--fund=false"] if lock_file.exists() else ["install", "--no-audit", "--fund=false"]
print("$ npm " + " ".join(install_args))
if not args.dry_run:
code = run("npm", install_args, app_root)
if code != 0:
if lock_file.exists() and install_args[0] == "ci":
print("npm ci failed (likely lockfile out of sync). Falling back to npm install...")
fallback_args = ["install", "--no-audit", "--fund=false"]
print("$ npm " + " ".join(fallback_args))
code = run("npm", fallback_args, app_root)
if code != 0:
return code
else:
return code
node_modules.mkdir(parents=True, exist_ok=True)
deps_hash_file.write_text(expected_hash, encoding="utf-8")
else:
print("Skipping dependency install.")
if args.target == "web":
cmd = ["run", "build"]
print("$ npm " + " ".join(cmd))
if not args.dry_run:
return run("npm", cmd, app_root)
return 0
tauri_cmd = ["run", "tauri", "build"]
tauri_tail: list[str] = []
if args.tauri_bundles == "none":
tauri_tail.extend(["--no-bundle"])
else:
tauri_tail.extend(["--bundles", args.tauri_bundles])
if args.configuration == "Debug":
tauri_tail.append("--debug")
if tauri_tail:
tauri_cmd.extend(["--", *tauri_tail])
print("$ npm " + " ".join(tauri_cmd))
if not args.dry_run:
return run("npm", tauri_cmd, app_root)
return 0
if __name__ == "__main__":
raise SystemExit(main())

90
Journal.DevTool/scripts/publish-output.py Normal file
View File

@ -0,0 +1,90 @@
#!/usr/bin/env python3
import argparse
import shutil
import subprocess
import sys
from pathlib import Path
from script_common import find_node_app_root, resolve_repo_root
def run_step(label: str, cmd: list[str], cwd: Path, dry_run: bool) -> int:
print(f"\n> {label}")
print("$", " ".join(cmd))
if dry_run:
return 0
proc = subprocess.run(cmd, cwd=str(cwd), check=False)
return proc.returncode
def main() -> int:
parser = argparse.ArgumentParser(description="Publish bundled outputs using Python script entrypoints")
parser.add_argument("--configuration", choices=["Release", "Debug"], default="Release")
parser.add_argument("--runtime", default="win-x64")
parser.add_argument("--skip-sidecar", action="store_true")
parser.add_argument("--skip-web", action="store_true")
parser.add_argument("--skip-webgateway", action="store_true")
parser.add_argument("--skip-tauri", action="store_true")
parser.add_argument("--dry-run", action="store_true")
parser.add_argument("--repo-root", default=None)
parser.add_argument("--sidecar-project", default=None)
parser.add_argument("--gateway-project", default=None)
parser.add_argument("--app-root", default=None)
parser.add_argument("--output-dir", default="output")
args = parser.parse_args()
repo_root = resolve_repo_root(args.repo_root)
output_root = (repo_root / args.output_dir).resolve()
output_root.mkdir(parents=True, exist_ok=True)
py = sys.executable
if not args.skip_sidecar:
cmd = [py, "scripts/publish-sidecar.py", "--configuration", args.configuration, "--runtime", args.runtime]
if args.sidecar_project:
cmd.extend(["--project", args.sidecar_project])
code = run_step("Publish sidecar", cmd, repo_root, args.dry_run)
if code != 0:
return code
if not args.skip_web:
cmd = [py, "scripts/publish-app.py", "--target", "web", "--configuration", args.configuration]
if args.app_root:
cmd.extend(["--app-root", args.app_root])
code = run_step("Build web", cmd, repo_root, args.dry_run)
if code != 0:
return code
if not args.skip_webgateway:
cmd = [py, "scripts/publish-webgateway.py", "--configuration", args.configuration, "--runtime", args.runtime]
if args.gateway_project:
cmd.extend(["--project", args.gateway_project])
code = run_step("Publish web gateway", cmd, repo_root, args.dry_run)
if code != 0:
return code
if not args.skip_tauri:
cmd = [py, "scripts/publish-app.py", "--target", "tauri", "--configuration", args.configuration, "--tauri-bundles", "none"]
if args.app_root:
cmd.extend(["--app-root", args.app_root])
code = run_step("Build tauri", cmd, repo_root, args.dry_run)
if code != 0:
return code
app_root = find_node_app_root(repo_root, args.app_root)
if app_root is not None:
target_dir = app_root / "src-tauri" / "target" / ("debug" if args.configuration == "Debug" else "release")
exes = sorted(target_dir.glob("*.exe"), key=lambda p: p.stat().st_mtime, reverse=True)
if exes:
staged = output_root / exes[0].name
if args.dry_run:
print(f"Would copy: {exes[0]} -> {staged}")
else:
shutil.copy2(exes[0], staged)
print(f"Staged desktop executable: {staged}")
print("\nPublish output workflow complete.")
return 0
if __name__ == "__main__":
raise SystemExit(main())

10
Journal.DevTool/scripts/publish-sidecar.ps1 Normal file
View File

@ -0,0 +1,10 @@
param(
[Parameter(ValueFromRemainingArguments = $($true))]
[string[]]$ForwardArgs
)
Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'
. (Join-Path $PSScriptRoot '_pwsh-python-shim.ps1')
Invoke-SdtPythonScript -ScriptName 'publish-sidecar.py' -ForwardArgs $ForwardArgs

58
Journal.DevTool/scripts/publish-sidecar.py Normal file
View File

@ -0,0 +1,58 @@
#!/usr/bin/env python3
import argparse
import os
from script_common import dotnet_env, find_csproj_by_keyword, resolve_repo_root, run
def main() -> int:
parser = argparse.ArgumentParser(description="Cross-platform .NET sidecar publish helper")
parser.add_argument("--configuration", default="Release")
parser.add_argument("--runtime", default="win-x64")
parser.add_argument("--repo-root", default=None)
parser.add_argument("--project", default=None, help="Relative/absolute path to sidecar csproj")
parser.add_argument("--output-dir", default="output")
args = parser.parse_args()
repo_root = resolve_repo_root(args.repo_root)
output_dir = (repo_root / args.output_dir).resolve()
output_dir.mkdir(parents=True, exist_ok=True)
if args.project:
csproj = (repo_root / args.project).resolve()
else:
csproj = find_csproj_by_keyword(repo_root, ["sidecar"])
if csproj is None or not csproj.exists():
print("Could not locate sidecar project. Pass --project <path/to/project.csproj>.")
return 2
publish_args = [
"publish",
str(csproj),
"-c",
args.configuration,
"-r",
args.runtime,
"--self-contained",
"-p:PublishSingleFile=true",
"-p:IncludeNativeLibrariesForSelfExtract=true",
"-p:RestoreIgnoreFailedSources=true",
"-p:NuGetAudit=false",
"-o",
str(output_dir),
]
code = run("dotnet", publish_args, repo_root, env=dotnet_env(repo_root))
if code != 0:
return code
binary_name = csproj.stem + (".exe" if args.runtime.startswith("win-") else "")
binary_path = output_dir / binary_name
if binary_path.exists():
print(f"Published executable: {binary_path}")
else:
print(f"Publish completed. Output directory: {output_dir}")
return 0
if __name__ == "__main__":
raise SystemExit(main())

78
Journal.DevTool/scripts/publish-webgateway.py Normal file
View File

@ -0,0 +1,78 @@
#!/usr/bin/env python3
import argparse
import shutil
from script_common import dotnet_env, find_csproj_by_keyword, resolve_repo_root, run
def main() -> int:
parser = argparse.ArgumentParser(description="Cross-platform ASP.NET gateway publish helper")
parser.add_argument("--configuration", choices=["Release", "Debug"], default="Release")
parser.add_argument("--runtime", default="win-x64")
parser.add_argument("--self-contained", action="store_true")
parser.add_argument("--skip-web-assets", action="store_true")
parser.add_argument("--repo-root", default=None)
parser.add_argument("--project", default=None, help="Relative/absolute path to gateway csproj")
parser.add_argument("--web-build-dir", default=None, help="Relative path to web build assets root")
parser.add_argument("--output-dir", default="output/webgateway")
args = parser.parse_args()
repo_root = resolve_repo_root(args.repo_root)
output_dir = (repo_root / args.output_dir).resolve()
output_dir.mkdir(parents=True, exist_ok=True)
if args.project:
csproj = (repo_root / args.project).resolve()
else:
csproj = find_csproj_by_keyword(repo_root, ["webgateway", "gateway"])
if csproj is None or not csproj.exists():
print("Could not locate web gateway project. Pass --project <path/to/project.csproj>.")
return 2
publish_args = [
"publish",
str(csproj),
"-c",
args.configuration,
"-r",
args.runtime,
"--self-contained",
"true" if args.self_contained else "false",
"-p:RestoreIgnoreFailedSources=true",
"-p:NuGetAudit=false",
"-o",
str(output_dir),
]
code = run("dotnet", publish_args, repo_root, env=dotnet_env(repo_root))
if code != 0:
return code
if not args.skip_web_assets:
if args.web_build_dir:
web_build_dir = (repo_root / args.web_build_dir).resolve()
else:
web_build_dir = next((p.parent for p in repo_root.rglob("package.json") if (p.parent / "build").exists()), None)
if web_build_dir is not None:
web_build_dir = web_build_dir / "build"
if web_build_dir is None or not web_build_dir.exists():
print("Web assets not found. Skip with --skip-web-assets or pass --web-build-dir.")
else:
web_out = output_dir / "wwwroot"
web_out.mkdir(parents=True, exist_ok=True)
for item in web_build_dir.iterdir():
dst = web_out / item.name
if item.is_dir():
if dst.exists():
shutil.rmtree(dst)
shutil.copytree(item, dst)
else:
shutil.copy2(item, dst)
print(f"Copied web assets: {web_out}")
print(f"Publish completed: {output_dir}")
return 0
if __name__ == "__main__":
raise SystemExit(main())

60
Journal.DevTool/scripts/run-webgateway.py Normal file
View File

@ -0,0 +1,60 @@
#!/usr/bin/env python3
import argparse
import os
from pathlib import Path
from script_common import dotnet_env, find_csproj_by_keyword, resolve_repo_root, run
def main() -> int:
parser = argparse.ArgumentParser(description="Run gateway in dev or output mode")
parser.add_argument("--configuration", choices=["Release", "Debug"], default="Release")
parser.add_argument("--urls", default="http://0.0.0.0:5180")
parser.add_argument("--project-root", default=None, help="Runtime project root exposed via SDT_PROJECT_ROOT")
parser.add_argument("--mode", choices=["Dev", "Output"], default="Dev")
parser.add_argument("--repo-root", default=None)
parser.add_argument("--project", default=None, help="Gateway csproj path")
parser.add_argument("--output-exe", default=None, help="Published gateway executable path")
args = parser.parse_args()
repo_root = resolve_repo_root(args.repo_root)
effective_project_root = Path(args.project_root).resolve() if args.project_root else repo_root
if not effective_project_root.exists():
print(f"Project root does not exist: {effective_project_root}")
return 2
env = dotnet_env(repo_root)
env["SDT_PROJECT_ROOT"] = str(effective_project_root)
if args.mode == "Output":
exe_path = Path(args.output_exe).resolve() if args.output_exe else (repo_root / "output" / "webgateway" / ("webgateway.exe" if os.name == "nt" else "webgateway"))
if not exe_path.exists():
print(f"Output executable not found: {exe_path}")
return 2
return run(str(exe_path), ["--urls", args.urls], repo_root, env=env)
if args.project:
csproj = (repo_root / args.project).resolve()
else:
csproj = find_csproj_by_keyword(repo_root, ["webgateway", "gateway"])
if csproj is None or not csproj.exists():
print("Could not locate gateway project. Pass --project <path/to/project.csproj>.")
return 2
run_args = [
"run",
"--project",
str(csproj),
"-c",
args.configuration,
"--no-launch-profile",
"--urls",
args.urls,
"-p:RestoreIgnoreFailedSources=true",
"-p:NuGetAudit=false",
]
return run("dotnet", run_args, repo_root, env=env)
if __name__ == "__main__":
raise SystemExit(main())

124
Journal.DevTool/scripts/script-common.ps1 Normal file
View File

@ -0,0 +1,124 @@
Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'
# Legacy compatibility helper only.
# Active SDT workflows and shell bootstrap now use Python scripts.
function Clear-SdtProxyEnv {
Remove-Item Env:HTTP_PROXY -ErrorAction SilentlyContinue
Remove-Item Env:HTTPS_PROXY -ErrorAction SilentlyContinue
Remove-Item Env:ALL_PROXY -ErrorAction SilentlyContinue
Remove-Item Env:http_proxy -ErrorAction SilentlyContinue
Remove-Item Env:https_proxy -ErrorAction SilentlyContinue
Remove-Item Env:all_proxy -ErrorAction SilentlyContinue
Remove-Item Env:GIT_HTTP_PROXY -ErrorAction SilentlyContinue
Remove-Item Env:GIT_HTTPS_PROXY -ErrorAction SilentlyContinue
Remove-Item Env:PIP_NO_INDEX -ErrorAction SilentlyContinue
}
function Resolve-SdtRepoRoot {
param([string]$StartPath)
$candidateStarts = @()
if (-not [string]::IsNullOrWhiteSpace($StartPath)) {
$candidateStarts += $StartPath
}
$cwd = (Get-Location).Path
if (-not [string]::IsNullOrWhiteSpace($cwd) -and ($candidateStarts -notcontains $cwd)) {
$candidateStarts += $cwd
}
$override = $env:SDT_REPO_ROOT
if ([string]::IsNullOrWhiteSpace($override)) {
$override = $env:JOURNAL_REPO_ROOT # backward compatibility
}
if (-not [string]::IsNullOrWhiteSpace($override)) {
$overridePath = [System.IO.Path]::GetFullPath($override)
if (Test-Path (Join-Path $overridePath "devtool.json")) {
return $overridePath
}
}
foreach ($start in $candidateStarts) {
$cursor = [System.IO.Path]::GetFullPath($start)
while (-not [string]::IsNullOrWhiteSpace($cursor)) {
if (Test-Path (Join-Path $cursor "devtool.json")) {
return $cursor
}
$parent = [System.IO.Directory]::GetParent($cursor)
if ($null -eq $parent -or $parent.FullName -eq $cursor) {
break
}
$cursor = $parent.FullName
}
}
if (Get-Command git -ErrorAction SilentlyContinue) {
foreach ($start in $candidateStarts) {
try {
$gitRoot = & git -C $start rev-parse --show-toplevel 2>$null
if ($? -and -not [string]::IsNullOrWhiteSpace($gitRoot)) {
return [System.IO.Path]::GetFullPath($gitRoot.Trim())
}
}
catch {}
}
}
throw "Could not locate repository root. Ensure a devtool.json exists in the project root."
}
function Initialize-SdtDotnetEnv {
param([Parameter(Mandatory = $true)][string]$RepoRoot)
$dotnetCliHome = Join-Path $RepoRoot ".dotnet_home"
$nugetPackages = Join-Path $RepoRoot ".nuget\packages"
$nugetHttpCachePath = Join-Path $RepoRoot ".nuget\http-cache"
$env:DOTNET_CLI_HOME = $dotnetCliHome
$env:NUGET_PACKAGES = $nugetPackages
$env:NUGET_HTTP_CACHE_PATH = $nugetHttpCachePath
$env:DOTNET_SKIP_FIRST_TIME_EXPERIENCE = "1"
$env:DOTNET_ADD_GLOBAL_TOOLS_TO_PATH = "0"
$env:DOTNET_GENERATE_ASPNET_CERTIFICATE = "0"
$env:DOTNET_CLI_TELEMETRY_OPTOUT = "1"
$env:NUGET_CERT_REVOCATION_MODE = "offline"
New-Item -ItemType Directory -Force -Path $dotnetCliHome, $nugetPackages, $nugetHttpCachePath | Out-Null
}
function Initialize-SdtPipEnv {
param([Parameter(Mandatory = $true)][string]$RepoRoot)
$pipCacheDir = Join-Path $RepoRoot ".pip\cache"
$pipTempDir = Join-Path $RepoRoot ".tmp\pip-temp"
$env:PIP_CACHE_DIR = $pipCacheDir
$env:TEMP = $pipTempDir
$env:TMP = $pipTempDir
$env:PIP_DISABLE_PIP_VERSION_CHECK = "1"
$env:PIP_DEFAULT_TIMEOUT = "30"
$env:PIP_RETRIES = "2"
New-Item -ItemType Directory -Force -Path $pipCacheDir, $pipTempDir | Out-Null
}
function Initialize-SdtHuggingFaceEnv {
param([Parameter(Mandatory = $true)][string]$RepoRoot)
$hfHome = Join-Path $RepoRoot ".cache\huggingface"
$hfHubCache = Join-Path $hfHome "hub"
$env:HF_HOME = $hfHome
$env:HUGGINGFACE_HUB_CACHE = $hfHubCache
$env:HF_HUB_DISABLE_SYMLINKS_WARNING = "1"
New-Item -ItemType Directory -Force -Path $hfHubCache | Out-Null
}
# Backward-compatible aliases (legacy script calls)
Set-Alias -Name Clear-JournalProxyEnv -Value Clear-SdtProxyEnv -Scope Script
Set-Alias -Name Resolve-JournalRepoRoot -Value Resolve-SdtRepoRoot -Scope Script
Set-Alias -Name Initialize-JournalDotnetEnv -Value Initialize-SdtDotnetEnv -Scope Script
Set-Alias -Name Initialize-JournalPipEnv -Value Initialize-SdtPipEnv -Scope Script
Set-Alias -Name Initialize-JournalHuggingFaceEnv -Value Initialize-SdtHuggingFaceEnv -Scope Script

315
Journal.DevTool/scripts/script_common.py Normal file
View File

@ -0,0 +1,315 @@
#!/usr/bin/env python3
import hashlib
import json
import os
import pathlib
import shutil
import subprocess
import sys
from typing import Dict, Iterable, List, Sequence
PROXY_VARS = [
"HTTP_PROXY",
"HTTPS_PROXY",
"ALL_PROXY",
"http_proxy",
"https_proxy",
"all_proxy",
"GIT_HTTP_PROXY",
"GIT_HTTPS_PROXY",
"PIP_NO_INDEX",
]
def resolve_repo_root(start: str | None = None) -> pathlib.Path:
base = pathlib.Path(start or os.getcwd()).resolve()
# Preferred marker for SDT-managed projects.
for cur in [base, *base.parents]:
cfg = cur / "devtool.json"
if cfg.exists():
hints = load_project_root_hints(cur)
if not hints:
return cur
if any(_hint_matches(cur, hint) for hint in hints):
return cur
# Fall back to git root when available.
try:
proc = subprocess.run(
["git", "-C", str(base), "rev-parse", "--show-toplevel"],
capture_output=True,
text=True,
check=False,
)
if proc.returncode == 0:
git_root = proc.stdout.strip()
if git_root:
return pathlib.Path(git_root).resolve()
except Exception:
pass
return base
def load_project_root_hints(repo_root: pathlib.Path) -> list[str]:
cfg = repo_root / "devtool.json"
if not cfg.exists():
return []
try:
data = json.loads(cfg.read_text(encoding="utf-8"))
hints = data.get("project", {}).get("rootHints", [])
return [str(x) for x in hints if isinstance(x, str) and x.strip()]
except Exception:
return []
def ensure_dirs(paths: List[pathlib.Path]) -> None:
for p in paths:
p.mkdir(parents=True, exist_ok=True)
def clean_proxy_env(env: Dict[str, str]) -> None:
for k in PROXY_VARS:
env.pop(k, None)
def dotnet_env(repo_root: pathlib.Path) -> Dict[str, str]:
env = dict(os.environ)
clean_proxy_env(env)
dotnet_cli_home = repo_root / ".dotnet_home"
nuget_packages = repo_root / ".nuget" / "packages"
nuget_http_cache = repo_root / ".nuget" / "http-cache"
ensure_dirs([dotnet_cli_home, nuget_packages, nuget_http_cache])
env["DOTNET_CLI_HOME"] = str(dotnet_cli_home)
env["NUGET_PACKAGES"] = str(nuget_packages)
env["NUGET_HTTP_CACHE_PATH"] = str(nuget_http_cache)
env["DOTNET_SKIP_FIRST_TIME_EXPERIENCE"] = "1"
env["DOTNET_ADD_GLOBAL_TOOLS_TO_PATH"] = "0"
env["DOTNET_GENERATE_ASPNET_CERTIFICATE"] = "0"
env["DOTNET_CLI_TELEMETRY_OPTOUT"] = "1"
env["NUGET_CERT_REVOCATION_MODE"] = "offline"
return env
def pip_env(repo_root: pathlib.Path) -> Dict[str, str]:
env = dict(os.environ)
clean_proxy_env(env)
pip_cache = repo_root / ".pip" / "cache"
pip_tmp = repo_root / ".tmp" / "pip-temp"
ensure_dirs([pip_cache, pip_tmp])
env["PIP_CACHE_DIR"] = str(pip_cache)
env["PIP_DISABLE_PIP_VERSION_CHECK"] = "1"
env["PIP_DEFAULT_TIMEOUT"] = "30"
env["PIP_RETRIES"] = "2"
env["TEMP"] = str(pip_tmp)
env["TMP"] = str(pip_tmp)
return env
def run(command: str, args: List[str], cwd: pathlib.Path, env: Dict[str, str] | None = None) -> int:
resolved = resolve_command(command)
try:
proc = subprocess.run([resolved, *args], cwd=str(cwd), env=env, check=False)
return proc.returncode
except FileNotFoundError:
print(f"Command not found: {resolved}", file=sys.stderr)
return 127
def run_capture(command: str, args: Sequence[str], cwd: pathlib.Path, env: Dict[str, str] | None = None) -> tuple[int, str, str]:
resolved = resolve_command(command)
try:
proc = subprocess.run(
[resolved, *args],
cwd=str(cwd),
env=env,
capture_output=True,
text=True,
check=False,
)
return proc.returncode, proc.stdout, proc.stderr
except FileNotFoundError:
return 127, "", f"Command not found: {resolved}"
def resolve_command(command: str) -> str:
if not command:
return command
if os.name != "nt":
return command
if any(sep in command for sep in ("\\", "/")):
return command
if pathlib.Path(command).suffix:
found = shutil.which(command)
return found or command
candidates = []
lowered = command.lower()
if lowered in ("npm", "npx", "pnpm", "yarn", "tauri"):
candidates.extend([f"{command}.cmd", f"{command}.exe", f"{command}.bat", command])
else:
candidates.append(command)
for c in candidates:
found = _which_windows(c)
if found:
name = pathlib.Path(found).name.lower()
if name in ("npm", "npx", "pnpm", "yarn", "tauri"):
shim = pathlib.Path(found).with_name(name + ".cmd")
if shim.exists():
return str(shim)
return found
if lowered in ("npm", "npx", "pnpm", "yarn"):
node = _which_windows("node.exe") or _which_windows("node")
if node:
node_dir = pathlib.Path(node).parent
shim = node_dir / f"{lowered}.cmd"
if shim.exists():
return str(shim)
return candidates[-1]
def _hint_matches(root: pathlib.Path, hint: str) -> bool:
h = hint.strip()
if not h:
return False
has_glob = any(ch in h for ch in ("*", "?", "["))
if has_glob:
# Match both anywhere in root and directly at root-level for common hints like "*.sln".
if any(root.glob(h)):
return True
return any(root.rglob(h))
marker = root / h
if marker.exists():
return True
# If hint is just a filename marker, look bounded in tree.
if not any(sep in h for sep in ("\\", "/")):
return any(p.name == h for p in root.rglob(h))
return False
def _expand_windows_path_segment(segment: str) -> str:
expanded = segment
# Expand %VAR% tokens repeatedly for nested references.
for _ in range(4):
next_value = os.path.expandvars(expanded)
if next_value == expanded:
break
expanded = next_value
return expanded
def _which_windows(command: str) -> str | None:
found = shutil.which(command)
if found:
return found
if os.name != "nt":
return None
path_value = os.environ.get("PATH", "")
pathext = os.environ.get("PATHEXT", ".COM;.EXE;.BAT;.CMD")
exts = [e.lower() for e in pathext.split(";") if e]
has_ext = pathlib.Path(command).suffix != ""
names = [command] if has_ext else [command, *(command + e.lower() for e in exts)]
for raw_segment in path_value.split(os.pathsep):
segment = _expand_windows_path_segment(raw_segment.strip())
if not segment:
continue
base = pathlib.Path(segment)
for name in names:
candidate = base / name
if candidate.exists():
return str(candidate)
return None
def sha256_files(paths: Iterable[pathlib.Path]) -> str:
h = hashlib.sha256()
for p in paths:
if not p.exists():
continue
h.update(p.read_bytes())
return h.hexdigest()
def first_existing(paths: Iterable[pathlib.Path]) -> pathlib.Path | None:
for p in paths:
if p.exists():
return p
return None
def find_csproj(repo_root: pathlib.Path, hints: Sequence[str] | None = None) -> pathlib.Path | None:
if hints:
for hint in hints:
candidate = (repo_root / hint).resolve()
if candidate.exists() and candidate.suffix.lower() == ".csproj":
return candidate
csprojs = sorted(repo_root.rglob("*.csproj"))
if not csprojs:
return None
if len(csprojs) == 1:
return csprojs[0]
return None
def find_csproj_by_keyword(repo_root: pathlib.Path, keywords: Sequence[str]) -> pathlib.Path | None:
kws = [k.lower() for k in keywords]
matches: list[pathlib.Path] = []
for p in repo_root.rglob("*.csproj"):
text = str(p).lower()
if any(k in text for k in kws):
matches.append(p)
if len(matches) == 1:
return matches[0]
return None
def find_node_app_root(repo_root: pathlib.Path, preferred: str | None = None) -> pathlib.Path | None:
if preferred:
p = (repo_root / preferred).resolve()
if (p / "package.json").exists():
return p
direct = repo_root / "package.json"
if direct.exists():
return repo_root
tauri_candidates = []
for package_json in repo_root.rglob("package.json"):
d = package_json.parent
if (d / "src-tauri" / "tauri.conf.json").exists():
tauri_candidates.append(d)
if len(tauri_candidates) == 1:
return tauri_candidates[0]
all_candidates = [p.parent for p in repo_root.rglob("package.json")]
if len(all_candidates) == 1:
return all_candidates[0]
return None
def newest_file(search_root: pathlib.Path, pattern: str) -> pathlib.Path | None:
if not search_root.exists():
return None
files = [p for p in search_root.rglob(pattern) if p.is_file() and "\\obj\\" not in str(p).replace("/", "\\")]
if not files:
return None
files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
return files[0]

82
Journal.DevTool/scripts/sync-output.py Normal file
View File

@ -0,0 +1,82 @@
#!/usr/bin/env python3
import argparse
import os
import shutil
from pathlib import Path
from script_common import newest_file, resolve_repo_root
def copy_tree_contents(src: Path, dst: Path) -> None:
dst.mkdir(parents=True, exist_ok=True)
for item in src.iterdir():
target = dst / item.name
if item.is_dir():
if target.exists():
shutil.rmtree(target)
shutil.copytree(item, target)
else:
shutil.copy2(item, target)
def main() -> int:
parser = argparse.ArgumentParser(description="Sync newest built assets into output folder")
parser.add_argument("--repo-root", default=None)
parser.add_argument("--output-dir", default="output")
parser.add_argument("--web-build-dir", default=None, help="Path to web build output")
parser.add_argument("--sidecar-bin-dir", default=None, help="Path to sidecar bin root")
parser.add_argument("--gateway-bin-dir", default=None, help="Path to gateway bin root")
parser.add_argument("--tauri-target-dir", default=None, help="Path to tauri target root")
args = parser.parse_args()
repo_root = resolve_repo_root(args.repo_root)
output_dir = (repo_root / args.output_dir).resolve()
output_dir.mkdir(parents=True, exist_ok=True)
web_build = (repo_root / args.web_build_dir).resolve() if args.web_build_dir else None
if web_build is None:
web_build = next((p for p in repo_root.rglob("build") if (p.parent / "package.json").exists()), None)
if web_build is not None and web_build.exists():
web_out = output_dir / "webgateway" / "wwwroot"
copy_tree_contents(web_build, web_out)
print(f"Synced web assets -> {web_out}")
sidecar_bin = (repo_root / args.sidecar_bin_dir).resolve() if args.sidecar_bin_dir else None
if sidecar_bin is None:
sidecar_proj = next((p.parent for p in repo_root.rglob("*.csproj") if "sidecar" in str(p).lower()), None)
sidecar_bin = sidecar_proj / "bin" if sidecar_proj else None
if sidecar_bin is not None:
sidecar_pattern = "*.exe" if os.name == "nt" else "*"
sidecar_exe = newest_file(sidecar_bin, sidecar_pattern)
if sidecar_exe is not None:
copy_tree_contents(sidecar_exe.parent, output_dir)
print(f"Synced sidecar -> {output_dir}")
gateway_bin = (repo_root / args.gateway_bin_dir).resolve() if args.gateway_bin_dir else None
if gateway_bin is None:
gateway_proj = next((p.parent for p in repo_root.rglob("*.csproj") if "gateway" in str(p).lower()), None)
gateway_bin = gateway_proj / "bin" if gateway_proj else None
if gateway_bin is not None:
gateway_pattern = "*.exe" if os.name == "nt" else "*"
gw_exe = newest_file(gateway_bin, gateway_pattern)
if gw_exe is not None:
gw_out = output_dir / "webgateway"
copy_tree_contents(gw_exe.parent, gw_out)
print(f"Synced gateway -> {gw_out}")
tauri_target = (repo_root / args.tauri_target_dir).resolve() if args.tauri_target_dir else None
if tauri_target is None:
tauri_target = next((p for p in repo_root.rglob("src-tauri") if (p / "target").exists()), None)
tauri_target = tauri_target / "target" if tauri_target else None
if tauri_target is not None:
app_exe = newest_file(tauri_target, "*.exe")
if app_exe is not None:
shutil.copy2(app_exe, output_dir / app_exe.name)
print(f"Synced desktop app ({app_exe.name}) -> {output_dir}")
print("Sync complete.")
return 0
if __name__ == "__main__":
raise SystemExit(main())

31
Journal.DevTool/tests/DevTool.Tests/ActionRunnerLegacyPwshTests.cs Normal file
View File

@ -0,0 +1,31 @@
using Sdt.Config;
using Sdt.Core;
using Xunit;
namespace DevTool.Tests;
public sealed class ActionRunnerLegacyPwshTests
{
[Fact]
public async Task LegacyPwshTarget_ReroutesToPythonScript_WhenPs1Missing()
{
var root = Path.Combine(Path.GetTempPath(), "sdt-actionrunner-" + Guid.NewGuid().ToString("N"));
var scripts = Path.Combine(root, "scripts");
Directory.CreateDirectory(scripts);
File.WriteAllText(Path.Combine(scripts, "publish-app.py"), "print('rerouted')");
var step = new WorkflowStep
{
Id = "legacy",
Label = "legacy",
Command = "pwsh",
Args = ["-NoProfile", "-File", "scripts/publish-app.ps1", "-Target", "web"],
WorkingDir = "."
};
var runner = new ActionRunner();
var run = await runner.RunStepAsync(step, root, (_, _) => { });
Assert.True(run.Success);
}
}

124
Journal.DevTool/tests/DevTool.Tests/CommandResolverTests.cs Normal file
View File

@ -0,0 +1,124 @@
using Sdt.Core;
using Sdt.Config;
using Xunit;
namespace DevTool.Tests;
public sealed class CommandResolverTests
{
[Fact]
public void Resolve_Npm_OnWindows_UsesCmdShim()
{
var resolved = CommandResolver.Resolve("npm");
if (OperatingSystem.IsWindows())
Assert.True(
resolved.EndsWith("npm.cmd", StringComparison.OrdinalIgnoreCase) ||
resolved.EndsWith("\\npm", StringComparison.OrdinalIgnoreCase) ||
string.Equals(resolved, "npm.cmd", StringComparison.OrdinalIgnoreCase),
$"Resolved npm path was '{resolved}'");
else
Assert.Equal("npm", resolved);
}
[Fact]
public void Resolve_PathOrExtension_Unchanged()
{
Assert.Equal("C:\\tools\\npm.cmd", CommandResolver.Resolve("C:\\tools\\npm.cmd"));
var resolved = CommandResolver.Resolve("dotnet.exe");
if (OperatingSystem.IsWindows() && Path.IsPathRooted(resolved))
Assert.EndsWith("dotnet.exe", resolved, StringComparison.OrdinalIgnoreCase);
else
Assert.Equal("dotnet.exe", resolved);
}
[Fact]
public void Resolve_Npm_PrefersCmdShim_WhenBothBareAndCmdExist()
{
if (!OperatingSystem.IsWindows())
return;
var temp = Path.Combine(Path.GetTempPath(), "sdt-cmdresolve-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(temp);
File.WriteAllText(Path.Combine(temp, "npm"), "");
File.WriteAllText(Path.Combine(temp, "npm.cmd"), "@echo off");
var originalPath = Environment.GetEnvironmentVariable("PATH");
try
{
Environment.SetEnvironmentVariable("PATH", temp);
var resolved = CommandResolver.Resolve("npm");
Assert.EndsWith("npm.cmd", resolved, StringComparison.OrdinalIgnoreCase);
}
finally
{
Environment.SetEnvironmentVariable("PATH", originalPath);
try { Directory.Delete(temp, recursive: true); } catch { }
}
}
[Fact]
public void ResolveWithTrace_ConfiguredOverride_IsUsed()
{
if (!OperatingSystem.IsWindows())
return;
var temp = Path.Combine(Path.GetTempPath(), "sdt-cmdresolve-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(temp);
var overridePath = Path.Combine(temp, "npm.cmd");
File.WriteAllText(overridePath, "@echo off");
var cfg = new DevToolConfig
{
Tooling = new ToolingConfig
{
Tools =
[
new ToolInstallDefinition
{
Tool = "npm",
Executables = [overridePath]
}
]
}
};
var resolved = CommandResolver.ResolveWithTrace("npm", cfg, "npm");
Assert.Equal(CommandResolutionSource.ConfiguredOverride, resolved.Source);
Assert.EndsWith("npm.cmd", resolved.Resolved, StringComparison.OrdinalIgnoreCase);
}
[Fact]
public void ResolveWithTrace_ExpandsWindowsPathTokens()
{
if (!OperatingSystem.IsWindows())
return;
var nvmHome = Path.Combine(Path.GetTempPath(), "sdt-nvmhome-" + Guid.NewGuid().ToString("N"));
var nvmLink = Path.Combine(Path.GetTempPath(), "sdt-nvmlink-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(nvmHome);
Directory.CreateDirectory(nvmLink);
File.WriteAllText(Path.Combine(nvmLink, "npm.cmd"), "@echo off");
var originalPath = Environment.GetEnvironmentVariable("PATH");
var originalHome = Environment.GetEnvironmentVariable("NVM_HOME");
var originalLink = Environment.GetEnvironmentVariable("NVM_SYMLINK");
try
{
Environment.SetEnvironmentVariable("NVM_HOME", nvmHome);
Environment.SetEnvironmentVariable("NVM_SYMLINK", nvmLink);
Environment.SetEnvironmentVariable("PATH", "%NVM_HOME%;%NVM_SYMLINK%");
var result = CommandResolver.ResolveWithTrace("npm");
Assert.True(result.Source is CommandResolutionSource.Shim or CommandResolutionSource.Path);
Assert.EndsWith("npm.cmd", result.Resolved, StringComparison.OrdinalIgnoreCase);
}
finally
{
Environment.SetEnvironmentVariable("PATH", originalPath);
Environment.SetEnvironmentVariable("NVM_HOME", originalHome);
Environment.SetEnvironmentVariable("NVM_SYMLINK", originalLink);
try { Directory.Delete(nvmHome, recursive: true); } catch { }
try { Directory.Delete(nvmLink, recursive: true); } catch { }
}
}
}

108
Journal.DevTool/tests/DevTool.Tests/ConfigBootstrapperTests.cs Normal file
View File

@ -0,0 +1,108 @@
using Sdt.Config;
using Xunit;
namespace DevTool.Tests;
public sealed class ConfigBootstrapperTests
{
[Fact]
public void Scan_DetectsDotnetAndNode()
{
var root = CreateTempDir();
File.WriteAllText(Path.Combine(root, "sample.sln"), "");
File.WriteAllText(Path.Combine(root, "package.json"), "{}");
var scan = ConfigBootstrapper.Scan(root);
Assert.Contains("dotnet", scan.ToolFamilies, StringComparer.OrdinalIgnoreCase);
Assert.Contains("node", scan.ToolFamilies, StringComparer.OrdinalIgnoreCase);
Assert.Contains("npm", scan.ToolFamilies, StringComparer.OrdinalIgnoreCase);
}
[Fact]
public void Scan_DetectsPythonFromScriptsDirectory()
{
var root = CreateTempDir();
var scripts = Path.Combine(root, "scripts");
Directory.CreateDirectory(scripts);
File.WriteAllText(Path.Combine(scripts, "publish-app.py"), "print('ok')");
var scan = ConfigBootstrapper.Scan(root);
Assert.Contains("python", scan.ToolFamilies, StringComparer.OrdinalIgnoreCase);
}
[Fact]
public void BuildDefaultConfig_ProducesWorkflowsAndDebugSection()
{
var scan = new BootstrapScanResult(
ProjectRoot: Path.GetTempPath(),
ProjectName: "demo",
ToolFamilies: ["dotnet", "git"],
NodeWorkingDir: null,
PythonRequirementsFile: null,
HasDockerCompose: false,
RootHints: ["*.sln"]);
var cfg = ConfigBootstrapper.BuildDefaultConfig(scan);
Assert.NotNull(cfg.Debug);
Assert.Contains(cfg.Workflows, w => w.Id == "build");
Assert.Contains(cfg.Workflows, w => w.Id == "repo-health");
Assert.False(cfg.Debug!.Diagnostics.IncludeAllEnv);
Assert.Contains("SDT_LOG_LEVEL", cfg.Debug.Diagnostics.CaptureEnvKeys);
}
[Fact]
public void BuildDefaultConfig_IncludesScriptDrivenWorkflow_WhenHelpersExist()
{
var root = CreateTempDir();
var scripts = Path.Combine(root, "scripts");
Directory.CreateDirectory(scripts);
File.WriteAllText(Path.Combine(scripts, "publish-app.py"), "print('ok')");
File.WriteAllText(Path.Combine(scripts, "publish-sidecar.py"), "print('ok')");
var scan = ConfigBootstrapper.Scan(root);
var cfg = ConfigBootstrapper.BuildDefaultConfig(scan);
Assert.Contains(cfg.Workflows, w => w.Id == "web");
Assert.Contains(cfg.Workflows, w => w.Id == "sidecar");
}
[Fact]
public void WriteDefaultConfig_WritesDevtoolJson()
{
var root = CreateTempDir();
var scan = new BootstrapScanResult(
ProjectRoot: root,
ProjectName: "demo",
ToolFamilies: ["dotnet"],
NodeWorkingDir: null,
PythonRequirementsFile: null,
HasDockerCompose: false,
RootHints: ["*.sln"]);
var cfg = ConfigBootstrapper.BuildDefaultConfig(scan);
var path = ConfigBootstrapper.WriteDefaultConfig(root, cfg);
Assert.True(File.Exists(path));
}
[Fact]
public void Scan_IgnoresExcludedDirectories_ForToolDetection()
{
var root = CreateTempDir();
var nodeModules = Path.Combine(root, "node_modules", "nested");
Directory.CreateDirectory(nodeModules);
File.WriteAllText(Path.Combine(nodeModules, "package.json"), "{}");
var scan = ConfigBootstrapper.Scan(root);
Assert.DoesNotContain("node", scan.ToolFamilies, StringComparer.OrdinalIgnoreCase);
}
private static string CreateTempDir()
{
var path = Path.Combine(Path.GetTempPath(), "sdt-bootstrap-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(path);
return path;
}
}

54
Journal.DevTool/tests/DevTool.Tests/ConfigDoctorAutoFixServiceTests.cs Normal file
View File

@ -0,0 +1,54 @@
using Sdt.Config;
using Sdt.Core;
using Xunit;
namespace DevTool.Tests;
public sealed class ConfigDoctorAutoFixServiceTests
{
[Fact]
public void FindMissingWorkingDirectories_ReturnsMissingPaths()
{
var root = Path.Combine(Path.GetTempPath(), "sdt-autofix-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(root);
Directory.CreateDirectory(Path.Combine(root, "exists"));
var cfg = new DevToolConfig
{
Workflows =
[
new WorkflowDefinition
{
Id = "build",
Label = "Build",
Steps =
[
new WorkflowStep { Id = "s1", Label = "S1", Action = "dotnet-build", WorkingDir = "exists" },
new WorkflowStep { Id = "s2", Label = "S2", Action = "dotnet-build", WorkingDir = "missing/sub" }
]
}
]
};
var service = new ConfigDoctorAutoFixService();
var missing = service.FindMissingWorkingDirectories(cfg, root);
Assert.Single(missing);
Assert.EndsWith(Path.Combine("missing", "sub"), missing[0], StringComparison.OrdinalIgnoreCase);
}
[Fact]
public void CreateMissingWorkingDirectories_CreatesPaths()
{
var root = Path.Combine(Path.GetTempPath(), "sdt-autofix-" + Guid.NewGuid().ToString("N"));
var path = Path.Combine(root, "a", "b", "c");
Directory.CreateDirectory(root);
var service = new ConfigDoctorAutoFixService();
var result = service.CreateMissingWorkingDirectories([path]);
Assert.True(result.Success);
Assert.True(Directory.Exists(path));
Assert.Equal(1, result.CreatedDirectories);
}
}

80
Journal.DevTool/tests/DevTool.Tests/ConfigDoctorServiceTests.cs Normal file
View File

@ -0,0 +1,80 @@
using Sdt.Config;
using Sdt.Core;
using Xunit;
namespace DevTool.Tests;
public sealed class ConfigDoctorServiceTests
{
[Fact]
public async Task TargetsOnly_Config_IsFlaggedAsFail()
{
var config = new DevToolConfig
{
Targets =
[
new BuildTarget
{
Id = "build",
Label = "Build",
Command = "dotnet",
Args = ["build"]
}
],
Workflows = []
};
var doctor = new ConfigDoctorService(new AlwaysAvailableProbe(), new RequirementResolver());
var report = await doctor.RunAsync(config, Directory.GetCurrentDirectory());
Assert.Contains(report.Checks, c => c.Name == "Legacy schema" && c.Status == DoctorStatus.Fail);
}
[Fact]
public async Task MissingTool_IsReportedWithFix()
{
var config = new DevToolConfig
{
Workflows =
[
new WorkflowDefinition
{
Id = "build",
Label = "Build",
Steps =
[
new WorkflowStep { Id = "s1", Label = "Build", Command = "dotnet", Args = ["build"] }
]
}
]
};
var doctor = new ConfigDoctorService(new AlwaysMissingProbe(), new RequirementResolver());
var report = await doctor.RunAsync(config, Directory.GetCurrentDirectory());
Assert.Contains(report.Checks, c =>
c.Name.Equals("Tool: dotnet", StringComparison.OrdinalIgnoreCase) &&
c.Status == DoctorStatus.Fail &&
!string.IsNullOrWhiteSpace(c.Fix));
}
private sealed class AlwaysAvailableProbe : IToolProbe
{
public Task<ProbeResult> ProbeAsync(
string tool,
string projectRoot,
DevToolConfig? config = null,
CancellationToken cancellationToken = default)
=> Task.FromResult(new ProbeResult(tool, true, Version: "1.0.0"));
}
private sealed class AlwaysMissingProbe : IToolProbe
{
public Task<ProbeResult> ProbeAsync(
string tool,
string projectRoot,
DevToolConfig? config = null,
CancellationToken cancellationToken = default)
=> Task.FromResult(new ProbeResult(tool, false, Details: "Fallback: unresolved command"));
}
}

40
Journal.DevTool/tests/DevTool.Tests/DebugConfigTests.cs Normal file
View File

@ -0,0 +1,40 @@
using System.Text.Json;
using Sdt.Config;
using Xunit;
namespace DevTool.Tests;
public sealed class DebugConfigTests
{
[Fact]
public void DebugSectionAbsent_DeserializesWithSafeDefaults()
{
const string json = """
{
"name": "Test",
"version": "1.0.0",
"workflows": []
}
""";
var cfg = JsonSerializer.Deserialize<DevToolConfig>(json, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true,
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
AllowTrailingCommas = true,
ReadCommentHandling = JsonCommentHandling.Skip
});
Assert.NotNull(cfg);
Assert.Null(cfg!.Debug);
}
[Fact]
public void DebugDiagnostics_DefaultOutputDir_IsSdtDebug()
{
var options = new DebugDiagnosticsOptions();
Assert.True(options.Enabled);
Assert.True(options.BundleOnFailure);
Assert.Equal(".sdt/debug", options.OutputDir);
}
}

191
Journal.DevTool/tests/DevTool.Tests/DebugServicesTests.cs Normal file
View File

@ -0,0 +1,191 @@
using Sdt.Config;
using Sdt.Core;
using Sdt.Core.Debug;
using Sdt.Runner;
using System.Text.Json;
using Xunit;
namespace DevTool.Tests;
public sealed class DebugServicesTests
{
[Fact]
public async Task DebugRunner_MissingPrereqDeclined_ReturnsUserDeclined()
{
var runner = new DebugProfileRunner(
new FakeProbeService(false),
new FakeInstallerService(true));
var profile = new DebugProfileDefinition
{
Id = "p1",
Label = "Profile",
Type = "python",
Command = "python",
Args = ["--version"],
Requires = [new ToolRequirement { Tool = "python", InstallPolicy = InstallPolicy.Prompt }]
};
var result = await runner.RunAsync(
profile,
new DevToolConfig(),
Directory.GetCurrentDirectory(),
verbose: false,
confirmInstallAsync: (_, _) => Task.FromResult(false),
onOutput: (_, _) => { });
Assert.False(result.Success);
Assert.Equal(ExecutionStopReason.UserDeclined, result.StopReason);
}
[Fact]
public async Task DiagnosticsBundle_WritesFiles()
{
var service = new DiagnosticsBundleService();
var root = Path.Combine(Path.GetTempPath(), "sdt-diag-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(root);
var request = new DiagnosticsBundleRequest(
Category: "workflow",
ProjectRoot: root,
SummaryMessage: "failed",
OutputLines: ["hello"],
WorkflowSteps: [],
Probes: [],
DiagnosticsOptions: new DebugDiagnosticsOptions { OutputDir = ".sdt/debug" },
Config: new DevToolConfig(),
StopReason: ExecutionStopReason.CommandFailed);
var result = await service.WriteBundleAsync(request);
Assert.True(result.Success);
Assert.True(File.Exists(Path.Combine(result.BundleDirectory, "summary.json")));
Assert.True(File.Exists(Path.Combine(result.BundleDirectory, "output.log")));
}
[Fact]
public async Task DiagnosticsBundle_EmptyAllowlist_CapturesNoEnvByDefault()
{
var service = new DiagnosticsBundleService();
var root = Path.Combine(Path.GetTempPath(), "sdt-diag-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(root);
var request = new DiagnosticsBundleRequest(
Category: "workflow",
ProjectRoot: root,
SummaryMessage: "failed",
OutputLines: [],
WorkflowSteps: [],
Probes: [],
DiagnosticsOptions: new DebugDiagnosticsOptions
{
OutputDir = ".sdt/debug",
IncludeAllEnv = false,
CaptureEnvKeys = []
},
Config: new DevToolConfig(),
StopReason: ExecutionStopReason.CommandFailed);
var result = await service.WriteBundleAsync(request);
Assert.True(result.Success);
var envJson = await File.ReadAllTextAsync(Path.Combine(result.BundleDirectory, "env.json"));
using var doc = JsonDocument.Parse(envJson);
Assert.Empty(doc.RootElement.EnumerateObject());
}
[Fact]
public async Task DiagnosticsBundle_Allowlist_CapturesOnlyListedKeys()
{
var service = new DiagnosticsBundleService();
var root = Path.Combine(Path.GetTempPath(), "sdt-diag-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(root);
Environment.SetEnvironmentVariable("SDT_TEST_ENV_A", "A");
Environment.SetEnvironmentVariable("SDT_TEST_ENV_B", "B");
var request = new DiagnosticsBundleRequest(
Category: "workflow",
ProjectRoot: root,
SummaryMessage: "failed",
OutputLines: [],
WorkflowSteps: [],
Probes: [],
DiagnosticsOptions: new DebugDiagnosticsOptions
{
OutputDir = ".sdt/debug",
IncludeAllEnv = false,
CaptureEnvKeys = ["SDT_TEST_ENV_A"]
},
Config: new DevToolConfig(),
StopReason: ExecutionStopReason.CommandFailed);
var result = await service.WriteBundleAsync(request);
Assert.True(result.Success);
var envJson = await File.ReadAllTextAsync(Path.Combine(result.BundleDirectory, "env.json"));
using var doc = JsonDocument.Parse(envJson);
Assert.True(doc.RootElement.TryGetProperty("SDT_TEST_ENV_A", out _));
Assert.False(doc.RootElement.TryGetProperty("SDT_TEST_ENV_B", out _));
}
[Fact]
public async Task DebugRunner_EmitsRunEvents()
{
var runner = new DebugProfileRunner(
new FakeProbeService(true),
new FakeInstallerService(true));
var profile = new DebugProfileDefinition
{
Id = "p1",
Label = "Profile",
Type = "python",
Command = "python",
Args = ["--version"],
Requires = [new ToolRequirement { Tool = "python", InstallPolicy = InstallPolicy.Prompt }]
};
var events = new List<RunEvent>();
var result = await runner.RunAsync(
profile,
new DevToolConfig(),
Directory.GetCurrentDirectory(),
verbose: false,
confirmInstallAsync: (_, _) => Task.FromResult(false),
onOutput: (_, _) => { },
onEvent: events.Add);
Assert.True(result.Success);
Assert.Contains(events, e => e.Type == RunEventType.DebugStarted);
Assert.Contains(events, e => e.Type == RunEventType.DebugCommandStarted);
Assert.Contains(events, e => e.Type == RunEventType.DebugCommandCompleted);
Assert.Contains(events, e => e.Type == RunEventType.DebugCompleted && e.Success == true);
}
private sealed class FakeProbeService(bool isAvailable) : IToolProbe
{
public Task<ProbeResult> ProbeAsync(
string tool,
string projectRoot,
DevToolConfig? config = null,
CancellationToken cancellationToken = default)
=> Task.FromResult(new ProbeResult(tool, isAvailable, Version: isAvailable ? "1.0.0" : null));
}
private sealed class FakeInstallerService(bool success) : IPrereqInstaller
{
public Task<InstallPlan> GetInstallPlanAsync(
string tool,
string projectRoot,
DevToolConfig? config = null,
CancellationToken cancellationToken = default)
=> Task.FromResult(new InstallPlan(tool, Supported: true, "test", [new InstallCommand("echo", ["ok"])]));
public Task<RunResult> RunInstallAsync(
InstallCommand command,
string projectRoot,
Action<string, bool> onOutput,
CancellationToken cancellationToken = default)
=> Task.FromResult(new RunResult(success ? 0 : 1, TimeSpan.FromMilliseconds(5)));
}
}

120
Journal.DevTool/tests/DevTool.Tests/DevShellScriptTests.cs Normal file
View File

@ -0,0 +1,120 @@
using System.Diagnostics;
using System.Text.Json;
using Xunit;
namespace DevTool.Tests;
public sealed class DevShellScriptTests
{
[Theory]
[InlineData("pwsh")]
[InlineData("bash")]
[InlineData("zsh")]
[InlineData("cmd")]
public async Task DevShellExport_ReturnsSuccess_ForSupportedShells(string shell)
{
var python = ResolvePython();
var result = await RunAsync(
python,
["scripts/dev_shell.py", "export", "--shell", shell, "--json"]);
Assert.Equal(0, result.ExitCode);
using var doc = JsonDocument.Parse(result.StdOut);
Assert.True(doc.RootElement.TryGetProperty("projectRoot", out _));
Assert.True(doc.RootElement.TryGetProperty("env", out _));
}
[Fact]
public async Task DevShellExport_InvalidShell_ReturnsExitCode3()
{
var python = ResolvePython();
var result = await RunAsync(
python,
["scripts/dev_shell.py", "export", "--shell", "fish"]);
Assert.Equal(3, result.ExitCode);
}
[Fact]
public async Task DevShellDoctor_ReturnsJson()
{
var python = ResolvePython();
var result = await RunAsync(
python,
["scripts/dev_shell.py", "doctor"]);
Assert.Equal(0, result.ExitCode);
using var doc = JsonDocument.Parse(result.StdOut);
Assert.True(doc.RootElement.TryGetProperty("repo_root", out _));
}
private static string ResolvePython()
{
var candidates = OperatingSystem.IsWindows()
? new[] { "python", "py" }
: new[] { "python3", "python" };
foreach (var candidate in candidates)
{
try
{
using var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = candidate,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
}
};
process.StartInfo.ArgumentList.Add("--version");
process.Start();
process.WaitForExit(2000);
if (process.ExitCode == 0)
return candidate;
}
catch
{
}
}
throw new InvalidOperationException("Python executable not found.");
}
private static async Task<(int ExitCode, string StdOut, string StdErr)> RunAsync(string command, IReadOnlyList<string> args)
{
var psi = new ProcessStartInfo
{
FileName = command,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
WorkingDirectory = RepoRoot(),
};
foreach (var arg in args)
psi.ArgumentList.Add(arg);
using var process = new Process { StartInfo = psi };
process.Start();
var stdout = await process.StandardOutput.ReadToEndAsync();
var stderr = await process.StandardError.ReadToEndAsync();
await process.WaitForExitAsync();
return (process.ExitCode, stdout, stderr);
}
private static string RepoRoot()
{
var dir = new DirectoryInfo(AppContext.BaseDirectory);
while (dir is not null)
{
if (File.Exists(Path.Combine(dir.FullName, "devtool.json")))
return dir.FullName;
dir = dir.Parent;
}
throw new InvalidOperationException("Could not locate repo root.");
}
}

18
Journal.DevTool/tests/DevTool.Tests/DevTool.Tests.csproj Normal file
View File

@ -0,0 +1,18 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
<PackageReference Include="xunit" Version="2.9.2" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\DevTool.csproj" />
</ItemGroup>
</Project>

88
Journal.DevTool/tests/DevTool.Tests/LegacyModeTests.cs Normal file
View File

@ -0,0 +1,88 @@
using System.Text.Json;
using Sdt.Config;
using Xunit;
namespace DevTool.Tests;
public sealed class LegacyModeTests
{
[Fact]
public void ConfigLoader_StrictMode_TargetsOnly_FailsAndWritesPreview()
{
var root = CreateTempDir();
WriteLegacyTargetsOnlyConfig(root);
Environment.SetEnvironmentVariable("SDT_LEGACY_MODE", null);
var ex = Assert.Throws<InvalidOperationException>(() => ConfigLoader.FindAndLoad(root));
Assert.Contains("Strict mode requires workflows", ex.Message, StringComparison.OrdinalIgnoreCase);
Assert.True(File.Exists(Path.Combine(root, "devtool.generated.workflows.json")));
}
[Fact]
public void ConfigLoader_CompatMode_TargetsOnly_Loads()
{
var root = CreateTempDir();
WriteLegacyTargetsOnlyConfig(root);
Environment.SetEnvironmentVariable("SDT_LEGACY_MODE", "compat");
try
{
var loaded = ConfigLoader.FindAndLoad(root);
Assert.NotNull(loaded);
Assert.Contains(loaded!.Warnings, w => w.Contains("legacy 'targets'", StringComparison.OrdinalIgnoreCase));
}
finally
{
Environment.SetEnvironmentVariable("SDT_LEGACY_MODE", null);
}
}
[Fact]
public void ApplyLegacyTargetMigration_RewritesConfigAndCreatesBackup()
{
var root = CreateTempDir();
WriteLegacyTargetsOnlyConfig(root);
var path = Path.Combine(root, "devtool.json");
var result = ConfigLoader.ApplyLegacyTargetMigration(path, createBackup: true);
Assert.True(result.Success);
Assert.True(File.Exists(path));
Assert.False(string.IsNullOrWhiteSpace(result.BackupPath));
Assert.True(File.Exists(result.BackupPath!));
var loaded = ConfigLoader.FindAndLoad(root);
Assert.NotNull(loaded);
Assert.NotEmpty(loaded!.Config.Workflows);
Assert.Empty(loaded.Config.Targets);
}
private static void WriteLegacyTargetsOnlyConfig(string root)
{
var cfg = new DevToolConfig
{
Name = "legacy",
Version = "0.1.0",
Targets =
[
new BuildTarget
{
Id = "build",
Label = "Build",
Command = "dotnet",
Args = ["build"]
}
],
Workflows = []
};
var json = JsonSerializer.Serialize(cfg, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase, WriteIndented = true });
File.WriteAllText(Path.Combine(root, "devtool.json"), json);
}
private static string CreateTempDir()
{
var path = Path.Combine(Path.GetTempPath(), "sdt-legacy-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(path);
return path;
}
}

99
Journal.DevTool/tests/DevTool.Tests/PrereqInstallerServiceTests.cs Normal file
View File

@ -0,0 +1,99 @@
using Sdt.Config;
using Sdt.Core;
using Xunit;
namespace DevTool.Tests;
public sealed class PrereqInstallerServiceTests
{
[Fact]
public async Task PreferredInstallCommands_AreUsedFirst()
{
var svc = new PrereqInstallerService();
var cfg = new DevToolConfig
{
Tooling = new ToolingConfig
{
Tools =
[
new ToolInstallDefinition
{
Tool = "dotnet",
PreferredInstallCommands =
[
"echo install dotnet",
"dotnet --info"
]
}
]
}
};
var plan = await svc.GetInstallPlanAsync("dotnet", Directory.GetCurrentDirectory(), cfg);
Assert.True(plan.Supported);
Assert.Equal("dotnet", plan.Tool);
Assert.Equal(2, plan.Commands.Count);
Assert.Equal("echo", plan.Commands[0].Command);
Assert.Equal("dotnet", plan.Commands[1].Command);
}
[Fact]
public async Task DiagInstallPlanFailure_FallsBackToTemplatePlan()
{
var root = Path.Combine(Path.GetTempPath(), "sdt-prereq-" + Guid.NewGuid().ToString("N"));
var scripts = Path.Combine(root, "scripts");
Directory.CreateDirectory(scripts);
await File.WriteAllTextAsync(Path.Combine(scripts, "diag.py"), "import sys\nsys.exit(2)\n");
var svc = new PrereqInstallerService();
var plan = await svc.GetInstallPlanAsync("npm", root, new DevToolConfig());
Assert.True(plan.Supported);
Assert.NotEmpty(plan.Commands);
Assert.Contains("fallback", plan.Summary, StringComparison.OrdinalIgnoreCase);
}
[Fact]
public async Task DiagInstallPlanInvalidJson_FallsBackToTemplatePlan()
{
var root = Path.Combine(Path.GetTempPath(), "sdt-prereq-" + Guid.NewGuid().ToString("N"));
var scripts = Path.Combine(root, "scripts");
Directory.CreateDirectory(scripts);
await File.WriteAllTextAsync(Path.Combine(scripts, "diag.py"), "print('not-json')\n");
var svc = new PrereqInstallerService();
var plan = await svc.GetInstallPlanAsync("dotnet", root, new DevToolConfig());
Assert.True(plan.Supported);
Assert.NotEmpty(plan.Commands);
Assert.Contains("fallback", plan.Summary, StringComparison.OrdinalIgnoreCase);
}
[Fact]
public async Task TauriFallbackPlan_IsMultiStepAndClear()
{
var root = Path.Combine(Path.GetTempPath(), "sdt-prereq-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(root);
var svc = new PrereqInstallerService();
var plan = await svc.GetInstallPlanAsync("tauri", root, new DevToolConfig());
Assert.True(plan.Supported);
Assert.True(plan.Commands.Count >= 3);
Assert.Contains("tauri", plan.Summary, StringComparison.OrdinalIgnoreCase);
}
[Fact]
public async Task TauriFallbackPlan_IncludesRustAndCliCommands()
{
var root = Path.Combine(Path.GetTempPath(), "sdt-prereq-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(root);
var svc = new PrereqInstallerService();
var plan = await svc.GetInstallPlanAsync("tauri", root, new DevToolConfig());
Assert.Contains(plan.Commands, c => c.Args.Any(a => a.Contains("rustup", StringComparison.OrdinalIgnoreCase)));
Assert.Contains(plan.Commands, c => c.Args.Any(a => a.Contains("@tauri-apps/cli", StringComparison.OrdinalIgnoreCase)));
}
}

44
Journal.DevTool/tests/DevTool.Tests/RequirementResolverTests.cs Normal file
View File

@ -0,0 +1,44 @@
using Sdt.Config;
using Sdt.Core;
using Xunit;
namespace DevTool.Tests;
public sealed class RequirementResolverTests
{
private readonly RequirementResolver _resolver = new();
[Fact]
public void TauriBuildAction_RequiresNodeNpmCargo_NotGlobalTauri()
{
var step = new WorkflowStep
{
Id = "tauri",
Label = "tauri",
Action = "tauri-build",
};
var tools = _resolver.Resolve(step).Select(r => r.Tool).ToHashSet(StringComparer.OrdinalIgnoreCase);
Assert.Contains("node", tools);
Assert.Contains("npm", tools);
Assert.Contains("cargo", tools);
Assert.DoesNotContain("tauri", tools);
}
[Fact]
public void LegacyPwshTarget_InferenceMatchesExpected()
{
var target = new BuildTarget
{
Id = "web",
Label = "Web",
Command = "pwsh",
Args = ["-NoProfile", "-File", "scripts/publish-app.ps1", "-Target", "web"],
};
var tools = _resolver.Resolve(target).Select(r => r.Tool).ToHashSet(StringComparer.OrdinalIgnoreCase);
Assert.Contains("python", tools);
Assert.Contains("node", tools);
Assert.Contains("npm", tools);
}
}

31
Journal.DevTool/tests/DevTool.Tests/RunEventJsonlRecorderTests.cs Normal file
View File

@ -0,0 +1,31 @@
using System.Text.Json;
using Sdt.Core;
using Xunit;
namespace DevTool.Tests;
public sealed class RunEventJsonlRecorderTests
{
[Fact]
public void Recorder_WritesJsonlEvents()
{
var root = Path.Combine(Path.GetTempPath(), "sdt-events-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(root);
string path;
using (var recorder = RunEventJsonlRecorder.Create(root, "workflow"))
{
path = recorder.FilePath;
recorder.Write(new RunEvent("workflow", RunEventType.WorkflowStarted, "started", WorkflowId: "build"));
recorder.Write(new RunEvent("workflow", RunEventType.WorkflowCompleted, "done", WorkflowId: "build", Success: true));
}
Assert.True(File.Exists(path));
var lines = File.ReadAllLines(path);
Assert.Equal(2, lines.Length);
using var doc = JsonDocument.Parse(lines[0]);
Assert.Equal("workflow", doc.RootElement.GetProperty("category").GetString());
Assert.Equal("WorkflowStarted", doc.RootElement.GetProperty("type").GetString());
}
}

48
Journal.DevTool/tests/DevTool.Tests/RunEventLogReaderTests.cs Normal file
View File

@ -0,0 +1,48 @@
using Sdt.Core;
using Xunit;
namespace DevTool.Tests;
public sealed class RunEventLogReaderTests
{
[Fact]
public void ReadEvents_ParsesValidJsonlLines()
{
var root = Path.Combine(Path.GetTempPath(), "sdt-logreader-" + Guid.NewGuid().ToString("N"));
var dir = Path.Combine(root, ".sdt", "events");
Directory.CreateDirectory(dir);
var file = Path.Combine(dir, "workflow-test.jsonl");
File.WriteAllLines(file,
[
"""{"category":"workflow","type":"WorkflowStarted","message":"start","workflowId":"build","occurredAt":"2026-03-01T10:00:00Z"}""",
"""{"category":"workflow","type":"WorkflowCompleted","message":"done","workflowId":"build","success":true,"exitCode":0,"occurredAt":"2026-03-01T10:00:01Z"}"""
]);
var reader = new RunEventLogReader();
var events = reader.ReadEvents(file);
Assert.Equal(2, events.Count);
Assert.Equal(RunEventType.WorkflowStarted, events[0].Type);
Assert.Equal(RunEventType.WorkflowCompleted, events[1].Type);
Assert.True(events[1].Success);
}
[Fact]
public void ListEventFiles_ReturnsNewestFirst()
{
var root = Path.Combine(Path.GetTempPath(), "sdt-logreader-" + Guid.NewGuid().ToString("N"));
var dir = Path.Combine(root, ".sdt", "events");
Directory.CreateDirectory(dir);
var older = Path.Combine(dir, "older.jsonl");
var newer = Path.Combine(dir, "newer.jsonl");
File.WriteAllText(older, "{}");
Thread.Sleep(20);
File.WriteAllText(newer, "{}");
var reader = new RunEventLogReader();
var files = reader.ListEventFiles(root);
Assert.True(files.Count >= 2);
Assert.Equal("newer.jsonl", files[0].Name);
}
}

166
Journal.DevTool/tests/DevTool.Tests/ScriptCommonTests.cs Normal file
View File

@ -0,0 +1,166 @@
using System.Diagnostics;
using Xunit;
namespace DevTool.Tests;
public sealed class ScriptCommonTests
{
[Fact]
public async Task ResolveRepoRoot_UsesGlobRootHints()
{
var root = CreateTempDir("sdt-script-root-");
var nested = Path.Combine(root, "src", "app");
Directory.CreateDirectory(nested);
await File.WriteAllTextAsync(Path.Combine(root, "sample.sln"), "");
await File.WriteAllTextAsync(Path.Combine(root, "devtool.json"), """
{
"name": "demo",
"version": "0.1.0",
"workflows": [],
"project": {
"rootHints": ["*.sln"]
}
}
""");
var output = await RunPythonAsync(nested, "import script_common; print(script_common.resolve_repo_root(r'" + Escape(nested) + "'))");
Assert.Equal(Path.GetFullPath(root), output.Trim());
}
[Fact]
public async Task ResolveRepoRoot_UsesDirectoryMarkerHints()
{
var root = CreateTempDir("sdt-script-root-");
var nested = Path.Combine(root, "child", "leaf");
Directory.CreateDirectory(nested);
Directory.CreateDirectory(Path.Combine(root, ".git"));
await File.WriteAllTextAsync(Path.Combine(root, "devtool.json"), """
{
"name": "demo",
"version": "0.1.0",
"workflows": [],
"project": {
"rootHints": [".git", "package.json"]
}
}
""");
var output = await RunPythonAsync(nested, "import script_common; print(script_common.resolve_repo_root(r'" + Escape(nested) + "'))");
Assert.Equal(Path.GetFullPath(root), output.Trim());
}
[Fact]
public async Task ResolveCommand_ExpandsWindowsPathTokens()
{
if (!OperatingSystem.IsWindows())
return;
var root = CreateTempDir("sdt-script-cmd-");
var shimDir = Path.Combine(root, "nodejs");
Directory.CreateDirectory(shimDir);
await File.WriteAllTextAsync(Path.Combine(shimDir, "npm.cmd"), "@echo off");
var output = await RunPythonAsync(
root,
"import script_common; print(script_common.resolve_command('npm'))",
new Dictionary<string, string?>
{
["NVM_HOME"] = root,
["NVM_SYMLINK"] = shimDir,
["PATH"] = "%NVM_HOME%;%NVM_SYMLINK%",
});
Assert.EndsWith("npm.cmd", output.Trim(), StringComparison.OrdinalIgnoreCase);
}
private static async Task<string> RunPythonAsync(
string workingDir,
string script,
IReadOnlyDictionary<string, string?>? env = null)
{
var python = ResolvePython();
var psi = new ProcessStartInfo
{
FileName = python,
WorkingDirectory = workingDir,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
};
psi.ArgumentList.Add("-c");
psi.ArgumentList.Add($"import sys; sys.path.insert(0, r'{Escape(Path.Combine(ProjectRepoRoot(), "scripts"))}'); {script}");
if (env is not null)
{
foreach (var pair in env)
psi.Environment[pair.Key] = pair.Value ?? string.Empty;
}
using var process = new Process { StartInfo = psi };
process.Start();
var stdout = await process.StandardOutput.ReadToEndAsync();
var stderr = await process.StandardError.ReadToEndAsync();
await process.WaitForExitAsync();
if (process.ExitCode != 0)
throw new InvalidOperationException($"Python exited {process.ExitCode}: {stderr}");
return stdout;
}
private static string ResolvePython()
{
var candidates = OperatingSystem.IsWindows() ? new[] { "python", "py" } : new[] { "python3", "python" };
foreach (var candidate in candidates)
{
try
{
using var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = candidate,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
}
};
process.StartInfo.ArgumentList.Add("--version");
process.Start();
process.WaitForExit(2000);
if (process.ExitCode == 0)
return candidate;
}
catch
{
}
}
throw new InvalidOperationException("Python executable not found.");
}
private static string CreateTempDir(string prefix)
{
var path = Path.Combine(Path.GetTempPath(), prefix + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(path);
return path;
}
private static string Escape(string value) => value.Replace("\\", "\\\\").Replace("'", "\\'");
private static string ProjectRepoRoot()
{
var dir = new DirectoryInfo(AppContext.BaseDirectory);
while (dir is not null)
{
if (File.Exists(Path.Combine(dir.FullName, "devtool.json")) &&
File.Exists(Path.Combine(dir.FullName, "scripts", "script_common.py")))
{
return dir.FullName;
}
dir = dir.Parent;
}
throw new InvalidOperationException("Could not locate project repo root.");
}
}

179
Journal.DevTool/tests/DevTool.Tests/ScriptSmokeTests.cs Normal file
View File

@ -0,0 +1,179 @@
using System.Diagnostics;
using System.Text.Json;
using Xunit;
namespace DevTool.Tests;
public sealed class ScriptSmokeTests
{
[Fact]
public async Task DiagProbe_JsonContract_IsValid()
{
var python = ResolvePython();
var result = await RunAsync(
python,
["scripts/diag.py", "probe", "--tool", "python", "--json"]);
Assert.Equal(0, result.ExitCode);
using var doc = JsonDocument.Parse(result.StdOut);
Assert.True(doc.RootElement.TryGetProperty("tool", out _));
Assert.True(doc.RootElement.TryGetProperty("available", out _));
}
[Fact]
public async Task BuildAction_InvalidRequirements_PropagatesNonZeroAndJson()
{
var python = ResolvePython();
var missingReq = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".txt");
var result = await RunAsync(
python,
[
"scripts/build.py",
"python-pip-install",
"--project-root",
RepoRoot(),
"--requirements",
missingReq,
"--json"
]);
Assert.NotEqual(0, result.ExitCode);
var jsonText = ExtractLastJsonObject(result.StdOut);
using var doc = JsonDocument.Parse(jsonText);
Assert.True(doc.RootElement.TryGetProperty("exit_code", out var code));
Assert.NotEqual(0, code.GetInt32());
Assert.True(doc.RootElement.TryGetProperty("failure_reason", out _));
}
[Fact]
public async Task BuildAction_DotnetRestore_CommandNotFoundStillReturnsJson()
{
var python = ResolvePython();
var result = await RunAsync(
python,
[
"scripts/build.py",
"dotnet-restore",
"--project-root",
RepoRoot(),
"--json"
]);
var jsonText = ExtractLastJsonObject(result.StdOut);
using var doc = JsonDocument.Parse(jsonText);
Assert.True(doc.RootElement.TryGetProperty("exit_code", out _));
Assert.True(doc.RootElement.TryGetProperty("status", out _));
}
[Fact]
public async Task BuildAction_DotnetBuild_AutoSelectsSlnTarget_WhenSingleSlnFound()
{
var python = ResolvePython();
var tempRoot = Path.Combine(Path.GetTempPath(), "sdt-dotnet-target-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(tempRoot);
var sln = Path.Combine(tempRoot, "sample.sln");
await File.WriteAllTextAsync(sln, "Microsoft Visual Studio Solution File, Format Version 12.00");
var result = await RunAsync(
python,
[
"scripts/build.py",
"dotnet-build",
"--project-root",
tempRoot,
"--working-dir",
".",
"--json"
]);
var jsonText = ExtractLastJsonObject(result.StdOut);
using var doc = JsonDocument.Parse(jsonText);
Assert.True(doc.RootElement.TryGetProperty("args", out var args));
Assert.Contains(args.EnumerateArray().Select(x => x.GetString()), x => string.Equals(x, sln, StringComparison.OrdinalIgnoreCase));
}
private static string ResolvePython()
{
var candidates = OperatingSystem.IsWindows()
? new[] { "python", "py" }
: new[] { "python3", "python" };
foreach (var candidate in candidates)
{
try
{
using var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = candidate,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
}
};
process.StartInfo.ArgumentList.Add("--version");
process.Start();
process.WaitForExit(2000);
if (process.ExitCode == 0)
return candidate;
}
catch
{
}
}
throw new InvalidOperationException("Python executable not found for script smoke tests.");
}
private static async Task<(int ExitCode, string StdOut, string StdErr)> RunAsync(string command, IReadOnlyList<string> args)
{
var psi = new ProcessStartInfo
{
FileName = command,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true,
WorkingDirectory = RepoRoot(),
};
foreach (var arg in args)
psi.ArgumentList.Add(arg);
using var process = new Process { StartInfo = psi };
process.Start();
var stdout = await process.StandardOutput.ReadToEndAsync();
var stderr = await process.StandardError.ReadToEndAsync();
await process.WaitForExitAsync();
return (process.ExitCode, stdout, stderr);
}
private static string RepoRoot()
{
var dir = new DirectoryInfo(AppContext.BaseDirectory);
while (dir is not null)
{
if (File.Exists(Path.Combine(dir.FullName, "devtool.json")))
return dir.FullName;
dir = dir.Parent;
}
throw new InvalidOperationException("Could not locate repo root (devtool.json not found).");
}
private static string ExtractLastJsonObject(string text)
{
var lines = text.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
for (var i = lines.Length - 1; i >= 0; i--)
{
var line = lines[i];
if (line.StartsWith("{", StringComparison.Ordinal) && line.EndsWith("}", StringComparison.Ordinal))
return line;
}
throw new InvalidOperationException("No JSON object line found in script output.");
}
}

311
Journal.DevTool/tests/DevTool.Tests/WorkflowExecutorTests.cs Normal file
View File

@ -0,0 +1,311 @@
using Sdt.Config;
using Sdt.Core;
using Sdt.Runner;
using Xunit;
namespace DevTool.Tests;
public sealed class WorkflowExecutorTests
{
[Fact]
public async Task MissingPrereq_UserDeclines_ReturnsUserDeclined()
{
var executor = new WorkflowExecutor(
new WorkflowPlanner(),
new FakeProbeService(isAvailable: false),
new FakeInstallerService(success: true),
new FakeActionRunner(success: true),
new RequirementResolver());
var cfg = new DevToolConfig();
var wf = BuildSingleStepWorkflow("w", "dotnet");
var map = new Dictionary<string, WorkflowDefinition>(StringComparer.OrdinalIgnoreCase) { [wf.Id] = wf };
var result = await executor.ExecuteAsync(
wf, map, cfg, ".", (_, _) => Task.FromResult(false), (_, _) => { });
Assert.False(result.Success);
Assert.Equal(ExecutionStopReason.UserDeclined, result.StopReason);
}
[Fact]
public async Task MissingPrereq_InstallFails_ReturnsInstallFailed()
{
var executor = new WorkflowExecutor(
new WorkflowPlanner(),
new FakeProbeService(isAvailable: false),
new FakeInstallerService(success: false),
new FakeActionRunner(success: true),
new RequirementResolver());
var cfg = new DevToolConfig();
var wf = BuildSingleStepWorkflow("w", "dotnet");
var map = new Dictionary<string, WorkflowDefinition>(StringComparer.OrdinalIgnoreCase) { [wf.Id] = wf };
var result = await executor.ExecuteAsync(
wf, map, cfg, ".", (_, _) => Task.FromResult(true), (_, _) => { });
Assert.False(result.Success);
Assert.Equal(ExecutionStopReason.InstallFailed, result.StopReason);
}
[Fact]
public async Task StepFailure_StopsImmediately()
{
var executor = new WorkflowExecutor(
new WorkflowPlanner(),
new FakeProbeService(isAvailable: true),
new FakeInstallerService(success: true),
new FakeActionRunner(success: false),
new RequirementResolver());
var wf = new WorkflowDefinition
{
Id = "w",
Label = "W",
Steps =
[
new WorkflowStep { Id = "s1", Label = "S1", Command = "dotnet", Args = ["build"] },
new WorkflowStep { Id = "s2", Label = "S2", Command = "dotnet", Args = ["build"] },
]
};
var map = new Dictionary<string, WorkflowDefinition>(StringComparer.OrdinalIgnoreCase) { [wf.Id] = wf };
var result = await executor.ExecuteAsync(
wf, map, new DevToolConfig(), ".", (_, _) => Task.FromResult(true), (_, _) => { });
Assert.False(result.Success);
Assert.Equal(ExecutionStopReason.CommandFailed, result.StopReason);
Assert.Single(result.Steps);
}
[Fact]
public async Task LegacyPwshScriptStep_MissingPrereq_PromptsBeforeRun()
{
var executor = new WorkflowExecutor(
new WorkflowPlanner(),
new FakeProbeService(isAvailable: false),
new FakeInstallerService(success: true),
new FakeActionRunner(success: true),
new RequirementResolver());
var wf = new WorkflowDefinition
{
Id = "w",
Label = "W",
Steps =
[
new WorkflowStep
{
Id = "ps1",
Label = "Legacy PS1",
Command = "pwsh",
Args = ["-NoProfile", "-File", "scripts/publish-app.ps1", "-Target", "web"],
}
]
};
var map = new Dictionary<string, WorkflowDefinition>(StringComparer.OrdinalIgnoreCase) { [wf.Id] = wf };
var result = await executor.ExecuteAsync(
wf, map, new DevToolConfig(), ".", (_, _) => Task.FromResult(false), (_, _) => { });
Assert.False(result.Success);
Assert.Equal(ExecutionStopReason.UserDeclined, result.StopReason);
}
[Fact]
public async Task TauriBuild_DoesNotRequireGlobalTauri_WhenNodeNpmCargoAvailable()
{
var executor = new WorkflowExecutor(
new WorkflowPlanner(),
new ConditionalProbeService(),
new FakeInstallerService(success: true),
new FakeActionRunner(success: true),
new RequirementResolver());
var wf = new WorkflowDefinition
{
Id = "w",
Label = "W",
Steps =
[
new WorkflowStep
{
Id = "tauri",
Label = "Tauri Build",
Action = "tauri-build",
}
]
};
var map = new Dictionary<string, WorkflowDefinition>(StringComparer.OrdinalIgnoreCase) { [wf.Id] = wf };
var result = await executor.ExecuteAsync(
wf, map, new DevToolConfig(), ".", (_, _) => Task.FromResult(true), (_, _) => { });
Assert.True(result.Success);
Assert.Null(result.StopReason);
Assert.Single(result.Steps);
}
[Fact]
public async Task MissingPrereq_EmitsProbeDiagnosticsToOutput()
{
var executor = new WorkflowExecutor(
new WorkflowPlanner(),
new DetailedProbeService(),
new FakeInstallerService(success: true),
new FakeActionRunner(success: true),
new RequirementResolver());
var wf = BuildSingleStepWorkflow("w", "dotnet");
var map = new Dictionary<string, WorkflowDefinition>(StringComparer.OrdinalIgnoreCase) { [wf.Id] = wf };
var lines = new List<string>();
var result = await executor.ExecuteAsync(
wf, map, new DevToolConfig(), ".", (_, _) => Task.FromResult(false), (line, _) => lines.Add(line));
Assert.False(result.Success);
Assert.Contains(lines, l => l.Contains("Probe detail [dotnet]", StringComparison.OrdinalIgnoreCase));
}
[Fact]
public async Task ExecuteAsync_EmitsRunEvents_ForStepLifecycle()
{
var executor = new WorkflowExecutor(
new WorkflowPlanner(),
new FakeProbeService(isAvailable: true),
new FakeInstallerService(success: true),
new FakeActionRunner(success: true),
new RequirementResolver());
var wf = BuildSingleStepWorkflow("w", "dotnet");
var map = new Dictionary<string, WorkflowDefinition>(StringComparer.OrdinalIgnoreCase) { [wf.Id] = wf };
var events = new List<RunEvent>();
var result = await executor.ExecuteAsync(
wf, map, new DevToolConfig(), ".", (_, _) => Task.FromResult(true), (_, _) => { }, events.Add);
Assert.True(result.Success);
Assert.Contains(events, e => e.Type == RunEventType.WorkflowStarted);
Assert.Contains(events, e => e.Type == RunEventType.WorkflowStepStarted);
Assert.Contains(events, e => e.Type == RunEventType.WorkflowStepCompleted);
Assert.Contains(events, e => e.Type == RunEventType.WorkflowCompleted && e.Success == true);
}
[Fact]
public void AggregatorWorkflow_ExecutesDependenciesOnly()
{
var planner = new WorkflowPlanner();
var dep = new WorkflowDefinition
{
Id = "dep",
Label = "Dependency",
Steps = [new WorkflowStep { Id = "s", Label = "S", Command = "dotnet", Args = ["build"] }]
};
var agg = new WorkflowDefinition
{
Id = "agg",
Label = "Aggregator",
DependsOn = ["dep"],
Steps = []
};
var map = new Dictionary<string, WorkflowDefinition>(StringComparer.OrdinalIgnoreCase)
{
[dep.Id] = dep,
[agg.Id] = agg
};
var plan = planner.ResolvePlan(agg, map);
Assert.Single(plan);
Assert.Equal("dep", plan[0].Id);
}
private static WorkflowDefinition BuildSingleStepWorkflow(string id, string tool)
{
return new WorkflowDefinition
{
Id = id,
Label = id,
Steps =
[
new WorkflowStep
{
Id = "step",
Label = "step",
Command = tool,
Args = ["--version"],
Requires = [new ToolRequirement { Tool = tool, InstallPolicy = InstallPolicy.Prompt }],
}
]
};
}
private sealed class FakeProbeService(bool isAvailable) : IToolProbe
{
public Task<ProbeResult> ProbeAsync(
string tool,
string projectRoot,
DevToolConfig? config = null,
CancellationToken cancellationToken = default)
=> Task.FromResult(new ProbeResult(tool, isAvailable, Version: isAvailable ? "1.0.0" : null));
}
private sealed class FakeInstallerService(bool success) : IPrereqInstaller
{
public Task<InstallPlan> GetInstallPlanAsync(
string tool,
string projectRoot,
DevToolConfig? config = null,
CancellationToken cancellationToken = default)
=> Task.FromResult(new InstallPlan(tool, Supported: true, "test", [new InstallCommand("echo", ["ok"])]));
public Task<RunResult> RunInstallAsync(
InstallCommand command,
string projectRoot,
Action<string, bool> onOutput,
CancellationToken cancellationToken = default)
=> Task.FromResult(new RunResult(success ? 0 : 1, TimeSpan.FromMilliseconds(5)));
}
private sealed class FakeActionRunner(bool success) : IActionRunner
{
public Task<RunResult> RunStepAsync(
WorkflowStep step,
string projectRoot,
Action<string, bool> onOutput,
CancellationToken cancellationToken = default)
=> Task.FromResult(new RunResult(success ? 0 : 2, TimeSpan.FromMilliseconds(10)));
}
private sealed class ConditionalProbeService : IToolProbe
{
public Task<ProbeResult> ProbeAsync(
string tool,
string projectRoot,
DevToolConfig? config = null,
CancellationToken cancellationToken = default)
{
var available = tool.ToLowerInvariant() switch
{
"node" => true,
"npm" => true,
"cargo" => true,
"tauri" => false,
_ => true
};
return Task.FromResult(new ProbeResult(tool, available, Version: available ? "1.0.0" : null));
}
}
private sealed class DetailedProbeService : IToolProbe
{
public Task<ProbeResult> ProbeAsync(
string tool,
string projectRoot,
DevToolConfig? config = null,
CancellationToken cancellationToken = default)
=> Task.FromResult(new ProbeResult(tool, false, Details: "Fallback: unresolved command"));
}
}

149
Journal.DevTool/tests/DevTool.Tests/WorkflowModelBuilderTests.cs Normal file
View File

@ -0,0 +1,149 @@
using Sdt.Config;
using Xunit;
namespace DevTool.Tests;
public sealed class WorkflowModelBuilderTests
{
[Fact]
public void TargetsOnly_Strict_ThrowsMigrationError()
{
var cfg = new DevToolConfig
{
Targets =
[
new BuildTarget
{
Id = "build",
Label = "Build",
Command = "dotnet",
Args = ["build"],
}
]
};
var ex = Assert.Throws<InvalidOperationException>(() => WorkflowModelBuilder.Normalize(cfg, LegacyMode.Strict));
Assert.Contains("Legacy 'targets' are not allowed in strict mode", ex.Message, StringComparison.OrdinalIgnoreCase);
}
[Fact]
public void TargetsOnly_Compat_ProducesWarningAndConvertedWorkflow()
{
var cfg = new DevToolConfig
{
Targets =
[
new BuildTarget
{
Id = "build",
Label = "Build",
Command = "dotnet",
Args = ["build"],
}
]
};
var result = WorkflowModelBuilder.Normalize(cfg, LegacyMode.Compat);
Assert.Single(result.Workflows);
Assert.Contains(result.Warnings, w => w.Contains("legacy 'targets'", StringComparison.OrdinalIgnoreCase));
}
[Fact]
public void WorkflowsOnly_HasNoLegacyWarning()
{
var cfg = new DevToolConfig
{
Workflows =
[
new WorkflowDefinition
{
Id = "build",
Label = "Build",
Steps =
[
new WorkflowStep
{
Id = "run",
Label = "Run",
Command = "dotnet",
Args = ["build"],
}
]
}
]
};
var result = WorkflowModelBuilder.Normalize(cfg, LegacyMode.Strict);
Assert.Single(result.Workflows);
Assert.DoesNotContain(result.Warnings, w => w.Contains("legacy 'targets'", StringComparison.OrdinalIgnoreCase));
}
[Fact]
public void Mixed_PrefersWorkflowsDeterministically()
{
var cfg = new DevToolConfig
{
Targets =
[
new BuildTarget
{
Id = "legacy",
Label = "Legacy",
Command = "dotnet",
Args = ["build"],
}
],
Workflows =
[
new WorkflowDefinition
{
Id = "new",
Label = "New",
Steps =
[
new WorkflowStep
{
Id = "step",
Label = "Step",
Command = "dotnet",
Args = ["build"],
}
]
}
]
};
var result = WorkflowModelBuilder.Normalize(cfg, LegacyMode.Strict);
Assert.Single(result.Workflows);
Assert.Equal("new", result.Workflows[0].Id);
Assert.Contains(result.Warnings, w => w.Contains("Both 'workflows' and legacy 'targets'", StringComparison.OrdinalIgnoreCase));
}
[Fact]
public void LegacyPwshTarget_InfersToolRequirements_FromScript()
{
var cfg = new DevToolConfig
{
Targets =
[
new BuildTarget
{
Id = "web",
Label = "Web",
Command = "pwsh",
Args = ["-NoProfile", "-File", "scripts/publish-app.ps1", "-Target", "web"],
}
]
};
var result = WorkflowModelBuilder.Normalize(cfg, LegacyMode.Compat);
var step = Assert.Single(result.Workflows).Steps.Single();
Assert.Contains(step.Requires, r => r.Tool == "python");
Assert.Contains(step.Requires, r => r.Tool == "node");
Assert.Contains(step.Requires, r => r.Tool == "npm");
}
}

141
Journal.DevTool/tests/DevTool.Tests/WorkspaceDefaultsTests.cs Normal file
View File

@ -0,0 +1,141 @@
using Sdt.Config;
using Xunit;
namespace DevTool.Tests;
public sealed class WorkspaceDefaultsTests
{
[Fact]
public void ConfigLoader_AppliesWorkspaceDefaults_FromAncestorDirectory()
{
var workspaceRoot = CreateTempDir("sdt-ws-defaults-");
var projectRoot = Path.Combine(workspaceRoot, "proj-a");
Directory.CreateDirectory(projectRoot);
File.WriteAllText(Path.Combine(workspaceRoot, WorkspaceLoader.FileName), """
{
"name": "Test Workspace",
"projects": []
}
""");
File.WriteAllText(Path.Combine(workspaceRoot, ConfigLoader.WorkspaceDefaultsFileName), """
{
"toolchains": {
"node": {
"packageManager": "pnpm",
"workingDir": "frontend"
}
},
"env": [
{ "key": "DOTNET_ENVIRONMENT", "description": "default env", "default": "Development", "options": ["Development", "Production"] }
]
}
""");
File.WriteAllText(Path.Combine(projectRoot, "devtool.json"), """
{
"name": "Project A",
"version": "1.0.0",
"workflows": [
{
"id": "build",
"label": "Build",
"description": "Build app",
"group": "Build",
"dependsOn": [],
"steps": [
{ "id": "build-step", "label": "dotnet build", "command": "dotnet", "args": ["build"], "workingDir": "." }
]
}
]
}
""");
var loaded = ConfigLoader.FindAndLoad(projectRoot);
Assert.NotNull(loaded);
Assert.Equal("pnpm", loaded!.Config.Toolchains?.Node?.PackageManager);
Assert.Equal("frontend", loaded.Config.Toolchains?.Node?.WorkingDir);
Assert.Single(loaded.Config.Env);
Assert.Contains(loaded.Warnings, w => w.Contains("Applied workspace defaults", StringComparison.OrdinalIgnoreCase));
}
[Fact]
public void ConfigLoader_ProjectValuesOverrideWorkspaceDefaults()
{
var workspaceRoot = CreateTempDir("sdt-ws-override-");
var projectRoot = Path.Combine(workspaceRoot, "proj-b");
Directory.CreateDirectory(projectRoot);
File.WriteAllText(Path.Combine(workspaceRoot, WorkspaceLoader.FileName), """
{
"name": "Test Workspace",
"projects": []
}
""");
File.WriteAllText(Path.Combine(workspaceRoot, ConfigLoader.WorkspaceDefaultsFileName), """
{
"name": "Workspace Defaults",
"workflows": [
{
"id": "from-defaults",
"label": "Defaults Workflow",
"description": "",
"group": "General",
"dependsOn": [],
"steps": []
}
],
"debug": {
"diagnostics": {
"enabled": true,
"outputDir": ".sdt/workspace-debug",
"includeAllEnv": true,
"bundleOnFailure": true
}
}
}
""");
File.WriteAllText(Path.Combine(projectRoot, "devtool.json"), """
{
"name": "Project B",
"version": "1.0.0",
"workflows": [
{
"id": "project-workflow",
"label": "Project Workflow",
"description": "Only this one should remain",
"group": "Build",
"dependsOn": [],
"steps": []
}
],
"debug": {
"diagnostics": {
"enabled": false
}
}
}
""");
var loaded = ConfigLoader.FindAndLoad(projectRoot);
Assert.NotNull(loaded);
Assert.Equal("Project B", loaded!.Config.Name);
Assert.Single(loaded.Config.Workflows);
Assert.Equal("project-workflow", loaded.Config.Workflows[0].Id);
Assert.NotNull(loaded.Config.Debug);
Assert.NotNull(loaded.Config.Debug!.Diagnostics);
Assert.False(loaded.Config.Debug.Diagnostics.Enabled);
Assert.Equal(".sdt/workspace-debug", loaded.Config.Debug.Diagnostics.OutputDir);
Assert.True(loaded.Config.Debug.Diagnostics.IncludeAllEnv);
}
private static string CreateTempDir(string prefix)
{
var path = Path.Combine(Path.GetTempPath(), prefix + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(path);
return path;
}
}

56
Journal.DevTool/tests/DevTool.Tests/WorkspaceLoaderTests.cs Normal file
View File

@ -0,0 +1,56 @@
using Sdt.Config;
using Xunit;
namespace DevTool.Tests;
public sealed class WorkspaceLoaderTests
{
[Fact]
public void FindAndLoad_DoesNotThrow_WhenAutoDiscoverHitsStrictLegacyProject()
{
var root = Path.Combine(Path.GetTempPath(), "sdt-workspace-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(root);
File.WriteAllText(Path.Combine(root, "devtool.json"), """
{
"name": "legacy",
"version": "0.1.0",
"targets": [
{
"id": "build",
"label": "Build",
"group": "Build",
"command": "dotnet",
"args": ["build"],
"workingDir": ".",
"dependsOn": []
}
],
"workflows": []
}
""");
Environment.SetEnvironmentVariable("SDT_LEGACY_MODE", null);
var result = WorkspaceLoader.FindAndLoad(root);
Assert.Null(result);
}
[Fact]
public void ResolveProjectRoot_AcceptsAbsolutePaths()
{
var root = Path.GetFullPath(Path.Combine(Path.GetTempPath(), "ws-" + Guid.NewGuid().ToString("N")));
var abs = Path.GetFullPath(Path.Combine(Path.GetTempPath(), "proj-" + Guid.NewGuid().ToString("N")));
var project = new WorkspaceProject { Path = abs };
var resolved = WorkspaceLoader.ResolveProjectRoot(root, project);
Assert.Equal(abs, resolved, ignoreCase: OperatingSystem.IsWindows());
}
[Fact]
public void WorkspaceProject_AdditionalFields_DefaultsAreSafe()
{
var project = new WorkspaceProject();
Assert.Empty(project.Tags);
Assert.Empty(project.ToolFamilies);
Assert.False(project.Disabled);
}
}

1032
devtool.json
View File

File diff suppressed because it is too large Load Diff

105
justfile
View File

@ -1,105 +0,0 @@
# SDT — Project Journal Justfile
# Install just: https://just.systems/man/en/packages.html
set windows-shell := ["pwsh", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command"]
set shell := ["pwsh", "-c"]
# Detect runtime from OS
runtime := if os() == "windows" { "win-x64" } else { "linux-x64" }
# ── Default: list available recipes ────────────────────────────────────────────
default:
@just --list
# ── Build ──────────────────────────────────────────────────────────────────────
# Build Journal.Sidecar as self-contained single-file exe
sidecar:
& ./scripts/publish-sidecar.ps1 -Configuration Release -Runtime {{runtime}}
# Build SvelteKit web bundle (output: Journal.App/build/)
web:
& ./scripts/publish-app.ps1 -Target web
# Publish WebGateway with embedded web UI (depends: web)
webgateway: web
& ./scripts/publish-webgateway.ps1 -Configuration Release -Runtime {{runtime}}
# Build Tauri desktop exe — no installer (depends: sidecar)
tauri: sidecar
& ./scripts/publish-app.ps1 -Target tauri -TauriBundles none
# Build Tauri with NSIS installer (depends: sidecar)
tauri-nsis: sidecar
& ./scripts/publish-app.ps1 -Target tauri -TauriBundles nsis
# Build Tauri with MSI installer (depends: sidecar)
tauri-msi: sidecar
& ./scripts/publish-app.ps1 -Target tauri -TauriBundles msi
# Full release build — everything in correct order
all: sidecar web webgateway tauri
# ── Dev ────────────────────────────────────────────────────────────────────────
# Run WebGateway dev server (http://localhost:5180)
run:
& ./scripts/run-webgateway.ps1
# Run WebGateway with pinned project root (avoids multi-clone ambiguity)
run-pinned:
& ./scripts/run-webgateway.ps1 -ProjectRoot {{justfile_directory()}} -Urls http://0.0.0.0:5180
# SvelteKit dev server only (http://localhost:1420)
dev-app:
Set-Location Journal.App; npm run dev
# Tauri dev mode (desktop window + hot reload)
dev-tauri: sidecar
Set-Location Journal.App; npm run tauri dev
# ── Test ───────────────────────────────────────────────────────────────────────
# Run all smoke tests (~80 integration tests)
test:
dotnet run --project Journal.SmokeTests/Journal.SmokeTests.csproj
# Full migration gate (build + smoke + parity)
gate:
& ./scripts/migration-gate.ps1
# Migration gate — skip smoke tests
gate-fast:
& ./scripts/migration-gate.ps1 -SkipSmoke
# Migration gate — skip API contract tests
gate-no-api:
& ./scripts/migration-gate.ps1 -SkipApi
# ── .NET ───────────────────────────────────────────────────────────────────────
# dotnet build all projects
build:
dotnet build
# dotnet build with resilient NuGet defaults (use in restricted environments)
build-safe:
& ./scripts/dotnet-min.ps1 build Journal.Core/Journal.Core.csproj
& ./scripts/dotnet-min.ps1 build Journal.Sidecar/Journal.Sidecar.csproj
& ./scripts/dotnet-min.ps1 build Journal.WebGateway/Journal.WebGateway.csproj
# ── NuGet Cache ────────────────────────────────────────────────────────────────
# Export NuGet cache to zip for offline/transfer use
nuget-export zip="nuget-cache-export.zip":
& ./scripts/nuget-export-cache.ps1 -OutputZip {{zip}}
# Import NuGet cache zip and validate restore
nuget-import zip="nuget-cache-export.zip":
& ./scripts/nuget-import-cache.ps1 -InputZip {{zip}}
# ── SDT ────────────────────────────────────────────────────────────────────────
# Launch SDT dev tool TUI
sdt:
dotnet run --project Journal.DevTool/Journal.DevTool.csproj

328
scripts/README.md
View File

@ -1,328 +0,0 @@
# Scripts Reference
This folder contains PowerShell wrappers for repeatable local development, build, publish, and cache operations.
## Scope
These scripts target the repository rooted at `E:\stansshit\csharp\journal-master\journal`.
## Requirements
- PowerShell 7+ (`pwsh` recommended)
- .NET SDK (current repo uses `net10.0` targets)
- Python (for `pip-min.ps1`, `migration-gate.ps1`)
- Node.js + npm (for `publish-app.ps1`)
## Execution Policy
If script execution is blocked on Windows, run commands with one of:
```powershell
pwsh -NoProfile -ExecutionPolicy Bypass -File .\scripts\<script>.ps1
```
or in-session:
```powershell
Set-ExecutionPolicy -Scope Process Bypass
```
## Script Overview
| Script | Purpose |
|---|---|
| `dev-shell.ps1` | Initializes current shell with repo-local .NET/pip/HuggingFace cache env vars. |
| `script-common.ps1` | Shared helper functions used by most scripts. |
| `dotnet-min.ps1` | Minimal `dotnet` wrapper with local NuGet cache and safe defaults. |
| `pip-min.ps1` | Minimal `pip` wrapper with repo-local target/cache and Windows compatibility mapping. |
| `pip_safe.py` | Python wrapper used by `pip-min.ps1` to patch temporary-directory behavior. |
| `publish-app.ps1` | Builds frontend web bundle or Tauri desktop app. |
| `publish-sidecar.ps1` | Publishes `Journal.Sidecar` single-file executable to `output/`. |
| `publish-webgateway.ps1` | Publishes `Journal.WebGateway` and optionally copies web assets into `wwwroot`. |
| `run-webgateway.ps1` | Runs `Journal.WebGateway` with configurable URLs and project root. |
| `migration-gate.ps1` | End-to-end migration/parity gate (build + smoke/parity/API checks). |
| `nuget-export-cache.ps1` | Primes and exports `.nuget` cache to zip for transfer. |
| `nuget-import-cache.ps1` | Imports exported cache zip and validates restore. |
## Common Patterns Used Across Scripts
- Proxy cleanup: `Clear-JournalProxyEnv`
- Repo root detection: `Resolve-JournalRepoRoot`
- Repo-local caches:
- `.dotnet_home`
- `.nuget\packages`
- `.nuget\http-cache`
- `.pip\cache`
- `.tmp\*`
- `.npm\cache`
## Detailed Reference
### `dev-shell.ps1`
Dot-source this script to configure your *current shell*.
```powershell
. .\scripts\dev-shell.ps1
```
What it does:
- loads `script-common.ps1`
- resolves repo root
- clears proxy env vars
- initializes repo-local .NET, pip, and HuggingFace env vars
Use this once per shell session before running development commands manually.
### `script-common.ps1`
Shared helper functions:
- `Clear-JournalProxyEnv`
- `Resolve-JournalRepoRoot`
- `Initialize-JournalDotnetEnv`
- `Initialize-JournalPipEnv`
- `Initialize-JournalHuggingFaceEnv`
- `Resolve-JournalSidecarProjectPath`
- `Resolve-JournalAppRoot`
- `Resolve-JournalWebGatewayProjectPath`
Also supports optional override:
- `JOURNAL_REPO_ROOT`
### `dotnet-min.ps1`
Wrapper around `dotnet` with resilient restore/build defaults.
Usage:
```powershell
.\scripts\dotnet-min.ps1 <dotnet args>
```
Examples:
```powershell
.\scripts\dotnet-min.ps1 build Journal.Sidecar/Journal.Sidecar.csproj
.\scripts\dotnet-min.ps1 restore Journal.WebGateway/Journal.WebGateway.csproj
.\scripts\dotnet-min.ps1 run --project Journal.Sidecar/Journal.Sidecar.csproj
```
Behavior:
- sets repo-local `DOTNET_CLI_HOME` and NuGet cache paths
- clears proxy env vars
- adds for common commands (`restore`, `build`, `run`, `test`, `publish`, `pack`):
- `-p:RestoreIgnoreFailedSources=true`
- `-p:NuGetAudit=false`
- for `restore`, also adds `--ignore-failed-sources`
### `pip-min.ps1`
Wrapper around `python -m pip` focused on constrained hosts.
Usage:
```powershell
.\scripts\pip-min.ps1 <pip args>
```
Examples:
```powershell
.\scripts\pip-min.ps1 install requests
.\scripts\pip-min.ps1 install --index-url https://pypi.org/simple faster-whisper
```
Behavior:
- initializes repo-local pip cache/temp paths
- clears proxy env vars
- for `install` without target/prefix:
- strips `--user`
- installs into `.pydeps\py314`
- on Windows, maps `pyaudio` to `pyaudiowpatch`
- uses `pip_safe.py` if present
### `pip_safe.py`
Compatibility wrapper for pip on some Windows + Python 3.14 setups.
Behavior:
- monkey-patches `tempfile.mkdtemp` to create writable temp directories (`0o777`)
- then forwards to pip internal CLI
### `publish-app.ps1`
Builds the frontend (`web`) or Tauri desktop app (`tauri`).
Parameters:
- `-Target web|tauri` (default `web`)
- `-Configuration Release|Debug` (default `Release`)
- `-TauriBundles none|nsis|msi` (default `none`)
- `-InstallDeps`
- `-SkipInstall`
- `-DryRun`
Examples:
```powershell
.\scripts\publish-app.ps1 -Target web
.\scripts\publish-app.ps1 -Target tauri -TauriBundles none
.\scripts\publish-app.ps1 -Target tauri -TauriBundles nsis
```
Notes:
- uses repo-local npm cache/temp paths
- `-TauriBundles none` maps to `tauri build --no-bundle` (raw exe build)
- expected web output: `Journal.App\build`
- expected tauri exe location: `Journal.App\src-tauri\target\release\journalapp.exe` (Release)
### `publish-sidecar.ps1`
Publishes `Journal.Sidecar` as a self-contained single-file executable.
Parameters:
- `-Configuration` (default `Release`)
- `-Runtime` (default `win-x64`)
Example:
```powershell
.\scripts\publish-sidecar.ps1 -Configuration Release -Runtime win-x64
```
Output:
- `output\Journal.Sidecar.exe` (for Windows runtime)
### `publish-webgateway.ps1`
Publishes `Journal.WebGateway` and optionally embeds built web assets.
Parameters:
- `-Configuration Release|Debug` (default `Release`)
- `-Runtime` (default `win-x64`)
- `-SelfContained` (switch)
- `-SkipWebAssets` (switch)
Example:
```powershell
.\scripts\publish-app.ps1 -Target web
.\scripts\publish-webgateway.ps1 -Configuration Release -Runtime win-x64
```
Output:
- `output\webgateway\`
- optional `output\webgateway\wwwroot\` from `Journal.App\build`
### `run-webgateway.ps1`
Runs `Journal.WebGateway` directly with controlled environment.
Parameters:
- `-Configuration Release|Debug` (default `Release`)
- `-Urls` (default `http://0.0.0.0:5180`)
- `-ProjectRoot` (optional; if omitted, repo root)
Examples:
```powershell
.\scripts\run-webgateway.ps1
.\scripts\run-webgateway.ps1 -Urls http://127.0.0.1:5180
.\scripts\run-webgateway.ps1 -ProjectRoot E:\stansshit\csharp\journal-master\journal
```
Notes:
- sets `JOURNAL_PROJECT_ROOT` for the gateway process
- useful when multiple repo clones exist and you need deterministic data/vault paths
### `migration-gate.ps1`
Runs migration quality gate.
Parameters:
- `-SkipSmoke`
- `-SkipApi`
Current behavior:
1. builds `Journal.Sidecar`
2. optionally runs `Journal.SmokeTests`
3. runs Python parity harness test discovery
4. optionally runs API contract test discovery
If `tests/` is absent, Python parity and API contract steps are skipped automatically with a clear message — the sidecar build and smoke tests still run.
### `nuget-export-cache.ps1`
Primes and exports NuGet cache to zip.
Parameters:
- `-OutputZip` (default `nuget-cache-export.zip`)
- `-IncludeDotnetHome`
Behavior:
- runs restore for selected projects via `dotnet-min.ps1`
- copies `.nuget` (and optional `.dotnet_home`) to staging
- writes `nuget-cache-manifest.txt`
- outputs zip
Primes restore for `Journal.Sidecar`, `Journal.WebGateway`, and `Journal.SmokeTests`.
### `nuget-import-cache.ps1`
Imports exported cache zip and validates by restore.
Parameters:
- `-InputZip` (default `nuget-cache-export.zip`)
Behavior:
- extracts zip into repo root
- runs restore for selected projects via `dotnet-min.ps1`
Validates restore for `Journal.Sidecar`, `Journal.WebGateway`, and `Journal.SmokeTests`.
## Environment Variables Used
- `JOURNAL_REPO_ROOT` (optional override for repo detection)
- `JOURNAL_PROJECT_ROOT` (runtime project root for gateway/sidecar config)
- `DOTNET_CLI_HOME`
- `NUGET_PACKAGES`
- `NUGET_HTTP_CACHE_PATH`
- `NUGET_CERT_REVOCATION_MODE`
- `PIP_CACHE_DIR`
- `HF_HOME`
- `HUGGINGFACE_HUB_CACHE`
## Output and Cache Directories
- `output/`
- `output/webgateway/`
- `.dotnet_home/`
- `.nuget/packages/`
- `.nuget/http-cache/`
- `.npm/cache/`
- `.pip/cache/`
- `.tmp/`
- `.pydeps/`
## See Also
- [`WORKFLOWS.md`](./WORKFLOWS.md) for copy/paste command recipes.

140
scripts/WORKFLOWS.md
View File

@ -1,140 +0,0 @@
# Script Workflows
Practical command recipes for common tasks.
## 1) Start a Clean Dev Shell
```powershell
cd E:\stansshit\csharp\journal-master\journal
. .\scripts\dev-shell.ps1
```
Use this when you want the current shell configured with repo-local cache paths.
## 2) Build .NET Projects With Safe Defaults
```powershell
.\scripts\dotnet-min.ps1 build Journal.Sidecar/Journal.Sidecar.csproj
.\scripts\dotnet-min.ps1 build Journal.WebGateway/Journal.WebGateway.csproj
```
## 3) Build Frontend or Desktop App
Web build:
```powershell
.\scripts\publish-app.ps1 -Target web
```
Tauri raw exe (no installer):
```powershell
.\scripts\publish-app.ps1 -Target tauri -TauriBundles none
```
Tauri installer bundles:
```powershell
.\scripts\publish-app.ps1 -Target tauri -TauriBundles nsis
.\scripts\publish-app.ps1 -Target tauri -TauriBundles msi
```
## 4) Publish Sidecar
```powershell
.\scripts\publish-sidecar.ps1 -Configuration Release -Runtime win-x64
```
Expected output under `output/`.
## 5) Publish WebGateway Package
```powershell
.\scripts\publish-app.ps1 -Target web
.\scripts\publish-webgateway.ps1 -Configuration Release -Runtime win-x64
```
If you only want gateway binary refresh:
```powershell
.\scripts\publish-webgateway.ps1 -SkipWebAssets
```
## 6) Run WebGateway Against Explicit Root
When multiple clones exist, always pin project root:
```powershell
.\scripts\run-webgateway.ps1 -ProjectRoot E:\stansshit\csharp\journal-master\journal -Urls http://0.0.0.0:5180
```
Quick health check:
```powershell
Invoke-RestMethod http://127.0.0.1:5180/api/health
```
Inspect active backend config:
```powershell
$body = @{ action = 'config.get' } | ConvertTo-Json
Invoke-RestMethod -Uri http://127.0.0.1:5180/api/command -Method Post -ContentType 'application/json' -Body $body
```
## 7) Python Package Installs in Repo-Local Target
```powershell
.\scripts\pip-min.ps1 install requests
```
Packages go to `.pydeps\py314` unless you pass your own `--target`/`--prefix`.
## 8) Migration Gate (When Full Test Assets Exist)
```powershell
.\scripts\migration-gate.ps1
```
Partial run:
```powershell
.\scripts\migration-gate.ps1 -SkipSmoke -SkipApi
```
If `tests/` is absent, Python parity and API contract steps are skipped with a clear message.
## 9) NuGet Cache Export/Import (Offline-ish Restore)
Export:
```powershell
.\scripts\nuget-export-cache.ps1 -OutputZip .\nuget-cache-export.zip
```
Import:
```powershell
.\scripts\nuget-import-cache.ps1 -InputZip .\nuget-cache-export.zip
```
Validates restore for `Journal.Sidecar`, `Journal.WebGateway`, and `Journal.SmokeTests`.
## 10) Quick Troubleshooting
Script blocked by execution policy:
```powershell
pwsh -NoProfile -ExecutionPolicy Bypass -File .\scripts\publish-app.ps1 -Target web
```
Unexpected data/vault mismatch in WebGateway:
1. Run with explicit `-ProjectRoot`.
2. Verify with `config.get` via `/api/command`.
3. Verify sidecar root via `/api/sidecar/root`.
NuGet restore flakiness:
1. Use `dotnet-min.ps1` wrappers.
2. Confirm proxy vars are cleared (`HTTP_PROXY`, `HTTPS_PROXY`, etc.).
3. Ensure `.nuget` directories are writable.

Some files were not shown because too many files have changed in this diff Show More