@the-coded/pstash 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,286 @@
+import { z } from 'zod';
+
+/**
+ * @module schemas
+ *
+ * Zod as Single Source of Truth (SSoT) for all types.
+ *
+ * **Rule**: No manual `interface` or `type` declarations anywhere in the codebase.
+ * All types are derived via `z.infer<typeof Schema>`.
+ *
+ * Validation happens at every I/O boundary:
+ * - Reading `.stash.json` and `.project.json` files
+ * - Reading `~/.pstashrc` config
+ * - Parsing CLI options
+ *
+ * @example
+ * // Parse and validate untrusted data
+ * const metadata = StashMetadataSchema.parse(JSON.parse(rawJson))
+ *
+ * // Get TypeScript type from schema
+ * type Metadata = z.infer<typeof StashMetadataSchema>
+ */
+
+/**
+ * Represents a single file entry within a stash.
+ *
+ * @example
+ * const file: StashFile = {
+ *   name: "README.md",
+ *   size: 1024,
+ *   hash: "sha256:a1b2c3d4e5f6"
+ * }
+ */
+declare const StashFileSchema: z.ZodObject<{
+    name: z.ZodString;
+    size: z.ZodNumber;
+    hash: z.ZodString;
+}, z.core.$strip>;
+type StashFile = z.infer<typeof StashFileSchema>;
+/**
+ * Metadata stored in `.stash.json` inside each stash directory.
+ * Created by `Stasher.save()`, read by `Stasher.loadMetadata()`.
+ *
+ * @example
+ * // Stash directory structure:
+ * // my-personal-stash/scena/2026-03-12_01-05_k7x2/.stash.json
+ */
+declare const StashMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    project: z.ZodString;
+    timestamp: z.ZodString;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    branch: z.ZodOptional<z.ZodString>;
+    commit: z.ZodOptional<z.ZodString>;
+    user: z.ZodOptional<z.ZodString>;
+    files: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        size: z.ZodNumber;
+        hash: z.ZodString;
+    }, z.core.$strip>>;
+    totalSize: z.ZodNumber;
+    compressed: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type StashMetadata = z.infer<typeof StashMetadataSchema>;
+/**
+ * Metadata stored in `.project.json` at the project directory root.
+ * Managed by `Indexer` — updated after every save/delete.
+ *
+ * @example
+ * // my-personal-stash/scena/.project.json
+ * {
+ *   "name": "scena",
+ *   "stashCount": 3,
+ *   "totalSize": "268 KB"
+ * }
+ */
+declare const ProjectMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    remote: z.ZodOptional<z.ZodString>;
+    aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    stashCount: z.ZodNumber;
+    totalSize: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+type ProjectMetadata = z.infer<typeof ProjectMetadataSchema>;
+/**
+ * Per-project configuration inside `~/.pstashrc`.
+ * All fields are optional — only needed to customize behavior.
+ */
+declare const ProjectConfigSchema: z.ZodObject<{
+    aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    remote: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
+/**
+ * Global configuration stored at `~/.pstashrc`.
+ *
+ * - Location: `os.homedir() + "/.pstashrc"` (cross-platform)
+ * - Never stored inside the data repo (`my-personal-stash`)
+ * - Loaded and validated by `src/config/loader.ts`
+ *
+ * @example
+ * {
+ *   "version": "1.0.0",
+ *   "remote": "git@github.com:user/my-personal-stash.git",
+ *   "localPath": "~/.pstash",
+ *   "autoSync": true,
+ *   "projects": {},
+ *   "defaults": { "removeAfterSave": false }
+ * }
+ */
+declare const GlobalConfigSchema: z.ZodObject<{
+    version: z.ZodString;
+    remote: z.ZodString;
+    localPath: z.ZodDefault<z.ZodString>;
+    autoSync: z.ZodDefault<z.ZodBoolean>;
+    projects: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        remote: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    defaults: z.ZodObject<{
+        keepOnPop: z.ZodDefault<z.ZodBoolean>;
+        compression: z.ZodDefault<z.ZodBoolean>;
+        removeAfterSave: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type GlobalConfig = z.infer<typeof GlobalConfigSchema>;
+/**
+ * Options for the `pstash save` command.
+ *
+ * @example
+ * pstash save -t docs -t wip "planning notes" *.md
+ */
+declare const SaveOptionsSchema: z.ZodObject<{
+    message: z.ZodString;
+    files: z.ZodArray<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    project: z.ZodOptional<z.ZodString>;
+    push: z.ZodDefault<z.ZodBoolean>;
+    compress: z.ZodDefault<z.ZodBoolean>;
+    removeAfterSave: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type SaveOptions = z.infer<typeof SaveOptionsSchema>;
+/**
+ * Options for the `pstash list` command.
+ */
+declare const ListOptionsSchema: z.ZodObject<{
+    all: z.ZodDefault<z.ZodBoolean>;
+    project: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    preview: z.ZodDefault<z.ZodBoolean>;
+    json: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type ListOptions = z.infer<typeof ListOptionsSchema>;
+/**
+ * Options for `pstash pop` and `pstash apply` commands.
+ */
+declare const RestoreOptionsSchema: z.ZodObject<{
+    stashIndex: z.ZodOptional<z.ZodNumber>;
+    files: z.ZodOptional<z.ZodString>;
+    dest: z.ZodOptional<z.ZodString>;
+    keep: z.ZodDefault<z.ZodBoolean>;
+    force: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type RestoreOptions = z.infer<typeof RestoreOptionsSchema>;
+/**
+ * Options for `pstash init` command.
+ */
+declare const InitOptionsSchema: z.ZodObject<{
+    remote: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type InitOptions = z.infer<typeof InitOptionsSchema>;
+/**
+ * Options for `pstash sync` command.
+ */
+declare const SyncOptionsSchema: z.ZodObject<{
+    pull: z.ZodDefault<z.ZodBoolean>;
+    push: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type SyncOptions = z.infer<typeof SyncOptionsSchema>;
+/**
+ * Options for `pstash status` command.
+ */
+declare const StatusOptionsSchema: z.ZodObject<{
+    all: z.ZodDefault<z.ZodBoolean>;
+    json: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type StatusOptions = z.infer<typeof StatusOptionsSchema>;
+/**
+ * Options for `pstash drop` command.
+ */
+declare const DropOptionsSchema: z.ZodObject<{
+    stashIndex: z.ZodOptional<z.ZodNumber>;
+    project: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+    all: z.ZodDefault<z.ZodBoolean>;
+    force: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type DropOptions = z.infer<typeof DropOptionsSchema>;
+/**
+ * Options for `pstash clean` command (Phase 3).
+ */
+declare const CleanOptionsSchema: z.ZodObject<{
+    olderThan: z.ZodOptional<z.ZodString>;
+    keep: z.ZodOptional<z.ZodNumber>;
+    tag: z.ZodOptional<z.ZodString>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type CleanOptions = z.infer<typeof CleanOptionsSchema>;
+
+/**
+ * @module config/loader
+ *
+ * Load, save, and validate the global pstash config (`~/.pstashrc`).
+ *
+ * The config file is a JSON document validated against
+ * {@link GlobalConfigSchema}. All paths support `~/` notation, which
+ * is expanded against `os.homedir()` for cross-platform compatibility.
+ *
+ * @example
+ * ```ts
+ * import { loadConfig, updateConfig } from "pstash/config/loader"
+ *
+ * const config = await loadConfig()
+ * await updateConfig({ autoSync: false })
+ * ```
+ */
+
+/** Absolute path to the global config file */
+declare const CONFIG_PATH: string;
+/**
+ * Resolves the stash repo local path from config.
+ * Handles "~/.pstash" notation → expands to absolute path.
+ */
+declare function resolveLocalPath(localPath: string): string;
+/**
+ * Checks whether the config file exists.
+ */
+declare function configExists(): Promise<boolean>;
+/**
+ * Loads and validates ~/.pstashrc.
+ * Throws if file not found or invalid.
+ */
+declare function loadConfig(): Promise<GlobalConfig>;
+/**
+ * Saves config to ~/.pstashrc.
+ */
+declare function saveConfig(config: GlobalConfig): Promise<void>;
+/**
+ * Updates a specific key in the config.
+ */
+declare function updateConfig(updates: Partial<GlobalConfig>): Promise<GlobalConfig>;
+
+/**
+ * @module config/templates
+ *
+ * Default config templates and seed files for fresh pstash installs.
+ *
+ * Provides:
+ * - {@link createDefaultConfig} — builds a {@link GlobalConfig} from defaults
+ * - {@link DATA_REPO_README} — initial README for the data repo
+ * - {@link DATA_REPO_GITIGNORE} — initial `.gitignore` for the data repo
+ */
+
+/**
+ * Creates a default GlobalConfig for new pstash installations.
+ */
+declare function createDefaultConfig(remote: string, localPath?: string): GlobalConfig;
+/**
+ * README template for the data repo (my-personal-stash).
+ */
+declare const DATA_REPO_README = "# My Personal Stash\n\n> Managed by [pstash](https://github.com/the-coded/pstash-cli) \u2014 Git-backed personal file stash.\n\n## Structure\n\n```\nmy-personal-stash/\n\u251C\u2500\u2500 <project-name>/\n\u2502   \u251C\u2500\u2500 .project.json         # Project metadata\n\u2502   \u2514\u2500\u2500 YYYY-MM-DD_HH-mm_XXXX/  # Stash entries\n\u2502       \u251C\u2500\u2500 .stash.json       # Stash metadata\n\u2502       \u2514\u2500\u2500 <files...>\n```\n\n## Usage\n\nThis repo is managed automatically by `pstash`. Do not edit manually.\n\n```bash\npstash save \"message\" *.md    # Save files\npstash list                   # List stashes\npstash pop 0                  # Restore latest\npstash sync                   # Sync with remote\n```\n";
+/**
+ * .gitignore template for the data repo.
+ */
+declare const DATA_REPO_GITIGNORE = ".DS_Store\nThumbs.db\n*.log\n.env\n.env.*\n!.env.example\n";
+
+export { CONFIG_PATH, type CleanOptions, CleanOptionsSchema, DATA_REPO_GITIGNORE, DATA_REPO_README, type DropOptions, DropOptionsSchema, type GlobalConfig, GlobalConfigSchema, type InitOptions, InitOptionsSchema, type ListOptions, ListOptionsSchema, type ProjectConfig, ProjectConfigSchema, type ProjectMetadata, ProjectMetadataSchema, type RestoreOptions, RestoreOptionsSchema, type SaveOptions, SaveOptionsSchema, type StashFile, StashFileSchema, type StashMetadata, StashMetadataSchema, type StatusOptions, StatusOptionsSchema, type SyncOptions, SyncOptionsSchema, configExists, createDefaultConfig, loadConfig, resolveLocalPath, saveConfig, updateConfig };

package/dist/index.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+
+// src/schemas.ts
+import { z } from "zod";
+var StashFileSchema = z.object({
+  /** Original filename (basename only, no path) */
+  name: z.string(),
+  /** File size in bytes */
+  size: z.number().nonnegative(),
+  /**
+   * SHA-256 integrity hash, prefixed with "sha256:".
+   * First 12 hex chars used (48 bits) — sufficient for integrity checking.
+   * @example "sha256:a1b2c3d4e5f6"
+   */
+  hash: z.string()
+});
+var StashMetadataSchema = z.object({
+  /**
+   * Unique stash identifier.
+   * Format: `YYYY-MM-DD_HH-mm_XXXX` (timestamp + 4-char nanoid suffix).
+   * The suffix prevents collisions when multiple machines stash in the same minute.
+   * @example "2026-03-12_01-05_k7x2"
+   */
+  id: z.string(),
+  /** Project name (derived from git remote or directory name) */
+  project: z.string(),
+  /** ISO 8601 creation timestamp */
+  timestamp: z.string().datetime(),
+  /**
+   * ISO 8601 timestamp of the last `pstash update` on this stash.
+   * Absent when the stash has never been updated.
+   */
+  updatedAt: z.string().datetime().optional(),
+  /** Human-readable description of what was stashed */
+  message: z.string(),
+  /**
+   * User-defined tags for filtering and organization.
+   * @example ["docs", "planning", "wip"]
+   */
+  tags: z.array(z.string()).default([]),
+  /** Git branch at time of stash (if inside a git repo) */
+  branch: z.string().optional(),
+  /** Git commit hash at time of stash (if inside a git repo) */
+  commit: z.string().optional(),
+  /**
+   * Machine identifier of who created the stash.
+   * Format: `username@hostname` using `os.userInfo().username` (cross-platform).
+   * @example "gab@macmini"
+   */
+  user: z.string().optional(),
+  /** List of stashed files with size and integrity hash */
+  files: z.array(StashFileSchema),
+  /** Total size of all files in bytes */
+  totalSize: z.number().nonnegative(),
+  /** Whether files are stored as tar.gz (Phase 3 feature) */
+  compressed: z.boolean().default(false)
+});
+var ProjectMetadataSchema = z.object({
+  /** Project name (matches directory name in stash repo) */
+  name: z.string(),
+  /** Git remote URL for this project (informational only) */
+  remote: z.string().optional(),
+  /**
+   * Alternative names that map to this project.
+   * @example ["scena-cli", "e2e-gen"] → resolves to "scena"
+   */
+  aliases: z.array(z.string()).default([]),
+  /** Total number of stash entries for this project */
+  stashCount: z.number().nonnegative(),
+  /**
+   * Human-readable total size of all stashes.
+   * Formatted via `pretty-bytes`.
+   * @example "268 KB"
+   */
+  totalSize: z.string(),
+  /** ISO 8601 timestamp of first stash creation */
+  createdAt: z.string().datetime(),
+  /** ISO 8601 timestamp of last stash modification */
+  updatedAt: z.string().datetime()
+});
+var ProjectConfigSchema = z.object({
+  /**
+   * Alternative names that resolve to this project.
+   * @example ["e2e-gen", "scena-cli"] both map to "scena"
+   */
+  aliases: z.array(z.string()).default([]),
+  /**
+   * Override the detected git remote for this project.
+   * Useful if the project name differs from the remote.
+   */
+  remote: z.string().optional(),
+  /** Absolute path to the project directory */
+  path: z.string().optional()
+});
+var GlobalConfigSchema = z.object({
+  /** Config schema version for future migrations */
+  version: z.string(),
+  /** SSH or HTTPS URL of the personal stash data repository (SSH or HTTPS) */
+  remote: z.string().min(1, "Remote URL is required"),
+  /**
+   * Local path for the cloned stash data repo.
+   * Supports `~` expansion: `"~/.pstash"` → `"/Users/gab/.pstash"`.
+   * Resolved by `resolveLocalPath()` in `config/loader.ts`.
+   */
+  localPath: z.string().default("~/.pstash"),
+  /**
+   * Whether to automatically pull before and push after write operations
+   * (save, pop, drop, clean) and pull before read operations (list).
+   * Can be overridden per-operation with `--no-sync`.
+   */
+  autoSync: z.boolean().default(true),
+  /**
+   * Per-project overrides (aliases, custom remote, path).
+   * Key is the canonical project name.
+   */
+  projects: z.record(z.string(), ProjectConfigSchema).default({}),
+  /** Default behavior settings (can be overridden per-command) */
+  defaults: z.object({
+    /** If true, `pstash pop` keeps the stash after restoring (like apply) */
+    keepOnPop: z.boolean().default(false),
+    /** If true, compress stash files as tar.gz (Phase 3) */
+    compression: z.boolean().default(false),
+    /**
+     * If true, delete source files after `pstash save`.
+     * Can be overridden per-operation: `--rm` to force delete, `--keep` to force keep.
+     */
+    removeAfterSave: z.boolean().default(false)
+  })
+});
+var SaveOptionsSchema = z.object({
+  /** Required description of what was stashed */
+  message: z.string().min(1, "Message is required"),
+  /**
+   * File patterns to stash (glob patterns supported via globby).
+   * @example ["*.md", "src/**\/*.ts"]
+   */
+  files: z.array(z.string()).min(1, "At least one file pattern required"),
+  /** Tags for filtering and organization */
+  tags: z.array(z.string()).default([]),
+  /** Override auto-detected project name */
+  project: z.string().optional(),
+  /** Whether to push to remote after saving */
+  push: z.boolean().default(true),
+  /** Whether to compress the stash (Phase 3) */
+  compress: z.boolean().default(false),
+  /**
+   * Whether to remove source files after saving.
+   * `undefined` = use `config.defaults.removeAfterSave`.
+   * `true` (--rm) = always remove.
+   * `false` (--keep) = always keep.
+   */
+  removeAfterSave: z.boolean().optional()
+});
+var ListOptionsSchema = z.object({
+  /** Show stashes from all projects (not just current) */
+  all: z.boolean().default(false),
+  /** Filter by specific project name */
+  project: z.string().optional(),
+  /** Filter by tag */
+  tag: z.string().optional(),
+  /**
+   * Show stashes created after this timespec.
+   * @example "7d" (7 days ago), "2w", "1m", "2026-03-01"
+   */
+  since: z.string().optional(),
+  /** Show stashes created before this timespec */
+  until: z.string().optional(),
+  /** Show preview of the first non-empty line of up to the first 3 files per stash */
+  preview: z.boolean().default(false),
+  /** Output as JSON for scripting */
+  json: z.boolean().default(false)
+});
+var RestoreOptionsSchema = z.object({
+  /**
+   * Index of the stash to restore (0-based, newest first).
+   * If undefined, shows interactive selector.
+   */
+  stashIndex: z.number().int().nonnegative().optional(),
+  /**
+   * Glob pattern for partial restore (Phase 3, requires micromatch).
+   * @example "*.md" to restore only markdown files
+   */
+  files: z.string().optional(),
+  /**
+   * Destination directory for restored files.
+   * Defaults to `process.cwd()`.
+   */
+  dest: z.string().optional(),
+  /** If true, keep the stash after restoring (apply behavior) */
+  keep: z.boolean().default(false),
+  /** If true, overwrite existing files without error */
+  force: z.boolean().default(false)
+});
+var InitOptionsSchema = z.object({
+  /** SSH or HTTPS URL for the data repo (SSH or HTTPS) */
+  remote: z.string().min(1).optional(),
+  /** Local path to clone to (default: ~/.pstash) */
+  path: z.string().optional()
+});
+var SyncOptionsSchema = z.object({
+  /** Pull only (skip push) */
+  pull: z.boolean().default(false),
+  /** Push only (skip pull) */
+  push: z.boolean().default(false)
+});
+var StatusOptionsSchema = z.object({
+  /** Show status for all projects */
+  all: z.boolean().default(false),
+  /** Output as JSON for scripting */
+  json: z.boolean().default(false)
+});
+var DropOptionsSchema = z.object({
+  /** Index of the stash to drop (0-based). If undefined, shows interactive selector. */
+  stashIndex: z.number().int().nonnegative().optional(),
+  /** Limit to a specific project */
+  project: z.string().optional(),
+  /** Drop all stashes with this tag */
+  tag: z.string().optional(),
+  /** Drop all stashes in the project (requires confirmation) */
+  all: z.boolean().default(false),
+  /** Skip confirmation prompt */
+  force: z.boolean().default(false)
+});
+var CleanOptionsSchema = z.object({
+  /**
+   * Delete stashes older than this timespec.
+   * @example "30d", "2w", "1m"
+   */
+  olderThan: z.string().optional(),
+  /** Keep only N most recent stashes per project */
+  keep: z.number().int().positive().optional(),
+  /** Delete only stashes with this tag */
+  tag: z.string().optional(),
+  /** Preview what would be deleted without actually deleting */
+  dryRun: z.boolean().default(false)
+});
+
+// src/config/loader.ts
+import { readFile, writeFile, access } from "fs/promises";
+import { join, resolve } from "path";
+import { homedir } from "os";
+var CONFIG_PATH = join(homedir(), ".pstashrc");
+function resolveLocalPath(localPath) {
+  if (localPath.startsWith("~/")) {
+    return join(homedir(), localPath.slice(2));
+  }
+  if (localPath.startsWith("~")) {
+    return join(homedir(), localPath.slice(1));
+  }
+  return resolve(localPath);
+}
+async function configExists() {
+  try {
+    await access(CONFIG_PATH);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadConfig() {
+  let raw;
+  try {
+    raw = await readFile(CONFIG_PATH, "utf-8");
+  } catch {
+    throw new Error(
+      `Config file not found: ${CONFIG_PATH}
+Run "pstash init" to set up your personal stash.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Config file is not valid JSON: ${CONFIG_PATH}`);
+  }
+  const result = GlobalConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`Config validation failed:
+${issues}`);
+  }
+  return result.data;
+}
+async function saveConfig(config) {
+  const validated = GlobalConfigSchema.parse(config);
+  await writeFile(CONFIG_PATH, JSON.stringify(validated, null, 2) + "\n", "utf-8");
+}
+async function updateConfig(updates) {
+  const current = await loadConfig();
+  const merged = { ...current, ...updates };
+  const validated = GlobalConfigSchema.parse(merged);
+  await saveConfig(validated);
+  return validated;
+}
+
+// src/config/templates.ts
+function createDefaultConfig(remote, localPath = "~/.pstash") {
+  return {
+    version: "1.0.0",
+    remote,
+    localPath,
+    autoSync: true,
+    projects: {},
+    defaults: {
+      keepOnPop: false,
+      compression: false,
+      removeAfterSave: false
+    }
+  };
+}
+var DATA_REPO_README = `# My Personal Stash
+
+> Managed by [pstash](https://github.com/the-coded/pstash-cli) \u2014 Git-backed personal file stash.
+
+## Structure
+
+\`\`\`
+my-personal-stash/
+\u251C\u2500\u2500 <project-name>/
+\u2502   \u251C\u2500\u2500 .project.json         # Project metadata
+\u2502   \u2514\u2500\u2500 YYYY-MM-DD_HH-mm_XXXX/  # Stash entries
+\u2502       \u251C\u2500\u2500 .stash.json       # Stash metadata
+\u2502       \u2514\u2500\u2500 <files...>
+\`\`\`
+
+## Usage
+
+This repo is managed automatically by \`pstash\`. Do not edit manually.
+
+\`\`\`bash
+pstash save "message" *.md    # Save files
+pstash list                   # List stashes
+pstash pop 0                  # Restore latest
+pstash sync                   # Sync with remote
+\`\`\`
+`;
+var DATA_REPO_GITIGNORE = `.DS_Store
+Thumbs.db
+*.log
+.env
+.env.*
+!.env.example
+`;
+export {
+  CONFIG_PATH,
+  CleanOptionsSchema,
+  DATA_REPO_GITIGNORE,
+  DATA_REPO_README,
+  DropOptionsSchema,
+  GlobalConfigSchema,
+  InitOptionsSchema,
+  ListOptionsSchema,
+  ProjectConfigSchema,
+  ProjectMetadataSchema,
+  RestoreOptionsSchema,
+  SaveOptionsSchema,
+  StashFileSchema,
+  StashMetadataSchema,
+  StatusOptionsSchema,
+  SyncOptionsSchema,
+  configExists,
+  createDefaultConfig,
+  loadConfig,
+  resolveLocalPath,
+  saveConfig,
+  updateConfig
+};
+//# sourceMappingURL=index.js.map