poe-code 3.0.271 → 3.0.272

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.271",
+  "version": "3.0.272",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "type": "module",
   "main": "./dist/index.js",

package/packages/agent-gaslight/dist/ingest.js

@@ -50,10 +50,28 @@ function sanitizeAgentForFileName(agent) {
 function resolvePath(cwd, filePath) {
     return path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
 }
+function requireNonEmptyString(value, label) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${label} must be a non-empty string.`);
+    }
+    return trimmed;
+}
+function resolveOptionalNonEmptyString(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${label} must be a non-empty string when provided.`);
+    }
+    return trimmed;
+}
 async function resolveOutputPath(fs, cwd, analysisAgent, outputPath) {
-    if (outputPath) {
-        const absolutePath = resolvePath(cwd, outputPath);
-        return { absolutePath, resultPath: outputPath };
+    const normalizedOutputPath = resolveOptionalNonEmptyString(outputPath, "outputPath");
+    if (normalizedOutputPath) {
+        const absolutePath = resolvePath(cwd, normalizedOutputPath);
+        return { absolutePath, resultPath: normalizedOutputPath };
     }
     const configDirectory = path.join(cwd, ".poe-code");
     const defaultPath = path.join(configDirectory, "gaslight.yaml");
@@ -77,6 +95,9 @@ function resolveSince(value) {
         return milliseconds === null ? undefined : new Date(Date.now() - milliseconds);
     }
     if (value instanceof Date) {
+        if (!Number.isFinite(value.getTime())) {
+            throw new Error(`Invalid since date "${String(value)}".`);
+        }
         return value;
     }
     const milliseconds = parseDuration(value);
@@ -93,6 +114,13 @@ async function resolveDataPath(cwd, keepDataPath) {
     const resultPath = path.join(".poe-code", "ingest", `human-prompts-${process.pid}-${Date.now()}-${process.hrtime.bigint()}.md`);
     return { absolutePath: path.join(cwd, resultPath), resultPath };
 }
+function resolveLimit(value) {
+    const limit = value ?? 200;
+    if (!Number.isInteger(limit) || limit <= 0) {
+        throw new Error("limit must be a positive integer.");
+    }
+    return limit;
+}
 function buildAnalysisPrompt(dataPath) {
     return [
         "Read this curated Markdown file of human prompts from coding-agent traces:",
@@ -111,7 +139,7 @@ function buildAnalysisPrompt(dataPath) {
         "- Do not put review questions, validation checks, cleanup checks, commit checks, or release checks in `prompt`; those belong in `followups`.",
         "- Prefer concise followups that generalize across tasks.",
         "- Do not produce two followups for the same workflow step; merge semantic duplicates.",
-        "- Repeated short prompts like \"commit\" are evidence for one well-placed workflow check, not multiple followups.",
+        '- Repeated short prompts like "commit" are evidence for one well-placed workflow check, not multiple followups.',
         "- Order followups as a useful review sequence: quality, verification, cleanup, then commit or release when supported by the evidence.",
         "- Do not include project secrets, file paths, names, tokens, or one-off task details.",
         "- Preserve the user's direct style when it is reusable.",
@@ -148,8 +176,7 @@ function stripIdeSelection(value) {
         if (endIndex === -1) {
             return stripped;
         }
-        stripped =
-            stripped.slice(0, startIndex) + stripped.slice(endIndex + closeTag.length);
+        stripped = stripped.slice(0, startIndex) + stripped.slice(endIndex + closeTag.length);
     }
 }
 function normalizePromptText(value, cwd, homeDir) {
@@ -234,12 +261,7 @@ function buildRepeatedShortPromptSection(records, cwd, homeDir) {
         .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
         .slice(0, 12);
     if (repeated.length === 0) {
-        return [
-            "## Repeated short prompts",
-            "",
-            "No repeated short prompts were found.",
-            ""
-        ];
+        return ["## Repeated short prompts", "", "No repeated short prompts were found.", ""];
     }
     return [
         "## Repeated short prompts",
@@ -418,7 +440,10 @@ function extractGeneratedConfigContent(stdout) {
 async function writeGeneratedConfig(fs, content, absoluteOutputPath) {
     const yaml = extractYamlCandidate(extractGeneratedConfigContent(content));
     parseGaslightConfig(yaml, "generated gaslight config", { rejectExtraKeys: true });
-    await fs.mkdir(path.dirname(absoluteOutputPath), { recursive: true });
+    const outputDirectory = path.dirname(absoluteOutputPath);
+    await assertNotSymlink(fs, outputDirectory, "Output directory");
+    await fs.mkdir(outputDirectory, { recursive: true });
+    await assertNotSymlink(fs, outputDirectory, "Output directory");
     const temporaryPath = `${absoluteOutputPath}.tmp-${process.pid}-${Date.now()}`;
     await fs.writeFile(temporaryPath, `${yaml}\n`, { encoding: "utf8" });
     if (fs.rename) {
@@ -427,19 +452,40 @@ async function writeGeneratedConfig(fs, content, absoluteOutputPath) {
     }
     await fs.writeFile(absoluteOutputPath, `${yaml}\n`, { encoding: "utf8" });
 }
+async function assertNotSymlink(fs, targetPath, label) {
+    if (!fs.lstat) {
+        return;
+    }
+    try {
+        const stats = await fs.lstat(targetPath);
+        if (stats.isSymbolicLink()) {
+            throw new Error(`${label} cannot be a symbolic link: ${targetPath}`);
+        }
+    }
+    catch (error) {
+        if (isMissingFile(error)) {
+            return;
+        }
+        throw error;
+    }
+}
 export async function ingestGaslight(options) {
     const cwd = options.cwd ?? process.cwd();
     const homeDir = options.homeDir ?? os.homedir();
     const fs = (options.fs ?? nodeFs);
     const spawn = options.spawn ?? defaultSpawn;
     const collectHumanPrompts = options.collectHumanPrompts ?? collectHumanPromptsWithStats;
+    const analysisAgent = requireNonEmptyString(options.analysisAgent, "analysisAgent");
+    const model = resolveOptionalNonEmptyString(options.model, "model");
+    const limit = resolveLimit(options.limit);
+    const outputPathOption = resolveOptionalNonEmptyString(options.outputPath, "outputPath");
     const since = resolveSince(options.since);
     const collection = await collectHumanPrompts({
         sources: options.sources,
         cwd,
         homeDir,
         since,
-        limit: options.limit ?? 200,
+        limit,
         allWorkspaces: options.allWorkspaces,
         fs
     });
@@ -458,20 +504,20 @@ export async function ingestGaslight(options) {
     try {
         options.onEvent?.({
             type: "analysis.started",
-            agent: options.analysisAgent,
+            agent: analysisAgent,
             dataPath: dataPath.absolutePath
         });
-        const result = await spawn(options.analysisAgent, {
+        const result = await spawn(analysisAgent, {
             prompt: buildAnalysisPrompt(dataPath.absolutePath),
             cwd,
             mode: "read",
-            ...(options.model ? { model: options.model } : {})
+            ...(model ? { model } : {})
         });
         if (result.exitCode !== 0) {
             const message = result.stderr.trim() || result.stdout.trim() || `exit code ${result.exitCode}`;
             throw new Error(`Gaslight ingest analysis failed: ${message}`);
         }
-        const outputPath = await resolveOutputPath(fs, cwd, options.analysisAgent, options.outputPath);
+        const outputPath = await resolveOutputPath(fs, cwd, analysisAgent, outputPathOption);
         await writeGeneratedConfig(fs, result.stdout, outputPath.absolutePath);
         options.onEvent?.({ type: "config.written", path: outputPath.resultPath });
         return {

package/packages/agent-gaslight/dist/run.js

@@ -91,6 +91,23 @@ async function archivePlan(fs, cwd, planPath) {
     }
     return archivedPath;
 }
+function archivePathForPlan(cwd, planPath) {
+    const absolutePath = path.resolve(cwd, planPath);
+    return path.join(path.dirname(absolutePath), "archive", path.basename(absolutePath));
+}
+async function assertArchiveDestinationAvailable(fs, cwd, planPath) {
+    const archivedPath = archivePathForPlan(cwd, planPath);
+    try {
+        await fs.readFile(archivedPath, "utf8");
+        throw new Error(`Archive destination already exists: ${archivedPath}`);
+    }
+    catch (error) {
+        if (!isMissingFile(error)) {
+            throw error;
+        }
+    }
+    await rejectArchiveSymlink(fs, path.dirname(archivedPath));
+}
 function validateInlineConfig(prompt, followups) {
     if ((prompt === undefined) !== (followups === undefined)) {
         throw new Error("prompt and followups must be provided together.");
@@ -103,6 +120,23 @@ function validateInlineConfig(prompt, followups) {
         throw new Error("followups must be a non-empty array of non-empty strings.");
     }
 }
+function requireNonEmptyString(value, label) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${label} must be a non-empty string.`);
+    }
+    return trimmed;
+}
+function resolveModel(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error("model must be a non-empty string when provided.");
+    }
+    return trimmed;
+}
 function resolvePlanPaths(options) {
     if (options.planPaths.length === 0) {
         throw new Error("Provide at least one plan path.");
@@ -112,17 +146,30 @@ function resolvePlanPaths(options) {
             throw new Error("plan paths must be non-empty strings.");
         }
     }
-    return options.planPaths.map((planPath) => planPath.trim());
+    const planPaths = options.planPaths.map((planPath) => planPath.trim());
+    const seen = new Map();
+    for (const planPath of planPaths) {
+        const resolvedPath = path.resolve(options.cwd ?? process.cwd(), planPath);
+        const duplicate = seen.get(resolvedPath);
+        if (duplicate !== undefined) {
+            throw new Error(`Duplicate plan path: ${duplicate}`);
+        }
+        seen.set(resolvedPath, planPath);
+    }
+    return planPaths;
 }
 export async function runGaslight(options) {
     const cwd = options.cwd ?? process.cwd();
     const homeDir = options.homeDir ?? os.homedir();
     const fs = (options.fs ?? nodeFs);
     const spawn = options.spawn ?? defaultSpawn;
+    const agent = requireNonEmptyString(options.agent, "agent");
+    const model = resolveModel(options.model);
     validateInlineConfig(options.prompt, options.followups);
     const planPaths = resolvePlanPaths(options);
     for (const planPath of planPaths) {
         await requirePlan(fs, cwd, planPath);
+        await assertArchiveDestinationAvailable(fs, cwd, planPath);
     }
     const config = options.prompt !== undefined && options.followups !== undefined
         ? { prompt: options.prompt.trim(), followups: options.followups.map((value) => value.trim()) }
@@ -146,11 +193,11 @@ export async function runGaslight(options) {
                 planIndex: planIndex + 1,
                 totalPlans: planPaths.length
             });
-            const result = await spawn(options.agent, {
+            const result = await spawn(agent, {
                 prompt,
                 cwd,
                 mode: options.mode ?? "edit",
-                ...(options.model ? { model: options.model } : {}),
+                ...(model ? { model } : {}),
                 ...(resumeThreadId ? { resumeThreadId } : {}),
                 ...(options.signal ? { signal: options.signal } : {})
             });