akm-cli 0.8.6 → 0.8.14

package/dist/commands/{source-clone.js → sources/source-clone.js}

@@ -3,13 +3,13 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
-import { makeAssetRef, parseAssetRef } from "../core/asset-ref";
-import { TYPE_DIRS } from "../core/asset-spec";
-import { NotFoundError, UsageError } from "../core/errors";
-import { findSourceForPath, getPrimarySource, resolveSourceEntries } from "../indexer/search-source";
-import { isRemoteOrigin, resolveSourcesForOrigin } from "../registry/origin-resolve";
-import { syncFromRef } from "../sources/providers/sync-from-ref";
-import { resolveAssetPath } from "../sources/resolve";
+import { makeAssetRef, parseAssetRef } from "../../core/asset/asset-ref.js";
+import { TYPE_DIRS } from "../../core/asset/asset-spec.js";
+import { NotFoundError, UsageError } from "../../core/errors.js";
+import { findSourceForPath, getPrimarySource, resolveSourceEntries, } from "../../indexer/search/search-source.js";
+import { isRemoteOrigin, resolveSourcesForOrigin } from "../../registry/origin-resolve.js";
+import { syncFromRef } from "../../sources/providers/sync-from-ref.js";
+import { resolveAssetPath } from "../../sources/resolve.js";
 export async function akmClone(options) {
     const parsed = parseAssetRef(options.sourceRef);
     // When --dest is provided, the working stash is optional

package/dist/commands/{source-manage.js → sources/source-manage.js}

@@ -2,10 +2,10 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import path from "node:path";
-import { isRemoteUrl } from "../core/common";
-import { getSources, loadConfig, loadUserConfig, saveConfig } from "../core/config";
-import { ConfigError, UsageError } from "../core/errors";
-import { resolveSourceEntries } from "../indexer/search-source";
+import { isRemoteUrl } from "../../core/common.js";
+import { getSources, loadConfig, loadUserConfig, saveConfig } from "../../core/config/config.js";
+import { ConfigError, UsageError } from "../../core/errors.js";
+import { resolveSourceEntries } from "../../indexer/search/search-source.js";
 // ── Operations ──────────────────────────────────────────────────────────────
 /**
  * Add a stash source (filesystem path or remote provider URL) to config.

package/dist/commands/sources/sources-cli.js

@@ -0,0 +1,305 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Source-management CLI commands — `akm list/remove/update/upgrade/sync/clone/history`.
+ *
+ * Extracted verbatim from src/cli.ts (WS6). Each `main.subCommands.<key>`
+ * registration line stays byte-identical; the args/output shape of every
+ * subcommand is unchanged. The `--kind` filter helper (`parseKindFilter` +
+ * `VALID_SOURCE_KINDS`), the `runSyncBody` git-commit/push body, and the
+ * `wasFormatValueConsumedAsName` citty-mis-parse workaround are used ONLY by
+ * this cluster, so they move with it.
+ *
+ * Leaf handlers whose body is a plain `runWithJsonErrors(async () => { … })`
+ * are migrated to `defineJsonCommand`, which emits the same JSON envelope
+ * (stdout/stderr/exit-code) as the inline form. `sync` keeps `defineCommand`
+ * because its `run` delegates to `runSyncBody` (which owns the
+ * `runWithJsonErrors` wrapper) rather than wrapping inline.
+ */
+import { defineCommand } from "citty";
+import { defineJsonCommand, output, runWithJsonErrors } from "../../cli/shared.js";
+import { loadConfig } from "../../core/config/config.js";
+import { UsageError } from "../../core/errors.js";
+import { appendEvent } from "../../core/events.js";
+import { resolveSourceEntries } from "../../indexer/search/search-source.js";
+import { getHyphenatedBoolean, parseFlagValue } from "../../output/context.js";
+import { resolveWritableOverride, saveGitStash } from "../../sources/providers/git.js";
+import { pkgVersion } from "../../version.js";
+import { akmHistory } from "./history.js";
+import { akmListSources, akmRemove, akmUpdate } from "./installed-stashes.js";
+import { checkForUpdate, performUpgrade } from "./self-update.js";
+import { akmClone } from "./source-clone.js";
+const VALID_SOURCE_KINDS = new Set(["local", "managed", "remote"]);
+function parseKindFilter(raw) {
+    if (!raw)
+        return undefined;
+    const kinds = raw.split(",").map((s) => s.trim());
+    for (const k of kinds) {
+        if (!VALID_SOURCE_KINDS.has(k)) {
+            throw new UsageError(`Invalid --kind value: "${k}". Expected one of: local, managed, remote`);
+        }
+    }
+    return kinds;
+}
+export const listCommand = defineJsonCommand({
+    meta: { name: "list", description: "List all sources (local directories, managed packages, remote providers)" },
+    args: {
+        kind: { type: "string", description: "Filter by source kind (local, managed, remote). Comma-separated." },
+    },
+    async run({ args }) {
+        const kind = parseKindFilter(args.kind);
+        const result = await akmListSources({ kind });
+        output("list", result);
+    },
+});
+export const removeCommand = defineJsonCommand({
+    meta: { name: "remove", description: "Remove a source by id, ref, path, URL, or name" },
+    args: {
+        target: { type: "positional", description: "Source to remove (id, ref, path, URL, or name)", required: true },
+        yes: { type: "boolean", alias: "y", description: "Skip confirmation prompt", default: false },
+    },
+    async run({ args }) {
+        const { confirmDestructive } = await import("../../cli/confirm.js");
+        const confirmed = await confirmDestructive(`Remove source "${args.target}"? This cannot be undone.`, {
+            yes: args.yes === true,
+        });
+        if (!confirmed) {
+            process.stderr.write("Aborted.\n");
+            return;
+        }
+        const result = await akmRemove({ target: args.target });
+        appendEvent({
+            eventType: "remove",
+            metadata: {
+                target: args.target,
+                ref: typeof result.removed?.ref === "string" ? result.removed.ref : null,
+                id: typeof result.removed?.id === "string" ? result.removed.id : null,
+            },
+        });
+        output("remove", result);
+    },
+});
+export const updateCommand = defineJsonCommand({
+    meta: { name: "update", description: "Update one or all managed sources" },
+    args: {
+        target: { type: "positional", description: "Source to update (id or ref)", required: false },
+        all: { type: "boolean", description: "Update all installed entries", default: false },
+        force: { type: "boolean", description: "Force fresh download even if version is unchanged", default: false },
+    },
+    async run({ args }) {
+        const result = await akmUpdate({ target: args.target, all: args.all, force: args.force });
+        appendEvent({
+            eventType: "update",
+            metadata: {
+                target: args.target ?? null,
+                all: args.all === true,
+                force: args.force === true,
+                processed: Array.isArray(result.processed)
+                    ? result.processed.length
+                    : 0,
+            },
+        });
+        output("update", result);
+    },
+});
+export const upgradeCommand = defineJsonCommand({
+    meta: { name: "upgrade", description: "Upgrade akm to the latest release" },
+    args: {
+        check: { type: "boolean", description: "Check for updates without installing", default: false },
+        force: { type: "boolean", description: "Force upgrade even if on latest", default: false },
+        "skip-checksum": {
+            type: "boolean",
+            description: "Skip checksum verification (not recommended)",
+            default: false,
+        },
+        "skip-post-upgrade": {
+            type: "boolean",
+            description: "Skip the post-upgrade `akm index` rebuild (config auto-migration still runs on next `akm` invocation)",
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const check = await checkForUpdate(pkgVersion);
+        if (args.check) {
+            output("upgrade", check);
+            return;
+        }
+        const skipChecksum = getHyphenatedBoolean(args, "skip-checksum");
+        const skipPostUpgrade = getHyphenatedBoolean(args, "skip-post-upgrade");
+        const result = await performUpgrade(check, { force: args.force, skipChecksum, skipPostUpgrade });
+        output("upgrade", result);
+    },
+});
+// `sync` body. Kept as a standalone function so the git-commit/push logic and
+// the `--format`-as-name workaround stay in one place.
+async function runSyncBody(args, verb) {
+    await runWithJsonErrors(async () => {
+        // Fix: citty can consume `--format json` (space-separated) as the
+        // positional `name` argument (e.g. `akm sync --format json` parses
+        // name="json"). Detect the mis-parse by checking argv order — only
+        // treat the positional as consumed by --format when --format appears
+        // before any standalone occurrence of the same value in the sync
+        // subcommand's argv slice. This preserves legitimate invocations
+        // like `akm sync json --format json`.
+        const parsedFormat = parseFlagValue(process.argv, "--format");
+        const effectiveName = args.name !== undefined &&
+            parsedFormat !== undefined &&
+            args.name === parsedFormat &&
+            wasFormatValueConsumedAsName(args.name, parsedFormat, verb)
+            ? undefined
+            : args.name;
+        let writable;
+        if (effectiveName === undefined) {
+            // Primary stash — honour the root-level writable flag from config.
+            writable = resolveWritableOverride(loadConfig());
+        }
+        const result = saveGitStash(effectiveName, args.message, writable, { push: args.push !== false });
+        appendEvent({
+            eventType: "save",
+            metadata: {
+                name: effectiveName ?? null,
+                message: args.message ?? null,
+                ok: result.ok !== false,
+            },
+        });
+        output("save", result);
+    });
+}
+export const syncCommand = defineCommand({
+    meta: {
+        name: "sync",
+        description: "Sync changes in a git-backed stash: commits (and pushes when writable + remote is configured). No-op for non-git stashes.",
+    },
+    args: {
+        name: {
+            type: "positional",
+            description: "Name of the git stash to sync (default: primary stash directory)",
+            required: false,
+        },
+        message: {
+            type: "string",
+            alias: "m",
+            description: "Commit message (default: timestamp)",
+        },
+        push: {
+            type: "boolean",
+            description: "Push after commit when writable + remote configured (use --no-push to commit only). Default: true.",
+            default: true,
+        },
+    },
+    async run({ args }) {
+        await runSyncBody(args, "sync");
+    },
+});
+/**
+ * Detect whether `--format <value>` was consumed by citty as the optional
+ * `name` positional of `akm sync`. Returns true only when `--format` appears
+ * in the sync subcommand's argv slice AND the candidate name does NOT
+ * appear as a standalone positional elsewhere (before or after the flag).
+ *
+ * This keeps `akm sync json --format json` routing `json` as the stash name,
+ * while `akm sync --format json` (no separate positional) is treated as a
+ * primary-stash sync. `verb` is the subcommand token to anchor on.
+ */
+function wasFormatValueConsumedAsName(name, formatValue, verb) {
+    const argv = process.argv.slice(2);
+    const verbIndex = argv.indexOf(verb);
+    const tokens = verbIndex >= 0 ? argv.slice(verbIndex + 1) : argv;
+    let formatIndex = -1;
+    let formatConsumesNextToken = false;
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        if (token === "--format") {
+            formatIndex = i;
+            formatConsumesNextToken = true;
+            break;
+        }
+        if (token === `--format=${formatValue}`) {
+            formatIndex = i;
+            break;
+        }
+    }
+    if (formatIndex === -1)
+        return false;
+    // If the name appears as a standalone token before --format, it's the
+    // real positional and --format did not consume it.
+    if (tokens.slice(0, formatIndex).includes(name))
+        return false;
+    // If --format has a space-separated value, skip past the value token
+    // when scanning after the flag; otherwise start right after the flag.
+    const firstTokenAfterFormat = formatIndex + (formatConsumesNextToken ? 2 : 1);
+    if (tokens.slice(firstTokenAfterFormat).includes(name))
+        return false;
+    return true;
+}
+export const cloneCommand = defineJsonCommand({
+    meta: {
+        name: "clone",
+        description: "Clone an asset from any source into the working stash or a custom destination",
+    },
+    args: {
+        ref: { type: "positional", description: "Asset ref (e.g. npm:@scope/pkg//script:deploy.sh)", required: true },
+        name: { type: "string", description: "New name for the cloned asset" },
+        force: { type: "boolean", description: "Overwrite if asset already exists in working stash", default: false },
+        dest: { type: "string", description: "Destination directory (default: working stash)" },
+    },
+    async run({ args }) {
+        const result = await akmClone({
+            sourceRef: args.ref,
+            newName: args.name,
+            force: args.force,
+            dest: args.dest,
+        });
+        output("clone", result);
+    },
+});
+export const historyCommand = defineJsonCommand({
+    meta: {
+        name: "history",
+        description: "Show mutation/usage history for a single asset (--ref) or stash-wide.\n\n" +
+            "Event sources:\n" +
+            "  usage_events (default): search, show, and feedback events from the local index.\n" +
+            "  state.db events (--include-proposals): proposal lifecycle events (promoted, rejected)\n" +
+            "    emitted by `akm accept` / `akm reject`.\n\n" +
+            "Results from all active sources are merged and sorted chronologically.",
+    },
+    args: {
+        ref: { type: "string", description: "Asset ref (type:name). Omit for stash-wide history." },
+        since: { type: "string", description: "ISO timestamp or epoch ms — only events on/after this time" },
+        generator: {
+            type: "string",
+            description: 'Filter by event generator: "user" (default) or "improve" (akm improve operations).',
+        },
+        "include-proposals": {
+            type: "boolean",
+            description: "Also include proposal lifecycle events (promoted, rejected) from state.db events. " +
+                "Default: false (usage_events only).",
+            default: false,
+        },
+        "accept-rate-by-source": {
+            type: "boolean",
+            description: "Compute accept-rate-per-source metrics from the proposal store and include them in the output (F-4 / #385). " +
+                "Useful for measuring which generators (reflect, distill, …) produce the most accepted proposals.",
+            default: false,
+        },
+        format: { type: "string", description: "Output format (json|jsonl|text|yaml)" },
+    },
+    async run({ args }) {
+        const generatorFlag = args.generator;
+        if (generatorFlag !== undefined && generatorFlag !== "user" && generatorFlag !== "improve") {
+            throw new UsageError(`Invalid --generator value: "${generatorFlag}". Must be "user" or "improve".`, "INVALID_FLAG_VALUE");
+        }
+        const sources = resolveSourceEntries();
+        const stashDir = sources[0]?.path;
+        const result = await akmHistory({
+            ref: args.ref,
+            since: args.since,
+            source: generatorFlag,
+            includeProposals: args["include-proposals"],
+            acceptRateBySource: args["accept-rate-by-source"],
+            stashDir,
+        });
+        output("history", result);
+    },
+});

package/dist/commands/sources/stash-cli.js

@@ -0,0 +1,219 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Stash-lifecycle command cluster — the create/index/ingest/inspect verbs for
+ * the working stash and its index database: `akm init` (create the stash +
+ * persist stashDir), `akm index` (build/refresh the search index), `akm import`
+ * (ingest a knowledge doc/URL), `akm db` (+ nested `backups` — inspect the
+ * SQLite data dir), and `akm info` (system capabilities + index stats).
+ * Extracted verbatim from src/cli.ts (WS6) so the God Module shrinks; the
+ * `main.subCommands.{init,index,import,db,info}` keys and every subcommand's
+ * args/output shape stay byte-identical.
+ *
+ * These share no private helper with any command still inline in cli.ts — every
+ * dependency is already exported from a shared module (core/paths, core/warn,
+ * core/errors, core/events, output/context, cli/shared, cli/parse-args, plus the
+ * per-command implementations in ./init, ./indexer, ./info, ./db-cli, ./knowledge,
+ * ./core/asset-create, ./core/common), so the cluster moves with zero hoisting.
+ *
+ * The leaf handlers whose body is a plain `runWithJsonErrors(...) + output(...)`
+ * (`init`, `import`, `info`, `db`, `db backups`) are migrated onto
+ * `defineJsonCommand`, which emits the same JSON envelope (stdout/stderr/
+ * exit-code) as the inline form. `index` keeps a plain `defineCommand` wrapping
+ * `runWithJsonErrors` because its body owns a spinner, an AbortController, and
+ * SIGINT/SIGTERM handlers in a try/finally — left byte-for-byte untouched.
+ */
+import path from "node:path";
+import * as p from "@clack/prompts";
+import { defineCommand } from "citty";
+import { hasSubcommand } from "../../cli/parse-args.js";
+import { defineJsonCommand, output, runWithJsonErrors } from "../../cli/shared.js";
+import { assertFlatAssetName } from "../../core/asset/asset-create.js";
+import { isHttpUrl } from "../../core/common.js";
+import { UsageError } from "../../core/errors.js";
+import { appendEvent } from "../../core/events.js";
+import { getCacheDir } from "../../core/paths.js";
+import { clearLogFile, info, isVerbose, setLogFile } from "../../core/warn.js";
+import { akmIndex } from "../../indexer/indexer.js";
+import { getHyphenatedBoolean, getOutputMode, parseFlagValue } from "../../output/context.js";
+import { akmDbBackups } from "../db-cli.js";
+import { readKnowledgeInput, writeMarkdownAsset } from "../read/knowledge.js";
+import { assembleInfo } from "./info.js";
+import { akmInit } from "./init.js";
+export const initCommand = defineJsonCommand({
+    meta: {
+        name: "init",
+        description: "Initialize akm's working stash directory and persist stashDir in config",
+    },
+    args: {
+        dir: { type: "string", description: "Custom stash directory path (default: ~/akm)" },
+    },
+    async run({ args }) {
+        // Accept both historical spellings for backwards compatibility with
+        // older docs/scripts that used `--stashDir`.
+        const legacyDir = parseFlagValue(process.argv, "--stashDir") ?? parseFlagValue(process.argv, "--stash-dir");
+        const result = await akmInit({ dir: args.dir ?? legacyDir });
+        output("init", result);
+    },
+});
+export const indexCommand = defineCommand({
+    meta: { name: "index", description: "Build search index (incremental by default; --full forces full reindex)" },
+    args: {
+        full: { type: "boolean", description: "Force full reindex", default: false },
+        clean: {
+            type: "boolean",
+            description: "After indexing, remove any entries whose source file no longer exists on disk.",
+            default: false,
+        },
+        "dry-run": {
+            type: "boolean",
+            description: "When combined with --clean, report stale entries without deleting them.",
+            default: false,
+        },
+    },
+    async run({ args }) {
+        await runWithJsonErrors(async () => {
+            if (getHyphenatedBoolean(args, "enrich") || parseFlagValue(process.argv, "--enrich") !== undefined) {
+                throw new UsageError("`akm index --enrich` has been removed. Plain `akm index` now performs metadata enrichment by default.");
+            }
+            if (getHyphenatedBoolean(args, "re-enrich") || parseFlagValue(process.argv, "--re-enrich") !== undefined) {
+                throw new UsageError("`akm index --re-enrich` has been removed. Re-enrichment of index-time LLM passes is not exposed in this slice.");
+            }
+            const outputMode = getOutputMode();
+            const controller = new AbortController();
+            const abort = () => controller.abort(new Error("index interrupted"));
+            process.once("SIGINT", abort);
+            process.once("SIGTERM", abort);
+            const indexLogFile = path.join(getCacheDir(), "logs", "index", `${new Date().toISOString().replace(/[:.]/g, "-")}.log`);
+            setLogFile(indexLogFile);
+            const verbose = isVerbose();
+            const spin = !verbose && outputMode.format === "text" ? p.spinner() : null;
+            if (spin) {
+                spin.start(`Building search index${args.full ? " (full rebuild)" : ""}...`);
+            }
+            let latestMessage = "";
+            try {
+                const result = await akmIndex({
+                    full: args.full,
+                    clean: args.clean,
+                    dryRun: args["dry-run"],
+                    onProgress: ({ phase, message, processed, total }) => {
+                        latestMessage = message;
+                        const progressPrefix = processed !== undefined && total !== undefined ? `[${processed}/${total}] ` : "";
+                        if (verbose) {
+                            info(`[index:${phase}] ${progressPrefix}${message}`);
+                        }
+                        else if (spin) {
+                            spin.stop(`${progressPrefix}${message}`);
+                            spin.start(`${progressPrefix}${message}`);
+                        }
+                    },
+                    signal: controller.signal,
+                });
+                if (spin) {
+                    spin.stop(`Indexed ${result.totalEntries} assets.`);
+                }
+                output("index", result);
+            }
+            catch (error) {
+                if (spin) {
+                    spin.stop(latestMessage ? `Indexing failed after: ${latestMessage}` : "Indexing failed.");
+                }
+                throw error;
+            }
+            finally {
+                clearLogFile();
+                process.off("SIGINT", abort);
+                process.off("SIGTERM", abort);
+            }
+        });
+    },
+});
+export const infoCommand = defineJsonCommand({
+    meta: { name: "info", description: "Show system capabilities, configuration, and index stats" },
+    run() {
+        const result = assembleInfo();
+        output("info", result);
+    },
+});
+// MVP DB administration. Currently only `akm db backups`; restore is manual —
+// stop akm and run `scripts/migrations/restore-data-dir.sh <backup>`.
+// Single source of truth: the routing set is derived from the subCommands keys
+// (M10) so adding a subcommand can never silently desync from `hasSubcommand`.
+const dbSubCommands = {
+    backups: defineJsonCommand({
+        meta: {
+            name: "backups",
+            description: "List pre-upgrade snapshots of the data directory (newest first). Backups are created automatically before destructive DB version upgrades unless AKM_DB_BACKUP=0.",
+        },
+        run() {
+            output("db-backups", akmDbBackups());
+        },
+    }),
+};
+const DB_SUBCOMMAND_SET = new Set(Object.keys(dbSubCommands));
+export const dbCommand = defineJsonCommand({
+    meta: {
+        name: "db",
+        description: "Inspect the AKM SQLite data directory. Currently exposes `backups`; to restore from a snapshot, stop akm and run scripts/migrations/restore-data-dir.sh against the chosen backup.",
+    },
+    subCommands: dbSubCommands,
+    run({ args }) {
+        if (hasSubcommand(args, DB_SUBCOMMAND_SET))
+            return;
+        // Default action: list backups.
+        output("db-backups", akmDbBackups());
+    },
+});
+export const importKnowledgeCommand = defineJsonCommand({
+    meta: {
+        name: "import",
+        description: "Import a knowledge document or URL into the default stash",
+    },
+    args: {
+        source: {
+            type: "positional",
+            description: 'Source file path, URL, or "-" to read from stdin',
+            required: true,
+        },
+        name: {
+            type: "string",
+            description: "Knowledge name (flat, no '/'; defaults to the source filename or content slug). Use --path for a subdirectory.",
+        },
+        path: {
+            type: "string",
+            description: "Relative subdirectory under knowledge/ to place the document in (e.g. 'projects/example'). The filename still comes from --name or the source slug.",
+        },
+        force: {
+            type: "boolean",
+            description: "Overwrite an existing knowledge document with the same name",
+            default: false,
+        },
+        target: {
+            type: "string",
+            description: "Override the write destination. Accepts a source name from your config; falls back to defaultWriteTarget then the working stash.",
+        },
+    },
+    async run({ args }) {
+        // `--name` is a flat name; subdirectory placement is `--path`'s job.
+        assertFlatAssetName(args.name);
+        const { content, preferredName } = await readKnowledgeInput(args.source);
+        const result = await writeMarkdownAsset({
+            type: "knowledge",
+            content,
+            name: args.name ?? (isHttpUrl(args.source) ? preferredName : undefined),
+            fallbackPrefix: "knowledge",
+            preferredName,
+            force: args.force,
+            target: args.target,
+            path: args.path,
+        });
+        appendEvent({
+            eventType: "import",
+            ref: result.ref,
+            metadata: { source: args.source, path: result.path, force: args.force === true },
+        });
+        output("import", { ok: true, source: args.source, ...result });
+    },
+});

package/dist/commands/{stash-skeleton.js → sources/stash-skeleton.js}

@@ -3,7 +3,8 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
-const SKELETON_DIR = path.join(import.meta.dir, "../assets/stash-skeleton");
+import { getDirname } from "../../runtime.js";
+const SKELETON_DIR = path.join(getDirname(import.meta.url), "../../assets/stash-skeleton");
 /**
  * Copy the default stash skeleton into a newly created stash directory.
  *