@pasko70/pibo 1.1.0 → 1.3.0

package/dist/user-skills/store.js

@@ -35,12 +35,26 @@ export function saveUserSkillStore(data, cwd = process.cwd()) {
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, `${JSON.stringify({ version: STORE_VERSION, skills: data.skills }, null, 2)}\n`, "utf-8");
 }
+function readUserSkillDescription(skill, cwd = process.cwd()) {
+    const markdown = readSkillMarkdown(skill, cwd);
+    const parsed = parseSkillMd(markdown);
+    return parsed.description;
+}
 export function listUserSkills(cwd = process.cwd()) {
-    return loadUserSkillStore(cwd).skills;
+    const skills = loadUserSkillStore(cwd).skills;
+    for (const skill of skills) {
+        skill.description = readUserSkillDescription(skill, cwd);
+    }
+    return skills;
 }
 export function findUserSkill(idOrName, cwd = process.cwd()) {
     const lookup = idOrName.trim();
-    return listUserSkills(cwd).find((skill) => skill.id === lookup || skill.name === lookup);
+    const store = loadUserSkillStore(cwd);
+    const stored = store.skills.find((skill) => skill.id === lookup || skill.name === lookup);
+    if (!stored)
+        return undefined;
+    stored.description = readUserSkillDescription(stored, cwd);
+    return stored;
 }
 function validateSkillName(name, existingId, cwd = process.cwd()) {
     const trimmed = name.trim();
@@ -71,21 +85,28 @@ export function createUserSkill(input, cwd = process.cwd()) {
     const skillDir = join(defaultUserSkillDir(cwd), name);
     mkdirSync(skillDir, { recursive: true });
     const skillPath = join(skillDir, "SKILL.md");
-    const markdown = buildSkillMd(name, description, input.markdown ?? "");
+    const incoming = input.markdown ?? "";
+    const parsedIncoming = parseSkillMd(incoming);
+    const body = parsedIncoming.body || incoming;
+    const effectiveDescription = description || parsedIncoming.description;
+    const markdown = buildSkillMd(name, effectiveDescription, body);
     writeFileSync(skillPath, markdown, "utf-8");
     const now = new Date().toISOString();
     const skill = {
         id,
         name,
-        description,
+        description: effectiveDescription,
         path: skillPath,
         enabled: true,
         source: "user-created",
         createdAt: now,
         updatedAt: now,
     };
+    // Do not persist description in JSON store; it lives in SKILL.md frontmatter only.
+    const storedSkill = { ...skill };
+    delete storedSkill.description;
     const store = loadUserSkillStore(cwd);
-    store.skills.push(skill);
+    store.skills.push(storedSkill);
     store.skills.sort((a, b) => a.name.localeCompare(b.name));
     saveUserSkillStore(store, cwd);
     return skill;
@@ -97,10 +118,12 @@ export function updateUserSkill(id, input, cwd = process.cwd()) {
         throw new Error(`Skill "${id}" not found`);
     const existing = store.skills[index];
     let name = existing.name;
-    let description = existing.description;
     if (input.name !== undefined) {
         name = validateSkillName(input.name, existing.id, cwd);
     }
+    const currentMarkdown = existsSync(existing.path) ? readFileSync(existing.path, "utf-8") : "";
+    const parsed = parseSkillMd(currentMarkdown);
+    let description = parsed.description;
     if (input.description !== undefined) {
         description = input.description.trim();
     }
@@ -117,10 +140,14 @@ export function updateUserSkill(id, input, cwd = process.cwd()) {
         }
     }
     if (input.markdown !== undefined) {
-        const markdown = buildSkillMd(name, description, input.markdown);
+        const parsedIncoming = parseSkillMd(input.markdown);
+        const body = parsedIncoming.body || input.markdown;
+        const effectiveDescription = input.description !== undefined ? description : parsedIncoming.description || description;
+        description = effectiveDescription;
+        const markdown = buildSkillMd(name, effectiveDescription, body);
         writeFileSync(skillPath, markdown, "utf-8");
     }
-    else if (name !== existing.name || description !== existing.description) {
+    else if (name !== existing.name || description !== parsed.description) {
         const currentMarkdown = existsSync(existing.path) ? readFileSync(existing.path, "utf-8") : "";
         const { body } = parseSkillMd(currentMarkdown);
         writeFileSync(skillPath, buildSkillMd(name, description, body), "utf-8");
@@ -133,7 +160,10 @@ export function updateUserSkill(id, input, cwd = process.cwd()) {
         ...(input.enabled !== undefined ? { enabled: input.enabled } : {}),
         updatedAt: new Date().toISOString(),
     };
-    store.skills[index] = updated;
+    // Strip description before persisting to JSON store.
+    const storedUpdated = { ...updated };
+    delete storedUpdated.description;
+    store.skills[index] = storedUpdated;
     store.skills.sort((a, b) => a.name.localeCompare(b.name));
     saveUserSkillStore(store, cwd);
     return updated;
@@ -164,7 +194,7 @@ function sanitizeStoredSkill(value) {
     return {
         id: candidate.id,
         name: candidate.name.trim(),
-        description: typeof candidate.description === "string" ? candidate.description.trim() : "",
+        description: "",
         path: candidate.path.trim(),
         enabled: candidate.enabled !== false,
         source: isValidSource(candidate.source) ? candidate.source : "user-created",
@@ -205,12 +235,21 @@ function parseSimpleYaml(text) {
         if (colonIdx <= 0)
             continue;
         const key = line.slice(0, colonIdx).trim();
-        const value = line.slice(colonIdx + 1).trim();
+        const value = parseSimpleYamlScalar(line.slice(colonIdx + 1).trim());
         if (key)
             result[key] = value;
     }
     return result;
 }
+function parseSimpleYamlScalar(value) {
+    if (value.length >= 2) {
+        const quote = value[0];
+        if ((quote === '"' || quote === "'") && value[value.length - 1] === quote) {
+            return value.slice(1, -1);
+        }
+    }
+    return value;
+}
 function renameDirContents(oldDir, newDir) {
     mkdirSync(newDir, { recursive: true });
     for (const entry of readdirSync(oldDir)) {

package/dist/vscode/cli.js

@@ -0,0 +1,90 @@
+/**
+ * `pibo vscode` sub-command — manage the Pibo VS Code extension.
+ *
+ * Sub-commands:
+ *   install     Download and install the latest Pibo VS Code extension.
+ *   uninstall   Remove the installed Pibo VS Code extension.
+ *   status      Show whether the extension is installed and which CLI is used.
+ */
+import { Command } from "commander";
+import { runInstall } from "./install.js";
+import { runStatus, formatStatusText } from "./status.js";
+import { runUninstall } from "./uninstall.js";
+function printDiscovery() {
+    console.log(`pibo vscode
+
+Manage the Pibo VS Code extension.
+
+Commands:
+  install     Download and install the latest Pibo VS Code extension
+  uninstall   Remove the installed Pibo VS Code extension
+  status      Show whether the extension is installed
+
+Next: pibo vscode install --help`);
+}
+export async function runVscodeCli(argv = process.argv) {
+    const program = new Command();
+    program.name("pibo vscode").description("Manage the Pibo VS Code extension").helpOption("-h, --help");
+    program
+        .command("install")
+        .description("Download and install the Pibo VS Code extension")
+        .option("--version <tag>", "Pibo release tag to install (e.g., v1.3.0). Defaults to latest.")
+        .option("--vsix <path>", "Install from a local .vsix file instead of fetching a release")
+        .option("--from-url <url>", "Fetch a .vsix from the given URL (release tag will be inferred)")
+        .option("--owner <owner>", "GitHub owner for the release source", "Pascapone")
+        .option("--repo <repo>", "GitHub repo for the release source", "pibo")
+        .option("--no-cache", "Skip the VSIX download cache")
+        .option("--json", "Print JSON")
+        .action(async (options) => {
+        const result = await runInstall({
+            vsixPath: options.vsix,
+            fromUrl: options.fromUrl,
+            version: options.version,
+            owner: options.owner,
+            repo: options.repo,
+            skipCache: options.cache === false,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (result.status === "installed") {
+            console.log(`installed\t${result.tagName}\t${result.vsixPath}`);
+        }
+        else {
+            process.exitCode = 1;
+        }
+    });
+    program
+        .command("uninstall")
+        .description("Remove the installed Pibo VS Code extension")
+        .option("--json", "Print JSON")
+        .action(async (options) => {
+        const result = await runUninstall();
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (result.status !== "uninstalled") {
+            process.exitCode = 1;
+        }
+    });
+    program
+        .command("status")
+        .description("Show the Pibo VS Code extension install status")
+        .option("--owner <owner>", "GitHub owner for the release source", "Pascapone")
+        .option("--repo <repo>", "GitHub repo for the release source", "pibo")
+        .option("--json", "Print JSON")
+        .action(async (options) => {
+        const status = await runStatus({ owner: options.owner, repo: options.repo });
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+        }
+        else {
+            console.log(formatStatusText(status));
+        }
+    });
+    if (argv.length <= 2 || argv.includes("--help") || argv.includes("-h")) {
+        printDiscovery();
+        return;
+    }
+    await program.parseAsync(argv);
+}

package/dist/vscode/code-cli.js

@@ -0,0 +1,119 @@
+/**
+ * Detection of the VS Code CLI binary and wrapper around it.
+ *
+ * The `code` binary is what VS Code installs on `$PATH` when the user enables
+ * "Shell Command: Install 'code' command in PATH" from the VS Code command
+ * palette. It is the only supported way for `pibo vscode install` to install
+ * the extension. If no supported binary is on `$PATH`, install fails with a
+ * clear error pointing at https://code.visualstudio.com/.
+ */
+import { spawn as defaultSpawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
+export const SUPPORTED_CODE_BINARIES = ["code", "code-insiders", "codium"];
+function splitPathEnv(pathValue) {
+    if (!pathValue)
+        return [];
+    return pathValue.split(delimiter).filter((entry) => entry.length > 0);
+}
+function firstExisting(candidates) {
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+export function detectCodeBinary(options = {}) {
+    const pathValue = options.path ?? options.env?.PATH ?? process.env.PATH ?? "";
+    const directories = splitPathEnv(pathValue);
+    for (const binary of SUPPORTED_CODE_BINARIES) {
+        const candidates = directories.map((dir) => join(dir, binary));
+        const found = firstExisting(candidates);
+        if (found)
+            return { binary, path: found };
+    }
+    return undefined;
+}
+const COLLECT_BUFFER_LIMIT = 1024 * 1024; // 1 MiB
+export function runCodeCommand(options) {
+    const spawnImpl = options.spawnImpl ?? defaultSpawn;
+    const env = options.env ?? process.env;
+    return new Promise((resolveInvocation, rejectInvocation) => {
+        let child;
+        try {
+            child = spawnImpl(options.binary, [...options.args], {
+                env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            rejectInvocation(error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let stdoutLength = 0;
+        let stderrLength = 0;
+        let timedOut = false;
+        const timeoutHandle = typeof options.timeoutMs === "number"
+            ? setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGKILL");
+            }, options.timeoutMs)
+            : null;
+        child.stdout?.on("data", (chunk) => {
+            stdoutLength += chunk.length;
+            if (stdoutLength <= COLLECT_BUFFER_LIMIT)
+                stdoutChunks.push(chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderrLength += chunk.length;
+            if (stderrLength <= COLLECT_BUFFER_LIMIT)
+                stderrChunks.push(chunk);
+        });
+        child.on("error", (error) => {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            rejectInvocation(error);
+        });
+        child.on("close", (code) => {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            if (timedOut) {
+                rejectInvocation(new Error(`code command timed out after ${options.timeoutMs}ms`));
+                return;
+            }
+            resolveInvocation({
+                stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+                stderr: Buffer.concat(stderrChunks).toString("utf8"),
+                exitCode: code ?? -1,
+            });
+        });
+    });
+}
+export async function listInstalledExtensions(options) {
+    const result = await runCodeCommand({
+        binary: options.binary,
+        args: ["--list-extensions", "--show-versions"],
+        spawnImpl: options.spawnImpl,
+        env: options.env,
+        timeoutMs: 30_000,
+    });
+    if (result.exitCode !== 0) {
+        throw new Error(`code --list-extensions failed: ${result.stderr || result.stdout || `exit ${result.exitCode}`}`);
+    }
+    const entries = [];
+    for (const rawLine of result.stdout.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const atIndex = line.lastIndexOf("@");
+        if (atIndex > 0) {
+            entries.push({ id: line.slice(0, atIndex), version: line.slice(atIndex + 1) });
+        }
+        else {
+            entries.push({ id: line });
+        }
+    }
+    return entries;
+}

package/dist/vscode/install.js

@@ -0,0 +1,177 @@
+/**
+ * `pibo vscode install` — install the Pibo VS Code extension.
+ *
+ * Resolution order for the VSIX artifact:
+ *  1. `--vsix <path>`     → use the local file directly
+ *  2. `--from-url <url>`  → download from the given URL
+ *  3. default             → fetch the latest GitHub Release for the repo and
+ *                            use its `.vsix` asset (optionally pinned by
+ *                            `--version <tag>`)
+ *
+ * The resolved VSIX is cached under `~/.pibo/vscode/cache/<tagName>/` so
+ * repeated installs do not re-download.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { detectCodeBinary, listInstalledExtensions, runCodeCommand } from "./code-cli.js";
+import { downloadVsixAsset, fetchLatestVsix, isVsixAsset } from "./vsix-fetcher.js";
+import { DEFAULT_GITHUB_OWNER, DEFAULT_GITHUB_REPO, PIBO_VSCODE_CACHE_DIR, PIBO_VSCODE_EXTENSION_ID, } from "./types.js";
+import { findVsixAsset, fetchRelease } from "./vsix-fetcher.js";
+const DEFAULT_LOG = (message) => {
+    console.log(message);
+};
+const DEFAULT_ERROR = (message) => {
+    process.stderr.write(`${message}\n`);
+};
+function getCacheDir(options) {
+    if (options.cacheDir)
+        return options.cacheDir;
+    const base = options.env?.PIBO_HOME ?? join(homedir(), ".pibo");
+    return join(base, PIBO_VSCODE_CACHE_DIR, "cache");
+}
+function cacheKeyForVersion(tagName) {
+    return tagName.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function readCachedVsix(cacheDir, tagName) {
+    const dir = join(cacheDir, cacheKeyForVersion(tagName));
+    const path = join(dir, "pibo.vsix");
+    return existsSync(path) ? path : undefined;
+}
+function writeCachedVsix(cacheDir, tagName, bytes) {
+    const dir = join(cacheDir, cacheKeyForVersion(tagName));
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, "pibo.vsix");
+    writeFileSync(path, bytes);
+    return path;
+}
+function cachedTagManifestPath(cacheDir) {
+    return join(cacheDir, "last-installed.json");
+}
+function readCachedTagManifest(cacheDir) {
+    const path = cachedTagManifestPath(cacheDir);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const json = JSON.parse(readFileSync(path, "utf8"));
+        return json;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeCachedTagManifest(cacheDir, tagName, vsixPath) {
+    const path = cachedTagManifestPath(cacheDir);
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(path, JSON.stringify({ tagName, vsixPath, installedAt: new Date().toISOString() }, null, 2));
+}
+export async function resolveVsixArtifact(options) {
+    if (options.vsixPath) {
+        const absolute = resolve(options.vsixPath);
+        if (!existsSync(absolute)) {
+            throw new Error(`VSIX file not found at ${absolute}`);
+        }
+        return { tagName: "local", vsixPath: absolute };
+    }
+    if (!options.skipCache && !options.version) {
+        const cachedTag = readCachedTagManifest(options.cacheDir);
+        if (cachedTag?.tagName && cachedTag.vsixPath && existsSync(cachedTag.vsixPath)) {
+            return { tagName: cachedTag.tagName, vsixPath: cachedTag.vsixPath };
+        }
+    }
+    if (options.fromUrl) {
+        const release = await fetchRelease({ owner: options.owner, repo: options.repo, fetchImpl: options.fetchImpl });
+        const asset = findVsixAsset(release) ?? { name: "remote.vsix", browserDownloadUrl: options.fromUrl, size: 0, contentType: "application/octet-stream" };
+        const bytes = await downloadVsixAsset({ url: options.fromUrl, fetchImpl: options.fetchImpl });
+        const cachedPath = writeCachedVsix(options.cacheDir, release.tagName, bytes);
+        return { tagName: release.tagName, vsixPath: cachedPath, bytes };
+    }
+    const result = await fetchLatestVsix({
+        owner: options.owner,
+        repo: options.repo,
+        tagName: options.version,
+        fetchImpl: options.fetchImpl,
+    });
+    if (!options.skipCache) {
+        const cached = readCachedVsix(options.cacheDir, result.tagName);
+        if (cached)
+            return { tagName: result.tagName, vsixPath: cached };
+    }
+    const cachedPath = writeCachedVsix(options.cacheDir, result.tagName, result.bytes);
+    return { tagName: result.tagName, vsixPath: cachedPath, bytes: result.bytes };
+}
+export async function runInstall(options) {
+    const log = options.log ?? DEFAULT_LOG;
+    const errorLog = options.error ?? DEFAULT_ERROR;
+    const owner = options.owner ?? DEFAULT_GITHUB_OWNER;
+    const repo = options.repo ?? DEFAULT_GITHUB_REPO;
+    const cacheDir = getCacheDir(options);
+    const detected = detectCodeBinary({ env: options.env });
+    if (!detected) {
+        const message = `No VS Code CLI found on PATH. Install VS Code (https://code.visualstudio.com/) and run 'Shell Command: Install code command in PATH' from the VS Code command palette.`;
+        errorLog(message);
+        return { status: "failed", reason: "no-code-cli" };
+    }
+    let artifact;
+    try {
+        artifact = await resolveVsixArtifact({
+            vsixPath: options.vsixPath,
+            fromUrl: options.fromUrl,
+            version: options.version,
+            owner,
+            repo,
+            fetchImpl: options.fetchImpl,
+            cacheDir,
+            skipCache: options.skipCache,
+        });
+    }
+    catch (fetchError) {
+        const reason = fetchError instanceof Error ? fetchError.message : String(fetchError);
+        errorLog(`Failed to obtain VSIX: ${reason}`);
+        return { status: "failed", reason };
+    }
+    log(`Installing pibo VS Code extension ${artifact.tagName} from ${artifact.vsixPath} via ${detected.path}…`);
+    let installResult;
+    try {
+        installResult = await runCodeCommand({
+            binary: detected.path,
+            args: ["--install-extension", artifact.vsixPath, "--force"],
+            spawnImpl: options.spawnImpl,
+            env: options.env,
+            timeoutMs: 120_000,
+        });
+    }
+    catch (spawnError) {
+        const reason = spawnError instanceof Error ? spawnError.message : String(spawnError);
+        errorLog(`Failed to invoke ${detected.binary}: ${reason}`);
+        return { status: "failed", reason, codeBinary: detected.path, tagName: artifact.tagName };
+    }
+    if (installResult.exitCode !== 0) {
+        const reason = `code --install-extension exited with code ${installResult.exitCode}: ${installResult.stderr || installResult.stdout}`;
+        errorLog(reason);
+        return { status: "failed", reason, codeBinary: detected.path, tagName: artifact.tagName };
+    }
+    writeCachedTagManifest(cacheDir, artifact.tagName, artifact.vsixPath);
+    try {
+        const installed = await listInstalledExtensions({
+            binary: detected.path,
+            spawnImpl: options.spawnImpl,
+            env: options.env,
+        });
+        const ours = installed.find((entry) => entry.id === PIBO_VSCODE_EXTENSION_ID);
+        if (ours) {
+            log(`Installed ${ours.id}@${ours.version ?? "?"} via ${detected.path}`);
+        }
+        else {
+            log(`code --install-extension reported success but ${PIBO_VSCODE_EXTENSION_ID} is not in the installed list.`);
+        }
+    }
+    catch (listError) {
+        // Listing the installed extensions is a best-effort check; do not fail the install on a listing error.
+        const reason = listError instanceof Error ? listError.message : String(listError);
+        log(`Install completed; failed to verify via --list-extensions: ${reason}`);
+    }
+    return { status: "installed", tagName: artifact.tagName, vsixPath: artifact.vsixPath, codeBinary: detected.path };
+}
+// Re-export for symmetry with code-cli.ts consumers.
+export { isVsixAsset };

package/dist/vscode/status.js

@@ -0,0 +1,80 @@
+/**
+ * `pibo vscode status` — report whether the Pibo VS Code extension is
+ * installed, the local VS Code CLI binary, and the cached VSIX artifacts.
+ */
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { detectCodeBinary, listInstalledExtensions } from "./code-cli.js";
+import { fetchRelease } from "./vsix-fetcher.js";
+import { DEFAULT_GITHUB_OWNER, DEFAULT_GITHUB_REPO, PIBO_VSCODE_CACHE_DIR, PIBO_VSCODE_EXTENSION_ID, } from "./types.js";
+function getCacheDir(options) {
+    if (options.cacheDir)
+        return options.cacheDir;
+    const base = options.env?.PIBO_HOME ?? join(homedir(), ".pibo");
+    return join(base, PIBO_VSCODE_CACHE_DIR, "cache");
+}
+function listCachedReleases(cacheDir, limit) {
+    if (!existsSync(cacheDir))
+        return [];
+    const entries = readdirSync(cacheDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name !== "node_modules")
+        .map((entry) => ({ name: entry.name, mtimeMs: statSync(join(cacheDir, entry.name)).mtimeMs }))
+        .sort((a, b) => b.mtimeMs - a.mtimeMs)
+        .slice(0, limit)
+        .map((entry) => entry.name);
+    return entries;
+}
+export async function runStatus(options = {}) {
+    const owner = options.owner ?? DEFAULT_GITHUB_OWNER;
+    const repo = options.repo ?? DEFAULT_GITHUB_REPO;
+    const cacheDir = getCacheDir(options);
+    const limit = options.limit ?? 5;
+    const detected = detectCodeBinary({ env: options.env });
+    let installed = false;
+    let version;
+    if (detected) {
+        try {
+            const installedExtensions = await listInstalledExtensions({
+                binary: detected.path,
+                spawnImpl: options.spawnImpl,
+                env: options.env,
+            });
+            const ours = installedExtensions.find((entry) => entry.id === PIBO_VSCODE_EXTENSION_ID);
+            if (ours) {
+                installed = true;
+                version = ours.version;
+            }
+        }
+        catch {
+            // Listing failed; treat as not-installed for status purposes.
+            installed = false;
+        }
+    }
+    const cachedReleases = listCachedReleases(cacheDir, limit);
+    let availableReleases = [];
+    try {
+        const release = await fetchRelease({ owner, repo, fetchImpl: options.fetchImpl });
+        availableReleases = [release.tagName];
+    }
+    catch {
+        // Network failure is non-fatal for status.
+    }
+    return {
+        installed,
+        version,
+        codeBinary: detected?.path,
+        vsixCacheDir: cacheDir,
+        availableReleases,
+    };
+}
+export function formatStatusText(status) {
+    const lines = [];
+    lines.push(`extension: ${status.installed ? `${PIBO_VSCODE_EXTENSION_ID}@${status.version ?? "?"}` : "not installed"}`);
+    lines.push(`code binary: ${status.codeBinary ?? "(not on PATH)"}`);
+    lines.push(`vsix cache: ${status.vsixCacheDir}`);
+    if (status.availableReleases.length > 0) {
+        lines.push(`latest release: ${status.availableReleases[0]}`);
+    }
+    return lines.join("\n");
+}

package/dist/vscode/types.js

@@ -0,0 +1,14 @@
+/**
+ * Types and constants for the `pibo vscode` sub-command.
+ *
+ * The pibo VS Code extension is a thin VS Code client that opens a WebView
+ * pointing at the gateway-served chat-vscode-web app. The extension itself
+ * ships as a `.vsix` artifact, published to the VS Code Marketplace and
+ * mirrored on GitHub Releases.
+ */
+export const PIBO_VSCODE_EXTENSION_PUBLISHER = "pibo";
+export const PIBO_VSCODE_EXTENSION_NAME = "pibo-vscode";
+export const PIBO_VSCODE_EXTENSION_ID = `${PIBO_VSCODE_EXTENSION_PUBLISHER}.${PIBO_VSCODE_EXTENSION_NAME}`;
+export const DEFAULT_GITHUB_OWNER = "Pascapone";
+export const DEFAULT_GITHUB_REPO = "pibo";
+export const PIBO_VSCODE_CACHE_DIR = "vscode";

package/dist/vscode/uninstall.js

@@ -0,0 +1,49 @@
+/**
+ * `pibo vscode uninstall` — remove the installed Pibo VS Code extension.
+ */
+import { detectCodeBinary, runCodeCommand } from "./code-cli.js";
+import { PIBO_VSCODE_EXTENSION_ID } from "./types.js";
+const DEFAULT_LOG = (message) => {
+    console.log(message);
+};
+const DEFAULT_ERROR = (message) => {
+    process.stderr.write(`${message}\n`);
+};
+export async function runUninstall(options = {}) {
+    const log = options.log ?? DEFAULT_LOG;
+    const errorLog = options.error ?? DEFAULT_ERROR;
+    const detected = detectCodeBinary({ env: options.env });
+    if (!detected) {
+        errorLog(`No VS Code CLI found on PATH.`);
+        return { status: "failed", reason: "no-code-cli" };
+    }
+    log(`Uninstalling ${PIBO_VSCODE_EXTENSION_ID} via ${detected.path}…`);
+    let result;
+    try {
+        result = await runCodeCommand({
+            binary: detected.path,
+            args: ["--uninstall-extension", PIBO_VSCODE_EXTENSION_ID],
+            spawnImpl: options.spawnImpl,
+            env: options.env,
+            timeoutMs: 60_000,
+        });
+    }
+    catch (spawnError) {
+        const reason = spawnError instanceof Error ? spawnError.message : String(spawnError);
+        errorLog(`Failed to invoke ${detected.binary}: ${reason}`);
+        return { status: "failed", reason, codeBinary: detected.path };
+    }
+    if (result.exitCode !== 0) {
+        const stderr = result.stderr || result.stdout;
+        // VS Code returns a non-zero exit when the extension is not installed; treat that as "not-installed".
+        if (/not found|not installed|Cannot find extension/i.test(stderr)) {
+            log(`${PIBO_VSCODE_EXTENSION_ID} was not installed.`);
+            return { status: "not-installed", codeBinary: detected.path };
+        }
+        const reason = `code --uninstall-extension exited with code ${result.exitCode}: ${stderr}`;
+        errorLog(reason);
+        return { status: "failed", reason, codeBinary: detected.path };
+    }
+    log(`Uninstalled ${PIBO_VSCODE_EXTENSION_ID}`);
+    return { status: "uninstalled", codeBinary: detected.path };
+}