@lumpcode/core 0.0.11 → 0.0.13

package/dist/helpers/executeStepsForContextList/main.d.ts

@@ -6,7 +6,7 @@ export type ExecuteStepsForContextListParams = Required<Pick<RunLumpInput, 'base
 };
 export declare function executeStepsForContextList({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommandFn, gitCommitCommandFn, gitPushCommandFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, logger: loggerInput, }: ExecuteStepsForContextListParams): Promise<Failure<{
     message: string;
-}> | import("../../types").Success<{
+}> | import("../..").Success<{
     branchName: string;
     contextNames: string[];
     contextRunStateList: ContextRunState[];

package/dist/helpers/getCodeBasePaths/main.d.ts

@@ -2,7 +2,7 @@ import { CodeBasePath, Logger } from '../../types';
 export declare function getCodeBasePaths({ cwd, logger: loggerInput, }: {
     cwd: string;
     logger?: Logger;
-}): Promise<import("../../types").Failure<{
+}): Promise<import("../..").Failure<{
     message: string;
-}> | import("../../types").Success<CodeBasePath[]>>;
+}> | import("../..").Success<CodeBasePath[]>>;
 //# sourceMappingURL=main.d.ts.map

package/dist/helpers/getCodeBasePaths/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/getCodeBasePaths/main.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAEnD,wBAAsB,gBAAgB,CAAC,EACnC,GAAG,EACH,MAAM,EAAE,WAAW,GACtB,EAAE;IACC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;;oDAoBA"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/getCodeBasePaths/main.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAEnD,wBAAsB,gBAAgB,CAAC,EACnC,GAAG,EACH,MAAM,EAAE,WAAW,GACtB,EAAE;IACC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;;8CAoBA"}

package/dist/helpers/getToDoContextList/main.d.ts

@@ -7,7 +7,7 @@ export declare function getToDoContextList(params: {
     projectRoot: string;
     baseBranch: string;
     logger?: Logger;
-}): Promise<import("../../types").Failure<{
+}): Promise<import("../..").Failure<{
     message: string;
-}> | import("../../types").Success<import("../../types").Context<Record<string, string | number | boolean>>[]>>;
+}> | import("../..").Success<import("../..").Context<Record<string, string | number | boolean>>[]>>;
 //# sourceMappingURL=main.d.ts.map

package/dist/helpers/getToDoContextList/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/getToDoContextList/main.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGpE,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC7C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,aAAa,EAAE,aAAa,CAAC;IAC7B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;;gHA8DA"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/helpers/getToDoContextList/main.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGpE,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC7C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,aAAa,EAAE,aAAa,CAAC;IAC7B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;;oGA8DA"}

package/dist/index.cjs

@@ -86,6 +86,10 @@ const DEFAULT_WINDOWS_PATHEXT = [
     '.WSH',
     '.MSC',
 ];
+/** Matches a quoted script path using %dp0% / %~dp0 relative to a Windows .cmd shim. */
+const WINDOWS_DP0_SCRIPT_RE = /"(?:%dp0%|%~dp0)\\?((?:[^"\r\n])+?\.(?:js|mjs|cjs))"/i;
+/** Absolute Windows path to a Node script in quotes. */
+const WINDOWS_ABS_SCRIPT_RE = /"([A-Za-z]:\\[^"\r\n]+\.(?:js|mjs|cjs))"/i;
 function windowsPathext() {
     const fromEnv = process.env.PATHEXT?.split(';').map((entry) => entry.trim()).filter(Boolean);
     return fromEnv?.length ? fromEnv : DEFAULT_WINDOWS_PATHEXT;
@@ -151,9 +155,83 @@ function wrapWindowsCmdShim(resolvedPath, args) {
         args: ['/d', '/s', '/c', resolvedPath, ...args],
     };
 }
+function resolveWindowsJsPathFromShim(shimDir, relativeOrAbsolute) {
+    if (/^[A-Za-z]:[\\/]/.test(relativeOrAbsolute)) {
+        return path__namespace.resolve(relativeOrAbsolute);
+    }
+    // Normalize Windows separators so stubbed-win32 tests on POSIX still resolve.
+    const parts = relativeOrAbsolute.replace(/^[\\/]+/, '').split(/[/\\]+/).filter(Boolean);
+    return path__namespace.resolve(shimDir, ...parts);
+}
+/**
+ * Prefer a real Node binary — never a .cmd/.bat shim (those reintroduce cmd.exe),
+ * and never the host SEA/`lumpcode` binary via process.execPath.
+ * Returns bare `"node"` as last resort so spawn fails with ENOENT instead of
+ * silently falling back to cmd.exe after a Node entry was identified.
+ */
+function resolveNodeExecutable(preferredDir) {
+    if (preferredDir != null) {
+        const bundledNode = path__namespace.join(preferredDir, 'node.exe');
+        if (fileExists(bundledNode)) {
+            return bundledNode;
+        }
+    }
+    for (const name of ['node.exe', 'node']) {
+        const found = resolveOnPath(name);
+        if (!found)
+            continue;
+        const ext = path__namespace.extname(found).toLowerCase();
+        if (ext === '.cmd' || ext === '.bat')
+            continue;
+        return found;
+    }
+    const base = path__namespace.basename(process.execPath).toLowerCase();
+    if (base === 'node' || base === 'node.exe') {
+        return process.execPath;
+    }
+    return 'node';
+}
+/**
+ * Parse an npm/yarn-style Windows `.cmd` shim to `node <script.js>`.
+ * Returns null only when the file is not a recognizable Node cmd-shim
+ * (caller may wrap with cmd.exe). Once a script path is found, never falls
+ * back to cmd.exe — missing Node uses bare `"node"` for a clear spawn failure.
+ */
+function tryUnwrapWindowsNpmCmdShim(cmdPath) {
+    let body;
+    try {
+        body = fs__namespace.readFileSync(cmdPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const shimDir = path__namespace.dirname(cmdPath);
+    const lines = body.split(/\r?\n/);
+    // Windows npm-cmd-shim ends with `%*` pass-through; prefer that line for the script path.
+    const passThroughLine = [...lines].reverse().find((line) => /%\*\s*$/.test(line));
+    const searchOrder = passThroughLine != null ? [passThroughLine, body] : [body];
+    for (const searchIn of searchOrder) {
+        const dp0Match = searchIn.match(WINDOWS_DP0_SCRIPT_RE);
+        if (dp0Match?.[1]) {
+            const candidate = resolveWindowsJsPathFromShim(shimDir, dp0Match[1]);
+            if (fileExists(candidate)) {
+                return { scriptPath: candidate };
+            }
+        }
+        const absMatch = searchIn.match(WINDOWS_ABS_SCRIPT_RE);
+        if (absMatch?.[1] && fileExists(absMatch[1])) {
+            return { scriptPath: absMatch[1] };
+        }
+    }
+    return null;
+}
 /**
  * Resolves bare executable names on Windows so npm-style `.cmd` shims and
  * extensionless Node entrypoints work with `child_process.spawn` (no shell).
+ *
+ * For Node agent CLIs installed via npm (copilot.cmd, cursor-agent.cmd, …),
+ * unwraps the shim to `node <entry.js> …args` so prompt argv is not mangled by
+ * cmd.exe / `%*`. Unrecognized `.cmd`/`.bat` files still wrap through cmd.exe.
  */
 function resolveSpawnExecutable(executable, args) {
     if (process.platform !== 'win32') {
@@ -174,17 +252,52 @@ function resolveSpawnExecutable(executable, args) {
     }
     const ext = path__namespace.extname(resolved).toLowerCase();
     if (ext === '.cmd' || ext === '.bat') {
+        const unwrapped = tryUnwrapWindowsNpmCmdShim(resolved);
+        if (unwrapped != null) {
+            return {
+                executable: resolveNodeExecutable(path__namespace.dirname(resolved)),
+                args: [unwrapped.scriptPath, ...args],
+            };
+        }
         return wrapWindowsCmdShim(resolved, args);
     }
     if (isNodeScript(resolved)) {
         return {
-            executable: process.execPath,
+            executable: resolveNodeExecutable(path__namespace.dirname(resolved)),
             args: [resolved, ...args],
         };
     }
     return { executable: resolved, args };
 }
 
+/**
+ * Minimal Windows npm-cmd-shim `.cmd` body (modern `"%_prog%"` + `"%dp0%\\…\\.js" %*` form).
+ * Shared by core spawn tests and CLI e2e path-agent install — do not duplicate.
+ */
+function windowsNpmCmdShimBody(relativeJsFromShimDir) {
+    const target = relativeJsFromShimDir.replace(/\//g, '\\');
+    return [
+        '@ECHO off',
+        'GOTO start',
+        ':find_dp0',
+        'SET dp0=%~dp0',
+        'EXIT /b',
+        ':start',
+        'SETLOCAL',
+        'CALL :find_dp0',
+        '',
+        'IF EXIST "%dp0%\\node.exe" (',
+        '  SET "_prog=%dp0%\\node.exe"',
+        ') ELSE (',
+        '  SET "_prog=node"',
+        '  SET PATHEXT=%PATHEXT:;.JS;=;%',
+        ')',
+        '',
+        `endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & set PATHEXT=%PATHEXT:;.JS;=;% & "%_prog%"  "%dp0%\\${target}" %*`,
+        '',
+    ].join('\r\n');
+}
+
 function formatMessage(prefix, message) {
     if (!prefix)
         return message;
@@ -3165,6 +3278,38 @@ async function pathExists(filePath) {
     }
 }
 
+/** Strip terminal ANSI escapes and other C0 controls js-yaml rejects in literal blocks. */
+function sanitizeHistoryText(value) {
+    return value
+        .replace(/\x1b\[[0-9;]*[A-Za-z]/g, '')
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '');
+}
+function parseHistoryYamlContent(content) {
+    const parsed = load(content, { schema: YAML11_SCHEMA });
+    if (!Array.isArray(parsed)) {
+        throw new Error('History file must contain a YAML sequence');
+    }
+    return parsed;
+}
+function tryParseHistoryContent(content) {
+    try {
+        return parseHistoryYamlContent(content);
+    }
+    catch (firstError) {
+        const sanitized = sanitizeHistoryText(content);
+        if (sanitized === content) {
+            throw firstError;
+        }
+        return parseHistoryYamlContent(sanitized);
+    }
+}
+function sanitizeHistoryEntry(entry) {
+    return {
+        ...entry,
+        prompt: sanitizeHistoryText(entry.prompt),
+        commandResult: sanitizeHistoryText(entry.commandResult),
+    };
+}
 function historyFormatFromPath(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     if (ext === '.yaml' || ext === '.yml') {
@@ -3202,7 +3347,8 @@ function dumpHistoryEntries(entries) {
     if (entries.length === 0) {
         return '[]\n';
     }
-    return dump(entries, {
+    const sanitizedEntries = entries.map(sanitizeHistoryEntry);
+    return dump(sanitizedEntries, {
         schema: YAML11_SCHEMA,
         lineWidth: 0,
         noRefs: true,
@@ -3220,11 +3366,7 @@ async function readHistoryFile({ filePath, }) {
     }
     try {
         const content = await fs$1.readFile(filePath, 'utf-8');
-        const parsed = load(content, { schema: YAML11_SCHEMA });
-        if (!Array.isArray(parsed)) {
-            return failure(`History file ${filePath} must contain a YAML sequence`);
-        }
-        return success(parsed);
+        return success(tryParseHistoryContent(content));
     }
     catch (error) {
         const detail = error instanceof Error ? error.message : String(error);
@@ -3264,7 +3406,7 @@ async function appendHistoryEntry({ filePath, entry, }) {
         await fs$1.mkdir(path.dirname(filePath), { recursive: true });
         entries = [];
     }
-    entries.push(entry);
+    entries.push(sanitizeHistoryEntry(entry));
     return writeHistoryFile({ filePath, entries });
 }
 
@@ -3977,5 +4119,6 @@ exports.set = set;
 exports.shellSingleQuote = shellSingleQuote;
 exports.success = success;
 exports.validateContextListNames = validateContextListNames;
+exports.windowsNpmCmdShimBody = windowsNpmCmdShimBody;
 exports.writeHistoryFile = writeHistoryFile;
 //# sourceMappingURL=index.cjs.map