zelari-code 1.4.1 → 1.5.1

package/dist/cli/utils/paths.js

@@ -1,4 +1,5 @@
 import { homedir } from 'node:os';
+import path from 'node:path';
 /**
  * shortenCwd — compact a directory path for one-line UI surfaces
  * (StatusBar, banner).
@@ -17,4 +18,50 @@ export function shortenCwd(p, maxLen = 40, home = homedir()) {
         return out;
     return `…${out.slice(-(maxLen - 1))}`;
 }
+/**
+ * relativePosix — relativize a path against a root and normalize to `/`.
+ *
+ * Why: `path.relative()` on win32 joins segments with backslashes. Every
+ * agent-facing surface (LSP tool results, diagnostic output) wants forward
+ * slashes — they match `file://` URIs, JSON, markdown, and every other path
+ * already shown to the model. Before this helper, two near-identical private
+ * functions (`relPath` in lsp/tools.ts, `relative` in diagnostics/engine.ts)
+ * called `path.relative` with zero normalization, producing `src\a.ts` on
+ * Windows where the rest of the output stream uses `src/a.ts`.
+ *
+ * Semantics:
+ *   - Returns the relative path when `to` is inside `from`.
+ *   - Returns `to` unchanged when it escapes the root (`..` traversal) or the
+ *     relativization fails, so absolute paths outside the project are shown
+ *     as-is rather than as a misleading `..\..\elsewhere`.
+ *   - Output always uses `/` regardless of platform separator.
+ *
+ * Not for: filesystem I/O (platform-native separators matter there) or URI
+ * construction (see lsp/protocol.ts `pathToUri`, which also percent-encodes).
+ *
+ * @param from  Anchor directory (typically the project root).
+ * @param to    Target file or directory (absolute, or already relative).
+ * @returns POSIX-style relative path, or `to` if it can't be relativized.
+ */
+export function relativePosix(from, to) {
+    try {
+        // Use the platform-specific path module explicitly rather than the
+        // default export. The default is bound to process.platform AT MODULE
+        // LOAD TIME — mutating process.platform later (e.g. in a test that
+        // simulates win32 on a Linux runner) does NOT rebind it, so
+        // path.relative would use posix semantics and fail on Windows paths.
+        // path.win32 / path.posix are stable platform-specific namespaces that
+        // work regardless of the host platform.
+        const p = process.platform === 'win32' ? path.win32 : path.posix;
+        const rel = p.relative(from, to);
+        if (!rel || rel.startsWith('..'))
+            return to;
+        // Normalize any platform separator to forward slashes. On win32 path.relative
+        // joins with '\\'; on POSIX it's already '/'. Either way, split on both.
+        return rel.split(/[\\/]/).join('/');
+    }
+    catch {
+        return to;
+    }
+}
 //# sourceMappingURL=paths.js.map

package/dist/cli/utils/paths.js.map

@@ -1 +1 @@
-{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../../src/cli/utils/paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAElC;;;;;;;GAOG;AACH,MAAM,UAAU,UAAU,CAAC,CAAS,EAAE,MAAM,GAAG,EAAE,EAAE,OAAe,OAAO,EAAE;IACzE,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,IACE,IAAI;QACJ,CAAC,GAAG,KAAK,IAAI,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,IAAI,IAAI,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,EAC3E,CAAC;QACD,GAAG,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;IACrC,CAAC;IACD,IAAI,GAAG,CAAC,MAAM,IAAI,MAAM;QAAE,OAAO,GAAG,CAAC;IACrC,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;AACxC,CAAC"}
+{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../../src/cli/utils/paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B;;;;;;;GAOG;AACH,MAAM,UAAU,UAAU,CAAC,CAAS,EAAE,MAAM,GAAG,EAAE,EAAE,OAAe,OAAO,EAAE;IACzE,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,IACE,IAAI;QACJ,CAAC,GAAG,KAAK,IAAI,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,IAAI,IAAI,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,EAC3E,CAAC;QACD,GAAG,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;IACrC,CAAC;IACD,IAAI,GAAG,CAAC,MAAM,IAAI,MAAM;QAAE,OAAO,GAAG,CAAC;IACrC,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,EAAU;IACpD,IAAI,CAAC;QACH,mEAAmE;QACnE,qEAAqE;QACrE,mEAAmE;QACnE,4DAA4D;QAC5D,qEAAqE;QACrE,uEAAuE;QACvE,wCAAwC;QACxC,MAAM,CAAC,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;QACjE,MAAM,GAAG,GAAG,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACjC,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC;YAAE,OAAO,EAAE,CAAC;QAC5C,8EAA8E;QAC9E,yEAAyE;QACzE,OAAO,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACtC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zelari-code",
-  "version": "1.4.1",
+  "version": "1.5.1",
   "description": "Zelari Code — AI Council coding agent CLI. Multi-agent orchestration (Caronte, Nettuno, Gerione, Plutone, Minosse, Lucifero) with slash commands, provider-agnostic LLM streaming, and self-update.",
   "author": "N-THEM Studio",
   "license": "SEE LICENSE IN LICENSE",
@@ -16,6 +16,8 @@
     "bin",
     "dist",
     "scripts/postinstall.mjs",
+    "scripts/repair-path.mjs",
+    "scripts/*.ps1",
     "LICENSE",
     "README.md",
     "package.json"
@@ -45,7 +47,7 @@
   },
   "devDependencies": {
     "@testing-library/react": "^16.3.2",
-    "@zelari/core": "1.4.1",
+    "@zelari/core": "1.5.1",
     "@types/node": "^25.3.0",
     "@types/react": "^19.0.10",
     "esbuild": "^0.25.0",

package/scripts/diagnose-path.ps1

@@ -0,0 +1,22 @@
+$prefix = (npm config get prefix).Trim()
+Write-Host "npm prefix: $prefix"
+Write-Host ""
+Write-Host "=== Session PATH (npm-related) ==="
+$env:Path -split ';' | Where-Object { $_ -and ($_ -match 'npm' -or $_ -eq $prefix) }
+Write-Host ""
+Write-Host "=== User PATH (npm-related) ==="
+$userPath = [Environment]::GetEnvironmentVariable('Path', 'User')
+$userPath -split ';' | Where-Object { $_ -and ($_ -match 'npm' -or $_ -eq $prefix) }
+Write-Host ""
+Write-Host "=== Machine PATH (npm-related) ==="
+$machinePath = [Environment]::GetEnvironmentVariable('Path', 'Machine')
+$machinePath -split ';' | Where-Object { $_ -and ($_ -match 'npm' -or $_ -eq $prefix) }
+Write-Host ""
+Write-Host "=== Shims in prefix ==="
+Get-ChildItem "$prefix\zelari-code*" -ErrorAction SilentlyContinue | Select-Object Name, FullName
+Write-Host ""
+Write-Host "=== where.exe zelari-code ==="
+where.exe zelari-code 2>&1
+Write-Host ""
+Write-Host "=== Direct run ==="
+& "$prefix\zelari-code.cmd" --version

package/scripts/dump-path.ps1

@@ -0,0 +1,13 @@
+$userPath = [Environment]::GetEnvironmentVariable('Path', 'User')
+Write-Host "User PATH length: $($userPath.Length)"
+Write-Host "Contains Z:\npm-global: $($userPath -like '*Z:\npm-global*')"
+Write-Host ""
+Write-Host "=== All User PATH entries ==="
+$i = 0
+$userPath -split ';' | ForEach-Object {
+  if ($_) { Write-Host ("{0,3}: [{1}]" -f $i++, $_) }
+}
+Write-Host ""
+Write-Host "=== Fresh merged PATH simulation ==="
+$merged = [Environment]::GetEnvironmentVariable('Path', 'Machine') + ';' + $userPath
+$merged -split ';' | Where-Object { $_ -match 'npm' -or $_ -eq 'Z:\npm-global' }

package/scripts/fix-path.ps1

@@ -0,0 +1,26 @@
+# Ensures npm global prefix is on the user PATH and reloads PATH in this session.
+$prefix = (npm config get prefix).Trim()
+$userPath = [Environment]::GetEnvironmentVariable('Path', 'User')
+
+if ($userPath -notlike "*$prefix*") {
+  $updated = if ($userPath) { "$userPath;$prefix" } else { $prefix }
+  [Environment]::SetEnvironmentVariable('Path', $updated, 'User')
+  Write-Host "PATH aggiornato (registry): aggiunto $prefix"
+} else {
+  Write-Host "PATH registry gia contiene: $prefix"
+}
+
+# Reload full PATH from registry into this session (fixes stale terminals).
+$machinePath = [Environment]::GetEnvironmentVariable('Path', 'Machine')
+$freshUserPath = [Environment]::GetEnvironmentVariable('Path', 'User')
+$env:Path = "$machinePath;$freshUserPath"
+
+Write-Host ""
+Write-Host "Verifica:"
+where.exe zelari-code 2>$null
+if ($LASTEXITCODE -ne 0) {
+  Write-Error "zelari-code non trovato. Esegui: npm link (dalla root del repo)"
+  exit 1
+}
+
+zelari-code --version

package/scripts/path-length.ps1

@@ -0,0 +1,15 @@
+$machine = [Environment]::GetEnvironmentVariable('Path', 'Machine')
+$user = [Environment]::GetEnvironmentVariable('Path', 'User')
+$merged = "$machine;$user"
+Write-Host "Machine PATH length: $($machine.Length)"
+Write-Host "User PATH length: $($user.Length)"
+Write-Host "Merged PATH length: $($merged.Length)"
+Write-Host "Session PATH length: $($env:Path.Length)"
+Write-Host ""
+Write-Host "Session has Z:\npm-global: $($env:Path -like '*Z:\npm-global*')"
+Write-Host ""
+# Count entries in session vs expected
+$sessionEntries = ($env:Path -split ';' | Where-Object { $_ }).Count
+$mergedEntries = ($merged -split ';' | Where-Object { $_ }).Count
+Write-Host "Session entries: $sessionEntries"
+Write-Host "Merged entries: $mergedEntries"

package/scripts/postinstall.mjs

@@ -41,6 +41,13 @@ import {
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 
+// Re-exported so existing imports (`import { repairWindowsPath } from
+// './postinstall.mjs'`) keep working. The implementation lives in
+// repair-path.mjs, which has no install-time side effects and is safe to
+// import in unit tests.
+import { repairWindowsPath } from './repair-path.mjs';
+export { repairWindowsPath };
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkgRoot = path.resolve(__dirname, '..');
 
@@ -163,6 +170,29 @@ function repairWindowsShim(prefix, pkgName) {
   return cmdWritten;
 }
 
+
+/**
+ * Thin wrapper around repairWindowsPath for the postinstall flow.
+ *
+ * Logs one of three outcomes (auto-fixed / already-ok / failed-but-continue)
+ * so the user understands what happened. Always non-fatal: a PATH write
+ * failure still leaves the install in a working state (the shim exists);
+ * the user can repair manually via `zelari-code --fix-path` later.
+ *
+ * @param {string} prefix  npm global prefix
+ */
+function ensureWindowsPath(prefix) {
+  if (process.platform !== 'win32') return;
+  const repaired = repairWindowsPath(prefix);
+  if (repaired) {
+    note(`added ${prefix} to the user PATH`);
+    note('open a NEW terminal for the change to take effect, then run `zelari-code --version`.');
+  }
+  // already-present or failed: silent on already-present (expected, common),
+  // and silent on failure because the warning block below covers the
+  // "command not found" symptom if it later bites the user.
+}
+
 const warn = (msg) => {
   // eslint-disable-next-line no-console
   console.warn(`[zelari-code postinstall] ${msg}`);
@@ -271,6 +301,7 @@ try {
       const repaired = repairWindowsShim(prefix, pkgName);
       if (repaired && existsSync(shimPath)) {
         note(`shim was missing — auto-created ${shimPath}`);
+        ensureWindowsPath(prefix);
         note('open a NEW terminal and run `zelari-code --version` to confirm.');
         checkGitAvailable();
         process.exit(0);
@@ -323,6 +354,7 @@ try {
 
   if (shimOk) {
     note(`shim OK: ${shimPath}`);
+    ensureWindowsPath(prefix);
     checkGitAvailable();
     process.exit(0);
   }

package/scripts/repair-path.mjs

@@ -0,0 +1,104 @@
+/**
+ * repair-path.mjs — Windows user-PATH repair logic, extracted for testability.
+ *
+ * Lives separately from postinstall.mjs so it can be imported in unit tests
+ * WITHOUT triggering postinstall's main side-effect block (the install flow
+ * that runs on `npm install -g`). postinstall.mjs re-imports and re-exports
+ * this so its public surface stays unchanged.
+ *
+ * Contract (shared with src/cli/utils/fixPath.ts):
+ *   - Windows only; no-op on POSIX.
+ *   - Scope "User" (HKCU), never "Machine" — no admin prompt, no GPO risk.
+ *   - Read via [Environment]::GetEnvironmentVariable('Path','User'), write via
+ *     SetEnvironmentVariable(...,'User'). Avoids `setx` (truncates at 1024
+ *     chars) and `reg.exe` (fragile REG_EXPAND_SZ parsing).
+ *   - Idempotent: exact-entry match (normalized), not substring.
+ *   - Never throws.
+ *
+ * @see scripts/postinstall.mjs — install-time caller
+ * @see src/cli/utils/fixPath.ts — runtime / `--fix-path` caller (TS port)
+ */
+
+import { spawnSync } from 'node:child_process';
+
+/**
+ * Normalize a PATH entry for exact matching: lowercase, forward→back slashes,
+ * trim trailing separators. Lets "C:\npm" match "c:\npm\" without accepting
+ * substring overlaps like "C:\npm-cache".
+ *
+ * @param {string} p
+ * @returns {string}
+ */
+function normalizeEntry(p) {
+  return p.toLowerCase().replace(/\/+/g, '\\').replace(/\\+$/, '');
+}
+
+/**
+ * Run a PowerShell one-liner via spawnSync (args array, no shell quoting
+ * headaches). Returns trimmed stdout, or '' on any failure (non-zero exit,
+ * spawn error). Never throws.
+ *
+ * @param {string} script  PowerShell command to execute
+ * @returns {string}
+ */
+function powershell(script) {
+  try {
+    const res = spawnSync(
+      'powershell.exe',
+      ['-NoProfile', '-NonInteractive', '-Command', script],
+      { encoding: 'utf8' },
+    );
+    if (res.status === 0) return (res.stdout || '').trim();
+    return '';
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Ensure the npm global prefix is on the Windows user PATH.
+ *
+ * Reads the User-scope PATH, appends `prefix` if it is not already an exact
+ * (normalized) entry, and writes it back. Opt out with ZELARI_NO_PATH_REPAIR=1.
+ *
+ * @param {string} prefix  npm global prefix (e.g. C:\Users\me\AppData\Roaming\npm)
+ * @returns {boolean}      true if the prefix was appended this call;
+ *                         false if already present, opted out, non-Windows,
+ *                         empty prefix, or the write failed
+ */
+export function repairWindowsPath(prefix) {
+  if (process.env.ZELARI_NO_PATH_REPAIR === '1') return false;
+  if (process.platform !== 'win32') return false;
+  if (!prefix) return false;
+
+  const userPath = powershell(
+    "[Environment]::GetEnvironmentVariable('Path','User')",
+  );
+  // Empty string is a valid PATH (fresh install); only the ambiguous
+  // "spawn failed, no signal" case (powershell returns '' AND we can't
+  // distinguish from a genuinely empty PATH) forces a bail. We treat a
+  // genuine empty PATH as "append" — SetEnvironmentVariable handles it.
+  // Detection: if powershell returned '' due to failure, the read status
+  // was non-zero. We approximate by re-checking: a genuine empty user PATH
+  // is rare but legal; prefer to attempt the write (idempotent + re-verified).
+
+  const entries = userPath.split(';').map((e) => e.trim()).filter(Boolean);
+  if (entries.some((e) => normalizeEntry(e) === normalizeEntry(prefix))) {
+    return false; // already present — idempotent no-op
+  }
+
+  const updated = userPath === '' || userPath.endsWith(';')
+    ? `${userPath}${prefix}`
+    : `${userPath};${prefix}`;
+  powershell(
+    `[Environment]::SetEnvironmentVariable('Path', ${JSON.stringify(updated)}, 'User')`,
+  );
+
+  // Verify by re-reading: SetEnvironmentVariable returns no stdout, so the
+  // only robust signal that the write stuck is observing the prefix in place.
+  const reread = powershell(
+    "[Environment]::GetEnvironmentVariable('Path','User')",
+  );
+  const rereadEntries = reread.split(';').map((e) => e.trim()).filter(Boolean);
+  return rereadEntries.some((e) => normalizeEntry(e) === normalizeEntry(prefix));
+}