@howaboua/pi-codex-conversion 1.0.8 → 1.0.9-dev.0

package/README.md

@@ -80,6 +80,43 @@ Alternative Git install:
 pi install git:github.com/IgorWarzocha/pi-codex-conversion
 ```
 
+## Publishing
+
+This package is already configured for public npm publishes via:
+
+- `publishConfig.access = "public"`
+- `prepublishOnly` / `prepack` checks
+
+Useful commands:
+
+```bash
+npm run publish:dry-run
+npm run publish:dev
+npm run release:dev
+```
+
+What they do:
+
+- `npm run publish:dry-run` — inspect what would be published
+- `npm run publish:dev` — publish the current version under the `dev` dist-tag
+- `npm run release:dev` — bump the package to the next `-dev.N` prerelease and publish it under the `dev` dist-tag
+
+Typical flow:
+
+```bash
+npm login
+npm run publish:dry-run
+npm run release:dev
+```
+
+For modern npm auth, just run `npm login` and complete the browser flow when prompted.
+
+After publishing, install the dev build with:
+
+```bash
+pi install npm:@howaboua/pi-codex-conversion@dev
+```
+
 ## Prompt behavior
 
 The adapter does not build a standalone replacement prompt anymore. Instead it:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.0.8",
+  "version": "1.0.9-dev.0",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {
@@ -41,6 +41,9 @@
     "typecheck": "tsc -p tsconfig.json",
     "test": "tsx --test tests/**/*.test.ts",
     "check": "npm run typecheck && npm run test",
+    "publish:dry-run": "npm publish --dry-run",
+    "publish:dev": "npm publish --tag dev",
+    "release:dev": "npm version prerelease --preid dev && npm publish --tag dev",
     "prepack": "npm run check",
     "prepublishOnly": "npm run check"
   },
@@ -57,6 +60,8 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "node-pty": "^1.1.0"
+    "node-pty": "^1.1.0",
+    "tree-sitter-bash": "^0.25.1",
+    "web-tree-sitter": "^0.26.7"
   }
 }

package/src/adapter/runtime-shell.ts

@@ -0,0 +1,13 @@
+export const CODEX_FALLBACK_SHELL = "/bin/bash";
+
+export function isFishShell(shell: string | undefined): boolean {
+	const name = shell?.replace(/\\/g, "/").split("/").pop()?.toLowerCase();
+	return name === "fish";
+}
+
+export function getCodexRuntimeShell(shell: string | undefined): string {
+	if (!shell) {
+		return CODEX_FALLBACK_SHELL;
+	}
+	return isFishShell(shell) ? CODEX_FALLBACK_SHELL : shell;
+}

package/src/index.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { getCodexRuntimeShell } from "./adapter/runtime-shell.ts";
 import { CORE_ADAPTER_TOOL_NAMES, DEFAULT_TOOL_NAMES, STATUS_KEY, STATUS_TEXT, VIEW_IMAGE_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from "./adapter/tool-set.ts";
 import { registerApplyPatchTool } from "./tools/apply-patch-tool.ts";
 import { isCodexLikeContext, isOpenAICodexContext } from "./adapter/codex-model.ts";
@@ -81,7 +82,7 @@ export default function codexConversion(pi: ExtensionAPI) {
 		return {
 			systemPrompt: buildCodexSystemPrompt(event.systemPrompt, {
 				skills: state.promptSkills,
-				shell: process.env.SHELL || "/bin/bash",
+				shell: getCodexRuntimeShell(process.env.SHELL),
 			}),
 		};
 	});

package/src/prompt/build-system-prompt.ts

@@ -21,9 +21,12 @@ function insertBeforeTrailingContext(prompt: string, section: string): string {
 }
 
 function injectShell(prompt: string, shell?: string): string {
-	if (!shell || /\nCurrent shell:/.test(prompt)) {
+	if (!shell) {
 		return prompt;
 	}
+	if (/\nCurrent shell:/.test(prompt)) {
+		return prompt.replace(/(^Current shell:) .*$/m, `$1 ${shell}`);
+	}
 	return insertBeforeTrailingContext(prompt, `Current shell: ${shell}`);
 }
 

package/src/shell/bash.ts

@@ -0,0 +1,261 @@
+import { createRequire } from "node:module";
+import { Language, Parser, type Node, type Tree } from "web-tree-sitter";
+
+const require = createRequire(import.meta.url);
+
+const parser = await createBashParser();
+
+export function hasBashAstSupport(): boolean {
+	return parser !== undefined;
+}
+
+export function extractBashCommand(command: string[]): [shell: string, script: string] | undefined {
+	if (command.length !== 3) return undefined;
+	const [shell, flag, script] = command;
+	if (flag !== "-lc" && flag !== "-c") return undefined;
+	const shellName = shell.replace(/\\/g, "/").split("/").pop()?.toLowerCase();
+	if (shellName !== "bash" && shellName !== "zsh" && shellName !== "sh") return undefined;
+	return [shell, script];
+}
+
+export function tryParseShell(shellLcArg: string): Tree | undefined {
+	return parser?.parse(shellLcArg) ?? undefined;
+}
+
+export function tryParseWordOnlyCommandsSequence(tree: Tree, src: string): string[][] | undefined {
+	if (tree.rootNode.hasError) {
+		return undefined;
+	}
+
+	const allowedKinds = new Set([
+		"program",
+		"list",
+		"pipeline",
+		"command",
+		"command_name",
+		"word",
+		"string",
+		"string_content",
+		"raw_string",
+		"number",
+		"concatenation",
+	]);
+	const allowedPunctuation = new Set(["&&", "||", ";", "|", '"', "'"]);
+
+	const commandNodes: Node[] = [];
+	const stack: Node[] = [tree.rootNode];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (!node) continue;
+		if (node.isNamed) {
+			if (!allowedKinds.has(node.type)) return undefined;
+			if (node.type === "command") commandNodes.push(node);
+		} else {
+			if ([...node.type].some((char) => "&;|".includes(char)) && !allowedPunctuation.has(node.type)) {
+				return undefined;
+			}
+			if (!allowedPunctuation.has(node.type) && node.type.trim().length > 0) {
+				return undefined;
+			}
+		}
+		for (const child of node.children) {
+			stack.push(child);
+		}
+	}
+
+	commandNodes.sort((left, right) => left.startIndex - right.startIndex);
+	const commands: string[][] = [];
+	for (const node of commandNodes) {
+		const parsed = parsePlainCommandFromNode(node, src);
+		if (!parsed) return undefined;
+		commands.push(parsed);
+	}
+	return commands;
+}
+
+export function parseShellLcPlainCommands(command: string[]): string[][] | undefined {
+	const bash = extractBashCommand(command);
+	if (!bash) return undefined;
+	const [, script] = bash;
+	const tree = tryParseShell(script);
+	if (!tree) return undefined;
+	return tryParseWordOnlyCommandsSequence(tree, script);
+}
+
+export function parseShellLcSingleCommandPrefix(command: string[]): string[] | undefined {
+	const bash = extractBashCommand(command);
+	if (!bash) return undefined;
+	const [, script] = bash;
+	const tree = tryParseShell(script);
+	if (!tree || tree.rootNode.hasError) return undefined;
+	if (!hasNamedDescendantKind(tree.rootNode, "heredoc_redirect")) return undefined;
+
+	const commandNode = findSingleCommandNode(tree.rootNode);
+	if (!commandNode) return undefined;
+	return parseHeredocCommandWords(commandNode, script);
+}
+
+async function createBashParser(): Promise<Parser | undefined> {
+	try {
+		await Parser.init();
+		const language = await Language.load(require.resolve("tree-sitter-bash/tree-sitter-bash.wasm"));
+		const parser = new Parser();
+		parser.setLanguage(language);
+		return parser;
+	} catch {
+		return undefined;
+	}
+}
+
+function parsePlainCommandFromNode(command: Node, src: string): string[] | undefined {
+	if (command.type !== "command") return undefined;
+
+	const words: string[] = [];
+	for (const child of command.namedChildren) {
+		switch (child.type) {
+			case "command_name": {
+				const wordNode = child.namedChild(0);
+				if (!wordNode || wordNode.type !== "word") return undefined;
+				words.push(textOf(wordNode, src));
+				break;
+			}
+			case "word":
+			case "number":
+				words.push(textOf(child, src));
+				break;
+			case "string": {
+				const parsed = parseDoubleQuotedString(child, src);
+				if (parsed === undefined) return undefined;
+				words.push(parsed);
+				break;
+			}
+			case "raw_string": {
+				const parsed = parseRawString(child, src);
+				if (parsed === undefined) return undefined;
+				words.push(parsed);
+				break;
+			}
+			case "concatenation": {
+				let concatenated = "";
+				for (const part of child.namedChildren) {
+					switch (part.type) {
+						case "word":
+						case "number":
+							concatenated += textOf(part, src);
+							break;
+						case "string": {
+							const parsed = parseDoubleQuotedString(part, src);
+							if (parsed === undefined) return undefined;
+							concatenated += parsed;
+							break;
+						}
+						case "raw_string": {
+							const parsed = parseRawString(part, src);
+							if (parsed === undefined) return undefined;
+							concatenated += parsed;
+							break;
+						}
+						default:
+							return undefined;
+					}
+				}
+				if (concatenated.length === 0) return undefined;
+				words.push(concatenated);
+				break;
+			}
+			default:
+				return undefined;
+		}
+	}
+
+	return words;
+}
+
+function parseHeredocCommandWords(command: Node, src: string): string[] | undefined {
+	if (command.type !== "command") return undefined;
+	const words: string[] = [];
+	for (const child of command.namedChildren) {
+		switch (child.type) {
+			case "command_name": {
+				const wordNode = child.namedChild(0);
+				if (!wordNode || !(wordNode.type === "word" || wordNode.type === "number") || !isLiteralWordOrNumber(wordNode)) return undefined;
+				words.push(textOf(wordNode, src));
+				break;
+			}
+			case "word":
+			case "number":
+				if (!isLiteralWordOrNumber(child)) return undefined;
+				words.push(textOf(child, src));
+				break;
+			case "variable_assignment":
+			case "comment":
+				break;
+			case "heredoc_body":
+			case "simple_heredoc_body":
+			case "heredoc_redirect":
+			case "herestring_redirect":
+			case "file_redirect":
+			case "redirected_statement":
+				break;
+			default:
+				return undefined;
+		}
+	}
+	return words.length > 0 ? words : undefined;
+}
+
+function isLiteralWordOrNumber(node: Node): boolean {
+	if (node.type !== "word" && node.type !== "number") return false;
+	return node.namedChildren.length === 0;
+}
+
+function findSingleCommandNode(root: Node): Node | undefined {
+	const stack: Node[] = [root];
+	let singleCommand: Node | undefined;
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (!node) continue;
+		if (node.type === "command") {
+			if (singleCommand) return undefined;
+			singleCommand = node;
+		}
+		for (const child of node.namedChildren) {
+			stack.push(child);
+		}
+	}
+	return singleCommand;
+}
+
+function hasNamedDescendantKind(node: Node, kind: string): boolean {
+	const stack: Node[] = [node];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current) continue;
+		if (current.type === kind) return true;
+		for (const child of current.namedChildren) {
+			stack.push(child);
+		}
+	}
+	return false;
+}
+
+function parseDoubleQuotedString(node: Node, src: string): string | undefined {
+	if (node.type !== "string") return undefined;
+	for (const part of node.namedChildren) {
+		if (part.type !== "string_content") return undefined;
+	}
+	const raw = textOf(node, src);
+	if (!raw.startsWith('"') || !raw.endsWith('"')) return undefined;
+	return raw.slice(1, -1);
+}
+
+function parseRawString(node: Node, src: string): string | undefined {
+	if (node.type !== "raw_string") return undefined;
+	const raw = textOf(node, src);
+	if (!raw.startsWith("'") || !raw.endsWith("'")) return undefined;
+	return raw.slice(1, -1);
+}
+
+function textOf(node: Node, _src: string): string {
+	return node.text;
+}