pi-ui-extend 0.1.8 → 0.1.9

package/external/pi-tools-suite/src/default-pi-tools-suite-config.ts

@@ -8,6 +8,7 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = `{
     // "lsp",
     // "repo-discovery",
     // "antigravity-auth",
+    // "opencode-import",
     // "todo",
     // "model-tools",
     // "usage",
@@ -358,6 +359,276 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = `{
         "prompt": "Commit all changes"
       }
     }
+  },
+
+  // LSP language servers. TypeScript/JavaScript is enabled by default;
+  // uncomment additional server blocks after installing their binaries.
+  "lsp": {
+    "servers": [
+      {
+        "id": "typescript",
+        "include": [
+          "**/*.ts",
+          "**/*.tsx",
+          "**/*.js",
+          "**/*.jsx",
+          "**/*.mjs"
+        ],
+        "exclude": [
+          "**/node_modules/**",
+          "**/.next/**"
+        ],
+        "rootMarkers": [
+          "tsconfig.json",
+          "package.json"
+        ],
+        "bin": "typescript-language-server",
+        "args": [
+          "--stdio"
+        ],
+        "languageIdByExtension": {
+          ".ts": "typescript",
+          ".tsx": "typescriptreact",
+          ".js": "javascript",
+          ".jsx": "javascriptreact",
+          ".mjs": "javascript"
+        }
+      }
+      // ,
+      // {
+      //   "id": "python",
+      //   "include": [
+      //     "**/*.py",
+      //     "**/*.pyi"
+      //   ],
+      //   "exclude": [
+      //     "**/.git/**",
+      //     "**/node_modules/**",
+      //     "**/__pycache__/**",
+      //     "**/.venv/**",
+      //     "**/venv/**",
+      //     "**/.tox/**",
+      //     "**/.mypy_cache/**",
+      //     "**/.ruff_cache/**"
+      //   ],
+      //   "rootMarkers": [
+      //     "pyproject.toml",
+      //     "setup.py",
+      //     "setup.cfg",
+      //     "requirements.txt",
+      //     "Pipfile",
+      //     "poetry.lock",
+      //     ".git"
+      //   ],
+      //   "bin": "pylsp",
+      //   "args": [],
+      //   "languageIdByExtension": {
+      //     ".py": "python",
+      //     ".pyi": "python"
+      //   }
+      // }
+      // ,
+      // {
+      //   "id": "csharp",
+      //   "include": [
+      //     "**/*.cs",
+      //     "**/*.csx"
+      //   ],
+      //   "exclude": [
+      //     "**/.git/**",
+      //     "**/node_modules/**",
+      //     "**/bin/**",
+      //     "**/obj/**",
+      //     "**/.vs/**",
+      //     "**/Library/**",
+      //     "**/Temp/**",
+      //     "**/Logs/**"
+      //   ],
+      //   "rootMarkers": [
+      //     "*.sln",
+      //     "*.csproj",
+      //     "global.json",
+      //     "Directory.Build.props",
+      //     "Directory.Packages.props",
+      //     "Packages/manifest.json",
+      //     "ProjectSettings/ProjectVersion.txt",
+      //     ".git"
+      //   ],
+      //   "bin": "~/.dotnet/tools/roslyn-language-server",
+      //   "args": [
+      //     "--stdio",
+      //     "--autoLoadProjects",
+      //     "--logLevel",
+      //     "Error"
+      //   ],
+      //   "startupTimeoutMs": 30000,
+      //   "diagnosticsWaitMs": 15000,
+      //   "languageIdByExtension": {
+      //     ".cs": "csharp",
+      //     ".csx": "csharp"
+      //   }
+      // }
+      // ,
+      // {
+      //   "id": "gdscript",
+      //   "include": [
+      //     "**/*.gd",
+      //     "**/*.gdshader",
+      //     "**/*.gdshaderinc"
+      //   ],
+      //   "exclude": [
+      //     "**/.git/**",
+      //     "**/node_modules/**",
+      //     "**/.godot/**",
+      //     "**/imported/**"
+      //   ],
+      //   "rootMarkers": [
+      //     "project.godot"
+      //   ],
+      //   "bin": "bash",
+      //   "args": [
+      //     "-lc",
+      //     "port=$(python3 -c 'import socket; s=socket.socket(); s.bind((\\"127.0.0.1\\", 0)); print(s.getsockname()[1]); s.close()'); log=\\"\${TMPDIR:-/tmp}/pi-godot-lsp-\${1##*/}-\${port}.log\\"; godot --headless --editor --path \\"$1\\" --lsp-port \\"$port\\" >\\"$log\\" 2>&1 & pid=$!; cleanup(){ kill \\"$pid\\" 2>/dev/null || true; wait \\"$pid\\" 2>/dev/null || true; }; trap 'cleanup; exit 143' TERM INT HUP; trap cleanup EXIT; for i in $(seq 1 80); do nc -z 127.0.0.1 \\"$port\\" 2>/dev/null && break; if ! kill -0 \\"$pid\\" 2>/dev/null; then cat \\"$log\\" >&2; exit 1; fi; sleep 0.25; done; if ! nc -z 127.0.0.1 \\"$port\\" 2>/dev/null; then echo \\"Godot LSP did not open 127.0.0.1:$port; see $log\\" >&2; exit 1; fi; nc 127.0.0.1 \\"$port\\"; status=$?; exit $status",
+      //     "pi-godot-lsp",
+      //     "{root}"
+      //   ],
+      //   "startupTimeoutMs": 30000,
+      //   "diagnosticsWaitMs": 6000,
+      //   "languageIdByExtension": {
+      //     ".gd": "gdscript",
+      //     ".gdshader": "gdshader",
+      //     ".gdshaderinc": "gdshader"
+      //   }
+      // }
+      // ,
+      // {
+      //   "id": "ruby",
+      //   "include": [
+      //     "**/*.rb",
+      //     "**/*.rake",
+      //     "**/Gemfile",
+      //     "**/Rakefile",
+      //     "**/*.gemspec"
+      //   ],
+      //   "exclude": [
+      //     "**/.git/**",
+      //     "**/node_modules/**",
+      //     "**/vendor/bundle/**",
+      //     "**/.bundle/**",
+      //     "**/tmp/**",
+      //     "**/log/**"
+      //   ],
+      //   "rootMarkers": [
+      //     "Gemfile.lock",
+      //     "*.gemspec",
+      //     "Rakefile",
+      //     ".ruby-version",
+      //     ".git"
+      //   ],
+      //   "bin": "ruby-lsp",
+      //   "args": [],
+      //   "startupTimeoutMs": 60000,
+      //   "diagnosticsWaitMs": 10000,
+      //   "languageIdByExtension": {
+      //     ".rb": "ruby",
+      //     ".rake": "ruby",
+      //     ".gemspec": "ruby"
+      //   }
+      // }
+      // ,
+      // {
+      //   "id": "rust",
+      //   "include": [
+      //     "**/*.rs"
+      //   ],
+      //   "exclude": [
+      //     "**/.git/**",
+      //     "**/node_modules/**",
+      //     "**/target/**"
+      //   ],
+      //   "rootMarkers": [
+      //     "Cargo.toml",
+      //     "rust-project.json",
+      //     ".git"
+      //   ],
+      //   "bin": "rust-analyzer",
+      //   "args": [],
+      //   "startupTimeoutMs": 20000,
+      //   "diagnosticsWaitMs": 8000,
+      //   "languageIdByExtension": {
+      //     ".rs": "rust"
+      //   }
+      // }
+      // ,
+      // {
+      //   "id": "markdown",
+      //   "include": [
+      //     "**/*.md",
+      //     "**/*.markdown",
+      //     "**/*.mdown",
+      //     "**/*.mkd",
+      //     "**/*.mmd",
+      //     "**/*.mermaid"
+      //   ],
+      //   "exclude": [
+      //     "**/.git/**",
+      //     "**/node_modules/**"
+      //   ],
+      //   "rootMarkers": [
+      //     ".git",
+      //     "package.json",
+      //     "README.md"
+      //   ],
+      //   "bin": "vscode-markdown-language-server",
+      //   "args": [
+      //     "--stdio"
+      //   ],
+      //   "startupTimeoutMs": 15000,
+      //   "diagnosticsWaitMs": 5000,
+      //   "languageIdByExtension": {
+      //     ".md": "markdown",
+      //     ".markdown": "markdown",
+      //     ".mdown": "markdown",
+      //     ".mkd": "markdown",
+      //     ".mmd": "markdown",
+      //     ".mermaid": "markdown"
+      //   },
+      //   "initializationOptions": {
+      //     "markdownFileExtensions": [
+      //       "md",
+      //       "markdown",
+      //       "mdown",
+      //       "mkd",
+      //       "mmd",
+      //       "mermaid"
+      //     ]
+      //   },
+      //   "settings": {
+      //     "markdown": {
+      //       "validate": {
+      //         "enabled": true,
+      //         "referenceLinks": {
+      //           "enabled": "error"
+      //         },
+      //         "fragmentLinks": {
+      //           "enabled": "error"
+      //         },
+      //         "fileLinks": {
+      //           "enabled": "error",
+      //           "markdownFragmentLinks": "inherit"
+      //         },
+      //         "unusedLinkDefinitions": {
+      //           "enabled": "hint"
+      //         },
+      //         "duplicateLinkDefinitions": {
+      //           "enabled": "warning"
+      //         },
+      //         "ignoredLinks": []
+      //       }
+      //     }
+      //   }
+      // }
+    ]
   }
 }
 `;

package/external/pi-tools-suite/src/index.ts

@@ -15,6 +15,7 @@ const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
 	{ name: "lsp", load: () => import("./lsp/index") },
 	{ name: "repo-discovery", load: () => import("./repo-discovery/index") },
 	{ name: "antigravity-auth", load: () => import("./antigravity-auth/index") },
+	{ name: "opencode-import", load: () => import("./opencode-import/index") },
 	{ name: "todo", load: () => import("./todo/index") },
 	{ name: "model-tools", load: () => import("./model-tools/index") },
 	{ name: "usage", load: () => import("./usage/index") },

package/external/pi-tools-suite/src/opencode-import/commands.ts

@@ -0,0 +1,86 @@
+import type { OpencodeImportOptions, OpencodeImportResult, OpencodeProviderImportResult } from "./importer";
+
+function tokenizeArgs(args: string): string[] {
+	return args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => part.replace(/^("|')|("|')$/g, "")) ?? [];
+}
+
+export function parseOpencodeImportCommandArgs(args: string): OpencodeImportOptions {
+	const tokens = tokenizeArgs(args);
+	const parsed: OpencodeImportOptions = {};
+	for (let i = 0; i < tokens.length; i += 1) {
+		const token = tokens[i];
+		if (token === "--force" || token === "-f") {
+			parsed.overwrite = true;
+		} else if ((token === "--path" || token === "--opencode-auth-path") && tokens[i + 1]) {
+			parsed.sourcePath = tokens[++i];
+		} else if (token === "--auth-path" && tokens[i + 1]) {
+			parsed.authPath = tokens[++i];
+		} else if (token === "--antigravity-path" && tokens[i + 1]) {
+			parsed.antigravitySourcePath = tokens[++i];
+		} else if (token === "--skip-auth-json") {
+			parsed.skipAuthJson = true;
+		} else if (token === "--skip-antigravity") {
+			parsed.skipAntigravity = true;
+		} else if ((token === "--antigravity-index" || token === "--antigravity-account-index") && tokens[i + 1]) {
+			const index = Number(tokens[++i]);
+			if (Number.isInteger(index)) parsed.antigravityAccountIndex = index;
+		} else if (token === "--antigravity-email" && tokens[i + 1]) {
+			parsed.antigravityEmail = tokens[++i];
+		} else if (!token.startsWith("-") && !parsed.sourcePath) {
+			parsed.sourcePath = token;
+		}
+	}
+	return parsed;
+}
+
+function statusText(result: OpencodeProviderImportResult): string {
+	switch (result.status) {
+		case "imported":
+			return `imported ${result.sourceProvider} → ${result.targetProvider}`;
+		case "already-imported":
+			return `already imported ${result.targetProvider}`;
+		case "auth-exists-use-force":
+			return `skipped ${result.targetProvider}: already exists; use --force`;
+		case "target-set-from-other-source":
+			return `skipped ${result.sourceProvider}: ${result.targetProvider} was already filled from another opencode entry`;
+		case "invalid-source":
+			return `skipped ${result.sourceProvider}: missing usable token/key`;
+		case "source-missing":
+			return `missing ${result.sourceProvider}`;
+	}
+}
+
+function antigravityText(result: OpencodeImportResult): string | undefined {
+	const antigravity = result.antigravity;
+	if (!antigravity) return undefined;
+	const account = antigravity.email ? ` ${antigravity.email}` : "";
+	const position = typeof antigravity.accountIndex === "number" && typeof antigravity.accountCount === "number" ? ` (${antigravity.accountIndex + 1}/${antigravity.accountCount})` : "";
+	if (antigravity.imported) {
+		return `Antigravity: imported${account}${position}${antigravity.overwroteExisting ? " and overwrote existing auth" : ""}`;
+	}
+	if (antigravity.reason === "auth-exists-use-force") return "Antigravity: skipped existing auth; use --force";
+	if (antigravity.reason === "already-imported") return `Antigravity: already imported${account}${position}`;
+	return `Antigravity: skipped (${antigravity.reason ?? "unknown"})`;
+}
+
+export function formatOpencodeImportResult(result: OpencodeImportResult): string {
+	const providerLines = result.providers
+		.filter((provider) => provider.status !== "source-missing")
+		.map((provider) => `- ${provider.label}: ${statusText(provider)}`);
+	const missingCount = result.providers.filter((provider) => provider.status === "source-missing").length;
+	const antigravity = antigravityText(result);
+	if (antigravity) providerLines.push(`- ${antigravity}`);
+
+	if (providerLines.length === 0) {
+		return `No opencode credentials were imported. Checked ${result.sourcePath}${result.antigravitySourcePath ? ` and ${result.antigravitySourcePath}` : ""}.`;
+	}
+
+	const suffix = missingCount > 0 ? `\nMissing ${missingCount} known opencode provider entr${missingCount === 1 ? "y" : "ies"}.` : "";
+	return `Opencode import wrote to ${result.authPath}:\n${providerLines.join("\n")}${suffix}`;
+}
+
+export function notificationLevel(result: OpencodeImportResult): "info" | "warn" | "error" {
+	if (result.wroteAuth) return "info";
+	if (result.providers.some((provider) => provider.status === "auth-exists-use-force") || result.antigravity?.reason === "auth-exists-use-force") return "warn";
+	return "error";
+}

package/external/pi-tools-suite/src/opencode-import/importer.ts

@@ -0,0 +1,208 @@
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getPiAuthPath, importOpencodeAntigravityAccount, readJsonFile, writeJsonFileSecure } from "../antigravity-auth/auth-store";
+
+export type OpencodeAuthCredential = {
+	type?: string;
+	access?: string;
+	refresh?: string;
+	expires?: number;
+	key?: string;
+	[key: string]: unknown;
+};
+
+export type PiAuthCredential = OpencodeAuthCredential;
+export type PiAuthData = Record<string, PiAuthCredential | undefined>;
+export type OpencodeAuthData = Record<string, OpencodeAuthCredential | undefined>;
+
+export type OpencodeProviderImportStatus = "imported" | "already-imported" | "auth-exists-use-force" | "source-missing" | "target-set-from-other-source" | "invalid-source";
+
+export type OpencodeProviderImportResult = {
+	label: string;
+	sourceProvider: string;
+	targetProvider: string;
+	status: OpencodeProviderImportStatus;
+};
+
+export type OpencodeImportResult = {
+	sourcePath: string;
+	antigravitySourcePath?: string;
+	authPath: string;
+	providers: OpencodeProviderImportResult[];
+	antigravity?: {
+		imported: boolean;
+		reason?: string;
+		email?: string;
+		accountIndex?: number;
+		accountCount?: number;
+		overwroteExisting?: boolean;
+	};
+	wroteAuth: boolean;
+};
+
+export type OpencodeImportOptions = {
+	sourcePath?: string;
+	authPath?: string;
+	antigravitySourcePath?: string;
+	overwrite?: boolean;
+	skipAuthJson?: boolean;
+	skipAntigravity?: boolean;
+	antigravityAccountIndex?: number;
+	antigravityEmail?: string;
+};
+
+type Mapping = {
+	label: string;
+	sourceProvider: string;
+	targetProvider: string;
+	transform: (credential: OpencodeAuthCredential) => PiAuthCredential | undefined;
+};
+
+const AUTH_JSON_MAPPINGS: Mapping[] = [
+	{
+		label: "OpenAI Codex",
+		sourceProvider: "openai",
+		targetProvider: "openai-codex",
+		transform: transformOAuthCredential,
+	},
+	{
+		label: "GitHub Copilot",
+		sourceProvider: "github-copilot",
+		targetProvider: "github-copilot",
+		transform: transformOAuthCredential,
+	},
+	{
+		label: "Z.ai",
+		sourceProvider: "zai-coding-plan",
+		targetProvider: "zai",
+		transform: transformApiKeyCredential,
+	},
+	{
+		label: "Zhipu/Z.ai",
+		sourceProvider: "zhipuai-coding-plan",
+		targetProvider: "zai",
+		transform: transformApiKeyCredential,
+	},
+];
+
+export function getDefaultOpencodeAuthPath(): string {
+	const dataDir = process.env.OPENCODE_DATA_DIR ?? join(process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "opencode");
+	return join(dataDir, "auth.json");
+}
+
+function transformOAuthCredential(credential: OpencodeAuthCredential): PiAuthCredential | undefined {
+	if (!credential.access && !credential.refresh) return undefined;
+	return { ...credential, type: "oauth" };
+}
+
+function transformApiKeyCredential(credential: OpencodeAuthCredential): PiAuthCredential | undefined {
+	if (!credential.key) return undefined;
+	return { ...credential, type: "api_key", key: credential.key };
+}
+
+function sameCredential(a: PiAuthCredential | undefined, b: PiAuthCredential | undefined): boolean {
+	return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+}
+
+function providerResult(mapping: Mapping, status: OpencodeProviderImportStatus): OpencodeProviderImportResult {
+	return {
+		label: mapping.label,
+		sourceProvider: mapping.sourceProvider,
+		targetProvider: mapping.targetProvider,
+		status,
+	};
+}
+
+async function pathExists(path: string): Promise<boolean> {
+	try {
+		await fs.access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function importOpencodeAccounts(options: OpencodeImportOptions = {}): Promise<OpencodeImportResult> {
+	const sourcePath = options.sourcePath ?? getDefaultOpencodeAuthPath();
+	const authPath = options.authPath ?? getPiAuthPath();
+	const result: OpencodeImportResult = {
+		sourcePath,
+		authPath,
+		providers: [],
+		wroteAuth: false,
+	};
+	if (options.antigravitySourcePath) result.antigravitySourcePath = options.antigravitySourcePath;
+
+	let piAuth = await readJsonFile<PiAuthData>(authPath, {});
+	const changedTargets = new Set<string>();
+
+	if (!options.skipAuthJson) {
+		const sourceExists = await pathExists(sourcePath);
+		const opencodeAuth = sourceExists ? await readJsonFile<OpencodeAuthData>(sourcePath, {}) : {};
+
+		for (const mapping of AUTH_JSON_MAPPINGS) {
+			const sourceCredential = opencodeAuth[mapping.sourceProvider];
+			if (!sourceCredential) {
+				result.providers.push(providerResult(mapping, "source-missing"));
+				continue;
+			}
+
+			if (changedTargets.has(mapping.targetProvider)) {
+				result.providers.push(providerResult(mapping, "target-set-from-other-source"));
+				continue;
+			}
+
+			const nextCredential = mapping.transform(sourceCredential);
+			if (!nextCredential) {
+				result.providers.push(providerResult(mapping, "invalid-source"));
+				continue;
+			}
+
+			const existingCredential = piAuth[mapping.targetProvider];
+			if (sameCredential(existingCredential, nextCredential)) {
+				result.providers.push(providerResult(mapping, "already-imported"));
+				changedTargets.add(mapping.targetProvider);
+				continue;
+			}
+
+			if (existingCredential && !options.overwrite) {
+				result.providers.push(providerResult(mapping, "auth-exists-use-force"));
+				changedTargets.add(mapping.targetProvider);
+				continue;
+			}
+
+			piAuth = { ...piAuth, [mapping.targetProvider]: nextCredential };
+			changedTargets.add(mapping.targetProvider);
+			result.providers.push(providerResult(mapping, "imported"));
+		}
+
+		if (result.providers.some((provider) => provider.status === "imported")) {
+			await writeJsonFileSecure(authPath, piAuth);
+			result.wroteAuth = true;
+		}
+	}
+
+	if (!options.skipAntigravity) {
+		const antigravity = await importOpencodeAntigravityAccount({
+			sourcePath: options.antigravitySourcePath,
+			authPath,
+			overwrite: options.overwrite,
+			accountIndex: options.antigravityAccountIndex,
+			email: options.antigravityEmail,
+		});
+		const antigravityResult: NonNullable<OpencodeImportResult["antigravity"]> = {
+			imported: antigravity.imported,
+		};
+		if (antigravity.reason) antigravityResult.reason = antigravity.reason;
+		if (antigravity.email) antigravityResult.email = antigravity.email;
+		if (typeof antigravity.accountIndex === "number") antigravityResult.accountIndex = antigravity.accountIndex;
+		if (typeof antigravity.accountCount === "number") antigravityResult.accountCount = antigravity.accountCount;
+		if (typeof antigravity.overwroteExisting === "boolean") antigravityResult.overwroteExisting = antigravity.overwroteExisting;
+		result.antigravity = antigravityResult;
+		result.antigravitySourcePath = antigravity.sourcePath;
+		result.wroteAuth ||= antigravity.imported;
+	}
+
+	return result;
+}

package/external/pi-tools-suite/src/opencode-import/index.ts

@@ -0,0 +1,25 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { formatOpencodeImportResult, notificationLevel, parseOpencodeImportCommandArgs } from "./commands";
+import { importOpencodeAccounts } from "./importer";
+
+export { formatOpencodeImportResult, notificationLevel, parseOpencodeImportCommandArgs } from "./commands";
+export { getDefaultOpencodeAuthPath, importOpencodeAccounts } from "./importer";
+export type { OpencodeImportOptions, OpencodeImportResult } from "./importer";
+
+export default function opencodeImport(pi: ExtensionAPI): void {
+	pi.registerCommand("opencode-import", {
+		description: "Import opencode auth.json credentials and Antigravity accounts into Pi/Pix auth.json",
+		handler: async (args: string, ctx: any) => {
+			try {
+				const result = await importOpencodeAccounts(parseOpencodeImportCommandArgs(args));
+				const message = formatOpencodeImportResult(result);
+				if (ctx.ui?.notify) ctx.ui.notify(message, notificationLevel(result));
+				else console.log(message);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				if (ctx.ui?.notify) ctx.ui.notify(message, "error");
+				else console.error(message);
+			}
+		},
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "private": false,
   "type": "module",
   "bin": {