akm-cli 0.4.0 → 0.5.0-rc1

package/dist/stash-add.js

@@ -8,32 +8,50 @@ import { upsertLockEntry } from "./lockfile";
 import { detectStashRoot, installRegistryRef, upsertInstalledRegistryEntry } from "./registry-install";
 import { parseRegistryRef } from "./registry-resolve";
 import { ensureWebsiteMirror, validateWebsiteInputUrl } from "./stash-providers/website";
+import { warn } from "./warn";
+import { validateWikiName } from "./wiki";
+const VALID_OVERRIDE_TYPES = new Set(["wiki"]);
 export async function akmAdd(input) {
     const ref = input.ref.trim();
     if (!ref)
         throw new UsageError("Install ref or local directory is required. " +
             "Examples: `akm add @scope/kit`, `akm add github:owner/repo`, `akm add ./local/path`");
+    // Validate and resolve wiki name when --type wiki is used
+    let wikiName;
+    if (input.overrideType) {
+        if (!VALID_OVERRIDE_TYPES.has(input.overrideType)) {
+            throw new UsageError(`Invalid --type value: "${input.overrideType}". Supported types: ${[...VALID_OVERRIDE_TYPES].join(", ")}`);
+        }
+        if (input.overrideType === "wiki") {
+            const derived = input.name ?? deriveWikiNameFromRef(ref);
+            validateWikiName(derived);
+            wikiName = derived;
+        }
+    }
     const stashDir = resolveStashDir();
     if (shouldAddAsWebsiteUrl(ref)) {
-        return addWebsiteStashSource(ref, stashDir, input.name, input.options);
+        return addWebsiteStashSource(ref, stashDir, input.name ?? wikiName, input.options, wikiName);
     }
     // Detect local directory refs and route them to stashes[] instead of installed[]
     try {
         const parsed = parseRegistryRef(ref);
         if (parsed.source === "local") {
-            return addLocalStashSource(ref, parsed.sourcePath, stashDir);
+            if (input.trustThisInstall) {
+                warn("--trust has no effect on local directory sources; the install audit is not run for local paths.");
+            }
+            return addLocalStashSource(ref, parsed.sourcePath, stashDir, wikiName);
         }
     }
     catch {
         // Not a local ref — fall through to registry install
     }
-    return addRegistryKit(ref, stashDir);
+    return addRegistryKit(ref, stashDir, input.trustThisInstall, input.writable, wikiName);
 }
 /**
  * Add a local directory as a filesystem stash source.
  * Creates a stashes[] entry instead of an installed[] entry.
  */
-async function addLocalStashSource(ref, sourcePath, stashDir) {
+async function addLocalStashSource(ref, sourcePath, stashDir, wikiName) {
     const stashRoot = detectStashRoot(sourcePath);
     const resolvedPath = path.resolve(stashRoot);
     const config = loadUserConfig();
@@ -44,11 +62,16 @@ async function addLocalStashSource(ref, sourcePath, stashDir) {
         const entry = {
             type: "filesystem",
             path: resolvedPath,
-            name: toReadableId(resolvedPath),
+            name: wikiName ?? toReadableId(resolvedPath),
+            ...(wikiName ? { wikiName } : {}),
         };
         stashes.push(entry);
         saveConfig({ ...config, stashes });
     }
+    else if (wikiName && existing.wikiName !== wikiName) {
+        existing.wikiName = wikiName;
+        saveConfig({ ...config, stashes });
+    }
     const index = await akmIndex({ stashDir });
     const updatedConfig = loadConfig();
     return {
@@ -73,7 +96,7 @@ async function addLocalStashSource(ref, sourcePath, stashDir) {
         },
     };
 }
-async function addWebsiteStashSource(ref, stashDir, name, options) {
+async function addWebsiteStashSource(ref, stashDir, name, options, wikiName) {
     const normalizedUrl = validateWebsiteInputUrl(ref);
     const config = loadUserConfig();
     const stashes = [...(config.stashes ?? [])];
@@ -84,13 +107,23 @@ async function addWebsiteStashSource(ref, stashDir, name, options) {
             url: normalizedUrl,
             name: name ?? toWebsiteName(normalizedUrl),
             ...(options && Object.keys(options).length > 0 ? { options } : {}),
+            ...(wikiName ? { wikiName } : {}),
         };
         stashes.push(entry);
         saveConfig({ ...config, stashes });
     }
-    else if (options && Object.keys(options).length > 0) {
-        entry.options = { ...entry.options, ...options };
-        saveConfig({ ...config, stashes });
+    else {
+        let changed = false;
+        if (options && Object.keys(options).length > 0) {
+            entry.options = { ...entry.options, ...options };
+            changed = true;
+        }
+        if (wikiName && entry.wikiName !== wikiName) {
+            entry.wikiName = wikiName;
+            changed = true;
+        }
+        if (changed)
+            saveConfig({ ...config, stashes });
     }
     const cachePaths = await ensureWebsiteMirror(entry, { requireStashDir: true });
     const index = await akmIndex({ stashDir });
@@ -120,8 +153,8 @@ async function addWebsiteStashSource(ref, stashDir, name, options) {
 /**
  * Install a kit from a registry (npm, github, git).
  */
-async function addRegistryKit(ref, stashDir) {
-    const installed = await installRegistryRef(ref);
+async function addRegistryKit(ref, stashDir, trustThisInstall, writable, wikiName) {
+    const installed = await installRegistryRef(ref, { trustThisInstall, writable });
     const replaced = (loadConfig().installed ?? []).find((entry) => entry.id === installed.id);
     const config = upsertInstalledRegistryEntry({
         id: installed.id,
@@ -133,6 +166,8 @@ async function addRegistryKit(ref, stashDir) {
         stashRoot: installed.stashRoot,
         cacheDir: installed.cacheDir,
         installedAt: installed.installedAt,
+        writable: installed.writable,
+        ...(wikiName ? { wikiName } : {}),
     });
     await upsertLockEntry({
         id: installed.id,
@@ -211,3 +246,41 @@ function toWebsiteName(siteUrl) {
         return siteUrl;
     }
 }
+/**
+ * Derive a wiki name from a ref string when --name is not provided.
+ * Lowercases and slugifies the most meaningful identifier segment.
+ */
+export function deriveWikiNameFromRef(ref) {
+    let candidate = ref;
+    // github:owner/repo or github:owner/repo@ref
+    if (/^github:/i.test(ref)) {
+        const repoPath = ref.replace(/^github:/i, "").split("@")[0];
+        candidate = repoPath.split("/").pop() ?? repoPath;
+    }
+    // npm:pkg or @scope/pkg
+    else if (/^npm:/i.test(ref) || ref.startsWith("@")) {
+        candidate = ref
+            .replace(/^npm:/i, "")
+            .replace(/^@[^/]+\//, "")
+            .split("@")[0];
+    }
+    // git URLs or HTTPS git URLs
+    else if (/^(git:|https?:\/\/)/.test(ref)) {
+        try {
+            candidate = new URL(ref).pathname.split("/").pop() ?? candidate;
+        }
+        catch {
+            candidate = ref.split("/").pop() ?? ref;
+        }
+        candidate = candidate.replace(/\.git$/, "");
+    }
+    // Local paths
+    else {
+        candidate = path.basename(ref.replace(/\/+$/, ""));
+    }
+    return candidate
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64);
+}

package/dist/stash-providers/git.js

@@ -1,16 +1,19 @@
-import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { fetchWithRetry } from "../common";
-import { ConfigError } from "../errors";
+import { resolveStashDir } from "../common";
+import { loadConfig } from "../config";
+import { ConfigError, UsageError } from "../errors";
 import { getRegistryIndexCacheDir } from "../paths";
-import { extractTarGzSecure } from "../registry-install";
+import { validateGitUrl } from "../registry-resolve";
 import { registerStashProvider } from "../stash-provider-factory";
 import { isExpired, sanitizeString } from "./provider-utils";
 /** Cache TTL before refreshing the mirrored repo (12 hours). */
 const CACHE_TTL_MS = 12 * 60 * 60 * 1000;
 /** Maximum stale age allowed when refresh fails (7 days). */
 const CACHE_STALE_MS = 7 * 24 * 60 * 60 * 1000;
+const GIT_STASH_TYPES = new Set(["git", "context-hub", "github"]);
 class GitStashProvider {
     type = "git";
     name;
@@ -40,13 +43,13 @@ function getCachePaths(repoUrl) {
     const rootDir = path.join(getRegistryIndexCacheDir(), `context-hub-${key}`);
     return {
         rootDir,
-        archivePath: path.join(rootDir, "repo.tar.gz"),
         repoDir: path.join(rootDir, "repo"),
         indexPath: path.join(rootDir, "index.json"),
     };
 }
 async function ensureGitMirror(repo, cachePaths, options) {
     const requireRepoDir = options?.requireRepoDir === true;
+    const writable = options?.writable === true;
     // Check if cache is fresh
     let mtime = 0;
     try {
@@ -60,8 +63,13 @@ async function ensureGitMirror(repo, cachePaths, options) {
     }
     try {
         fs.mkdirSync(cachePaths.rootDir, { recursive: true });
-        await downloadArchive(buildTarballUrl(repo), cachePaths.archivePath);
-        extractTarGzSecure(cachePaths.archivePath, cachePaths.repoDir);
+        if (writable && fs.existsSync(path.join(cachePaths.repoDir, ".git"))) {
+            // Writable repo already cloned — pull instead of re-clone to preserve local changes
+            pullRepo(cachePaths.repoDir);
+        }
+        else {
+            cloneRepo(repo.cloneUrl, repo.ref, cachePaths.repoDir, writable);
+        }
         // Touch index file to track freshness
         fs.writeFileSync(cachePaths.indexPath, "[]", { encoding: "utf8", mode: 0o600 });
     }
@@ -72,6 +80,50 @@ async function ensureGitMirror(repo, cachePaths, options) {
         throw err;
     }
 }
+export function cloneRepo(cloneUrl, ref, destDir, writable = false) {
+    // Stage the clone into a sibling temp dir so that a failed clone never
+    // destroys a previously-valid destDir (e.g. when the remote is temporarily
+    // unreachable and we have a valid cached copy).
+    const tmpDir = `${destDir}.tmp-${randomBytes(4).toString("hex")}`;
+    const args = ["clone", "--depth", "1"];
+    if (ref)
+        args.push("--branch", ref);
+    args.push(cloneUrl, tmpDir);
+    const result = spawnSync("git", args, { encoding: "utf8", timeout: 120_000 });
+    if (result.status !== 0) {
+        // Clean up the (possibly partial) temp dir but leave destDir untouched.
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        const err = result.stderr?.trim() || result.error?.message || "unknown error";
+        throw new Error(`Failed to clone ${cloneUrl}: ${err}`);
+    }
+    try {
+        if (!writable) {
+            // Remove .git directory — we only need the working tree for read-only stashes
+            const gitDir = path.join(tmpDir, ".git");
+            if (fs.existsSync(gitDir))
+                fs.rmSync(gitDir, { recursive: true, force: true });
+        }
+        // Swap: remove the old destDir (if any) then atomically rename tmpDir into place.
+        if (fs.existsSync(destDir))
+            fs.rmSync(destDir, { recursive: true, force: true });
+        fs.renameSync(tmpDir, destDir);
+    }
+    catch (err) {
+        // Post-clone steps failed — clean up the temp dir to avoid orphaned dirs.
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        throw err;
+    }
+}
+function pullRepo(repoDir) {
+    const result = spawnSync("git", ["-C", repoDir, "pull", "--ff-only"], {
+        encoding: "utf8",
+        timeout: 120_000,
+    });
+    if (result.status !== 0) {
+        const err = result.stderr?.trim() || result.error?.message || "unknown error";
+        throw new Error(`Failed to pull ${repoDir}: ${err}`);
+    }
+}
 function hasExtractedRepo(repoDir) {
     try {
         return fs.statSync(repoDir).isDirectory() && fs.statSync(path.join(repoDir, "content")).isDirectory();
@@ -80,25 +132,22 @@ function hasExtractedRepo(repoDir) {
         return false;
     }
 }
-async function downloadArchive(url, destination) {
-    const response = await fetchWithRetry(url, undefined, { timeout: 120_000, retries: 1 });
-    if (!response.ok) {
-        throw new Error(`Failed to download archive (${response.status}) from ${url}`);
-    }
-    const BunRuntime = globalThis.Bun;
-    if (BunRuntime?.write) {
-        await BunRuntime.write(destination, response);
-        return;
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    fs.writeFileSync(destination, Buffer.from(arrayBuffer));
-}
-function buildTarballUrl(repo) {
-    return `https://github.com/${repo.owner}/${repo.repo}/archive/refs/heads/${repo.ref}.tar.gz`;
-}
 function parseGitRepoUrl(rawUrl) {
     if (!rawUrl) {
-        throw new ConfigError("Git provider requires a GitHub repository URL");
+        throw new ConfigError("Git provider requires a repository URL");
+    }
+    // SSH shorthand: git@host:path — valid as-is, delegated to system git credentials
+    if (/^git@[^:]+:.+$/.test(rawUrl)) {
+        return { cloneUrl: rawUrl, ref: null, canonicalUrl: rawUrl };
+    }
+    // Validate URL scheme is safe before parsing
+    try {
+        validateGitUrl(rawUrl);
+    }
+    catch (err) {
+        if (err instanceof UsageError)
+            throw new ConfigError(err.message);
+        throw err;
     }
     let parsed;
     try {
@@ -107,33 +156,122 @@ function parseGitRepoUrl(rawUrl) {
     catch {
         throw new ConfigError(`Git provider URL is not valid: "${rawUrl}"`);
     }
-    if (parsed.protocol !== "https:") {
-        throw new ConfigError(`Git provider URL must use https://, got "${parsed.protocol}"`);
+    // GitHub web URLs: extract a clean clone URL and optional branch from /tree/<ref>
+    if (parsed.hostname === "github.com" && parsed.protocol === "https:") {
+        const segments = parsed.pathname.split("/").filter(Boolean);
+        if (segments.length < 2) {
+            throw new ConfigError(`Git provider URL must point to a repository, got "${rawUrl}"`);
+        }
+        const owner = sanitizeString(segments[0]);
+        const repo = sanitizeString(segments[1].replace(/\.git$/i, ""));
+        if (!owner || !repo || !/^[A-Za-z0-9_.-]+$/.test(owner) || !/^[A-Za-z0-9_.-]+$/.test(repo)) {
+            throw new ConfigError(`Unsupported repository URL: "${rawUrl}"`);
+        }
+        let ref = null;
+        if (segments[2] === "tree" && segments.length >= 4) {
+            const rawRef = sanitizeString(segments.slice(3).join("/"), 255);
+            if (rawRef && !rawRef.includes("..") && /^[A-Za-z0-9._/-]+$/.test(rawRef)) {
+                ref = rawRef;
+            }
+        }
+        const cloneUrl = `https://github.com/${owner}/${repo}`;
+        const canonicalUrl = ref ? `${cloneUrl}/tree/${ref}` : cloneUrl;
+        return { cloneUrl, ref, canonicalUrl };
+    }
+    // Any other valid git URL: use as-is for cloning, but strip embedded credentials
+    // from canonicalUrl so secrets don't leak into cache keys or warning messages.
+    let canonicalUrl = rawUrl;
+    try {
+        const u = new URL(rawUrl);
+        u.username = "";
+        u.password = "";
+        u.search = "";
+        u.hash = "";
+        canonicalUrl = u.toString();
+    }
+    catch {
+        // URL failed to parse — fall back to raw (validateGitUrl already accepted it)
+    }
+    return { cloneUrl: rawUrl, ref: null, canonicalUrl };
+}
+/**
+ * Commit (and optionally push) local changes in a git-backed stash.
+ *
+ * Behaviour:
+ *   - Not a git repo → skipped (no-op)
+ *   - Git repo, no remote → commit only
+ *   - Git repo, has remote, but stash is not writable → commit only
+ *   - Git repo, has remote, stash is writable → commit + push
+ *
+ * When `name` is omitted the primary stash directory is used.
+ * When `message` is omitted a timestamp is used.
+ */
+export function saveGitStash(name, message, writableOverride) {
+    const timestamp = new Date().toISOString().replace("T", " ").slice(0, 19);
+    const commitMessage = message?.trim() || `akm save ${timestamp}`;
+    let repoDir;
+    let writable = false;
+    if (name) {
+        const config = loadConfig();
+        const stash = config.stashes?.find((s) => s.name === name || s.url === name);
+        if (!stash)
+            throw new UsageError(`No git stash found with name "${name}"`);
+        if (!GIT_STASH_TYPES.has(stash.type)) {
+            throw new UsageError(`Stash "${name}" is not a git stash (type: ${stash.type})`);
+        }
+        if (!stash.url)
+            throw new UsageError(`Stash "${name}" has no URL configured`);
+        const repo = parseGitRepoUrl(stash.url);
+        repoDir = getCachePaths(repo.canonicalUrl).repoDir;
+        writable = stash.writable === true;
+    }
+    else {
+        repoDir = resolveStashDir({ readOnly: true });
+        // Allow caller to override writable for the primary stash (e.g. from root config.writable)
+        if (writableOverride !== undefined) {
+            writable = writableOverride;
+        }
+    }
+    // No-op: not a git repo
+    if (!fs.existsSync(path.join(repoDir, ".git"))) {
+        return { committed: false, pushed: false, skipped: true, reason: "not a git repository", output: "" };
+    }
+    // Nothing to commit?
+    const statusResult = spawnSync("git", ["-C", repoDir, "status", "--porcelain"], { encoding: "utf8" });
+    if (statusResult.error || statusResult.status !== 0) {
+        throw new Error(`git status failed: ${statusResult.error?.message || statusResult.stderr?.trim() || "unknown error"}`);
+    }
+    if (!statusResult.stdout.trim()) {
+        return { committed: false, pushed: false, skipped: false, output: "nothing to commit, working tree clean" };
     }
-    if (parsed.hostname !== "github.com") {
-        throw new ConfigError(`Git provider only supports github.com URLs, got "${parsed.hostname}"`);
+    // Stage and commit — supply fallback identity so fresh environments without
+    // user.name/user.email configured can always commit to the default stash.
+    const addResult = spawnSync("git", ["-C", repoDir, "add", "-A"], { encoding: "utf8" });
+    if (addResult.status !== 0) {
+        throw new Error(`git add failed: ${addResult.stderr?.trim() || "unknown error"}`);
     }
-    const segments = parsed.pathname.split("/").filter(Boolean);
-    if (segments.length < 2) {
-        throw new ConfigError(`Git provider URL must point to a GitHub repository, got "${rawUrl}"`);
+    const commitResult = spawnSync("git", ["-C", repoDir, "-c", "user.name=akm", "-c", "user.email=akm@local", "commit", "-m", commitMessage], { encoding: "utf8" });
+    if (commitResult.status !== 0) {
+        throw new Error(`git commit failed: ${commitResult.stderr?.trim() || "unknown error"}`);
     }
-    const owner = sanitizeString(segments[0]);
-    const repo = sanitizeString(segments[1].replace(/\.git$/i, ""));
-    let ref = "main";
-    if (segments[2] === "tree" && segments.length >= 4) {
-        ref = sanitizeString(segments.slice(3).join("/"), 255) || "main";
+    // Push only when there is a remote AND the stash is marked writable
+    const remoteResult = spawnSync("git", ["-C", repoDir, "remote"], { encoding: "utf8" });
+    if (remoteResult.status !== 0) {
+        throw new Error(`git remote failed: ${remoteResult.stderr?.trim() || "unknown error"}`);
     }
-    if (!owner || !repo || !/^[A-Za-z0-9_.-]+$/.test(owner) || !/^[A-Za-z0-9_.-]+$/.test(repo)) {
-        throw new ConfigError(`Unsupported repository URL: "${rawUrl}"`);
+    const hasRemote = remoteResult.stdout.trim().length > 0;
+    if (!hasRemote || !writable) {
+        return { committed: true, pushed: false, skipped: false, output: commitResult.stdout.trim() };
     }
-    if (!ref || ref.includes("..") || !/^[A-Za-z0-9._/-]+$/.test(ref)) {
-        throw new ConfigError(`Unsupported branch/ref in URL: "${rawUrl}"`);
+    const pushResult = spawnSync("git", ["-C", repoDir, "push"], { encoding: "utf8", timeout: 120_000 });
+    if (pushResult.status !== 0) {
+        throw new Error(`git push failed: ${pushResult.stderr?.trim() || "unknown error"}`);
     }
     return {
-        owner,
-        repo,
-        ref,
-        canonicalUrl: `https://github.com/${owner}/${repo}/tree/${ref}`,
+        committed: true,
+        pushed: true,
+        skipped: false,
+        output: (commitResult.stdout + pushResult.stdout).trim() || "changes committed and pushed",
     };
 }
 // ── Exports ─────────────────────────────────────────────────────────────────

package/dist/stash-show.js

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import path from "node:path";
 import { loadConfig } from "./config";
 import { closeDatabase, openDatabase } from "./db";
@@ -13,6 +14,35 @@ import { resolveAssetPath } from "./stash-resolve";
 import { insertUsageEvent } from "./usage-events";
 // Eagerly import stash providers to trigger self-registration
 import "./stash-providers/index";
+/**
+ * Show a wiki root (no page path) — returns the same payload as
+ * `akm wiki show <name>`.
+ *
+ * Called when `parseAssetRef` yields `type === "wiki"` and the name has no
+ * `/`, e.g. `wiki:research`.
+ */
+async function showWikiRoot(stashDir, wikiName) {
+    const { showWiki, resolveWikiDir } = await import("./wiki.js");
+    const wikiDir = resolveWikiDir(stashDir, wikiName);
+    if (!fs.existsSync(wikiDir)) {
+        throw new NotFoundError(`Wiki not found: ${wikiName}. Run \`akm wiki create ${wikiName}\` to create it.`);
+    }
+    const result = showWiki(stashDir, wikiName);
+    // Shape the WikiShowResult into a ShowResponse-compatible object.
+    // The payload mirrors what `akm wiki show <name>` returns.
+    return {
+        type: "wiki",
+        name: result.ref,
+        path: result.path,
+        ...(result.description ? { description: result.description } : {}),
+        origin: null,
+        editable: false,
+        pages: result.pages,
+        raws: result.raws,
+        ...(result.lastModified ? { lastModified: result.lastModified } : {}),
+        recentLog: result.recentLog,
+    };
+}
 /**
  * Unified show: tries local FTS5 index first, then remote providers.
  *
@@ -21,6 +51,30 @@ import "./stash-providers/index";
  */
 export async function akmShowUnified(input) {
     const ref = input.ref.trim();
+    // 0. Wiki-root shortcut: `wiki:<name>` with no page path routes to the
+    //    wiki summary (same payload as `akm wiki show <name>`). Honour
+    //    `parsed.origin` by resolving against the matching stash source(s),
+    //    falling back to the primary stash when no origin is given.
+    {
+        const parsed = parseAssetRef(ref);
+        if (parsed.type === "wiki" && !parsed.name.includes("/")) {
+            const allSources = resolveStashSources();
+            const searchSources = resolveSourcesForOrigin(parsed.origin, allSources);
+            let lastError;
+            for (const source of searchSources) {
+                try {
+                    return await showWikiRoot(source.path, parsed.name);
+                }
+                catch (err) {
+                    if (!(err instanceof NotFoundError))
+                        throw err;
+                    lastError = err;
+                }
+            }
+            throw (lastError ??
+                new NotFoundError(`Wiki not found: ${parsed.name}. Run \`akm wiki create ${parsed.name}\` to create it.`));
+        }
+    }
     // 1. Try local filesystem first (FTS5 index lookup)
     let localError;
     try {
@@ -127,7 +181,7 @@ export async function showLocal(input) {
     if (!renderer) {
         throw new UsageError(`Renderer "${match.renderer}" not found for asset: ${displayType}:${parsed.name}`);
     }
-    const renderCtx = buildRenderContext(fileCtx, match, allStashDirs);
+    const renderCtx = buildRenderContext(fileCtx, match, allStashDirs, source?.registryId);
     const response = renderer.buildShowResponse(renderCtx);
     const editable = isEditable(assetPath, config);
     const fullResponse = {
@@ -188,6 +242,7 @@ function buildSummaryResponse(full, assetPath) {
         ...(description ? { description } : {}),
         ...(tags && tags.length > 0 ? { tags } : {}),
         ...(full.parameters ? { parameters: full.parameters } : {}),
+        ...(full.workflowTitle ? { workflowTitle: full.workflowTitle } : {}),
         ...(full.action ? { action: full.action } : {}),
         ...(full.run ? { run: full.run } : {}),
         ...(full.origin !== undefined ? { origin: full.origin } : {}),

package/dist/stash-source-manage.js

@@ -11,12 +11,16 @@ import { resolveStashSources } from "./search-source";
  * (e.g. "openviking").
  */
 export function addStash(opts) {
-    const { target, name, providerType, options: providerOptions } = opts;
+    const { target, name, providerType, options: providerOptions, writable } = opts;
     const config = loadUserConfig();
     const stashes = [...(config.stashes ?? [])];
-    const isUrl = target.startsWith("http://") || target.startsWith("https://");
+    const isRemoteUrl = target.startsWith("http://") ||
+        target.startsWith("https://") ||
+        target.startsWith("git@") ||
+        target.startsWith("ssh://") ||
+        target.startsWith("git://");
     let entry;
-    if (isUrl) {
+    if (isRemoteUrl) {
         if (!providerType) {
             throw new UsageError("--provider is required for URL sources (e.g. --provider openviking)");
         }
@@ -27,6 +31,8 @@ export function addStash(opts) {
         entry = { type: providerType, url: target };
         if (name)
             entry.name = name;
+        if (writable)
+            entry.writable = true;
         if (providerOptions)
             entry.options = providerOptions;
     }
@@ -51,7 +57,11 @@ export function addStash(opts) {
 export function removeStash(target) {
     const config = loadUserConfig();
     const stashes = [...(config.stashes ?? [])];
-    const isUrl = target.startsWith("http://") || target.startsWith("https://");
+    const isUrl = target.startsWith("http://") ||
+        target.startsWith("https://") ||
+        target.startsWith("git@") ||
+        target.startsWith("ssh://") ||
+        target.startsWith("git://");
     const resolvedPath = !isUrl ? path.resolve(target) : undefined;
     // Try URL match first, then path, then name (most specific → least specific)
     let idx = -1;