@hobble-env/cli 3.3.7 → 3.3.9

package/SKILL.md

@@ -7,7 +7,7 @@ description: Use when a repository contains a `.hobble` file, references the hob
 
 > **Living document.** This file is the canonical agent-facing reference for the hobble CLI surface. Per the gate in `AGENTS.md`, any feature work that changes the CLI surface (commands, flags, arguments, output formats, exit behavior, env vars, or config files) MUST update this file in the same change, and it must be verified current before every PR. Source of truth: `cli/bin/hobble.ts` and `cli/commands/*.ts`.
 
-<!-- documented-version: 3.2.0 — keep in sync with cli/bin/hobble.ts -->
+<!-- documented-version: 3.3.8 — keep in sync with cli/bin/hobble.ts -->
 
 ## Overview
 
@@ -37,7 +37,7 @@ In this repo, the CLI runs from source: `npm run hobble -- <command>` (or `npx t
 5. **Do not run interactive commands unprompted.** `hobble login`, `hobble init`, and `hobble switch` modify user or repo state. Ask the user to run them, or explicitly confirm before doing so.
 6. **Never run `hobble env push -y` without showing the diff first.** Omit `-y` (or run once without it) so the user can review create/update/delete counts.
 
-## Command Surface (v3.2.0)
+## Command Surface (v3.3.8)
 
 Global options: `-v, --verbose` (debug output on stderr), `-V, --version`.
 
@@ -118,11 +118,20 @@ All commands exit `0` on success and `1` on any failure (not found, auth, networ
 
 Each data command needs a `project` and `environment`, resolved in order:
 1. `--project` / `--env` flags on the command
-2. `.hobble` in the current working directory
+2. The nearest `.hobble` found by walking **up** from the current working
+   directory to the filesystem root (like `git`/`npm`/`eslint` root-config
+   discovery). The deepest ancestor wins, so running a command from a
+   subdirectory of a project resolves the project-root `.hobble`. An `apiUrl`
+   pin in that resolved `.hobble` is honored the same way.
 3. Error: `No project configured. Run \`hobble init\` or pass \`--project\` and \`--env\`.`
 
 If you hit that error, stop and ask the user. Do not run `hobble init` on their behalf — it is interactive and binds the directory to a project.
 
+`hobble switch` rewrites the discovered ancestor `.hobble` in place (it does not
+orphan a new config in a subdirectory). `hobble init`, by contrast, always
+writes `.hobble` into the current directory — it is how you declare where the
+project root is.
+
 ## Authentication
 
 - Stored config: `~/.config/hobble/config.json` (written by `hobble login` / `hobble init`). Shape: `{ "apiUrl": "<default instance>", "credentials": { "<instance url>": { "type": "apiKey" | "session", ... } } }` — one credential per instance URL, so logins to multiple instances coexist. Older single-credential config files migrate automatically on first read.

package/dist/bin/hobble.js

@@ -20,7 +20,7 @@ const program = new Command();
 program
     .name("hobble")
     .description("CLI for managing secrets via the secret-management-dash API")
-    .version("3.3.6")
+    .version("3.3.8")
     .enablePositionalOptions()
     .option("-v, --verbose", "Show debug output for troubleshooting");
 program.hook("preAction", (thisCommand) => {

package/dist/commands/init.js

@@ -54,6 +54,13 @@ export const initCommand = new Command("init")
         // Pin the instance in .hobble when --url named one explicitly, and
         // preserve a pin a previous init/switch already wrote.
         const pinnedUrl = opts.url ? apiUrl : existing?.apiUrl;
+        // init intentionally binds *this* directory: it writes .hobble (and the
+        // gitignore entry below) into process.cwd() via the default `dir`
+        // argument, even though loadProjectConfig/findProjectConfig now walk up
+        // to discover an ancestor config. This is deliberate — `init` is how a
+        // user declares "the project root is here", so it must not silently
+        // mutate an ancestor's .hobble. `switch`, by contrast, rewrites the
+        // discovered ancestor in place.
         await saveProjectConfig({
             project: selectedProject.name,
             environment: envName,

package/dist/commands/switch.js

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import { api } from "../lib/api.js";
-import { loadProjectConfig, saveProjectConfig } from "../lib/project-config.js";
+import { findProjectConfig, saveProjectConfig } from "../lib/project-config.js";
 import { success, error } from "../lib/output.js";
 export const switchCommand = new Command("switch")
     .description("Switch project and environment")
@@ -27,13 +27,17 @@ export const switchCommand = new Command("switch")
             error(`Environment "${envName}" not found in project "${projectName}".`);
             process.exit(1);
         }
+        // Anchor the write on the nearest ancestor .hobble so a switch from a
+        // subdirectory rewrites the existing config in place instead of
+        // orphaning a new .hobble in cwd. Fall back to cwd when none exists.
         // Keep an instance pin from a previous `init --url` intact.
-        const existing = await loadProjectConfig();
+        const existing = await findProjectConfig();
+        const targetDir = existing?.dir ?? process.cwd();
         await saveProjectConfig({
             project: projectName,
             environment: envName,
-            ...(existing?.apiUrl ? { apiUrl: existing.apiUrl } : {}),
-        });
+            ...(existing?.config.apiUrl ? { apiUrl: existing.config.apiUrl } : {}),
+        }, targetDir);
         success(`Switched to ${projectName}/${envName}`);
     }
     catch (err) {

package/dist/lib/project-config.d.ts

@@ -8,15 +8,33 @@ export interface ProjectConfig {
      */
     apiUrl?: string;
 }
+export interface FoundProjectConfig {
+    config: ProjectConfig;
+    /** Absolute directory that contains the discovered .hobble. */
+    dir: string;
+}
+/**
+ * Walk up from `startDir` (default cwd) to the filesystem root, returning the
+ * nearest ancestor that contains a parseable .hobble plus the directory it
+ * lives in. The walk stops when `dirname(dir) === dir` (filesystem root) and
+ * returns null if no .hobble is found along the way — mirroring how git/npm/
+ * eslint discover their root config.
+ *
+ * A .hobble that exists but fails to read/parse is treated like "not here" and
+ * the walk continues upward, so the nearest *valid* ancestor wins. This keeps
+ * the historical swallow-and-return-null tolerance (an unparseable cwd .hobble
+ * previously yielded null) while being strictly more forgiving.
+ */
+export declare function findProjectConfig(startDir?: string): Promise<FoundProjectConfig | null>;
 export declare function loadProjectConfig(): Promise<ProjectConfig | null>;
-export declare function saveProjectConfig(config: ProjectConfig): Promise<void>;
+export declare function saveProjectConfig(config: ProjectConfig, dir?: string): Promise<void>;
 /**
  * Returns true when the project's .gitignore already contains an entry for
  * the project config file (PROJECT_CONFIG_FILE). Returns false when the
  * .gitignore exists but does not mention it, or when .gitignore is missing.
  */
-export declare function isHobbleInGitignore(): Promise<boolean>;
-export declare function addToGitignore(): Promise<void>;
+export declare function isHobbleInGitignore(dir?: string): Promise<boolean>;
+export declare function addToGitignore(dir?: string): Promise<void>;
 export interface ResolvedContext {
     project: string;
     environment: string;

package/dist/lib/project-config.js

@@ -1,25 +1,49 @@
 import { readFile, writeFile, appendFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
 const PROJECT_CONFIG_FILE = ".hobble";
-export async function loadProjectConfig() {
-    try {
-        const raw = await readFile(PROJECT_CONFIG_FILE, "utf-8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
+/**
+ * Walk up from `startDir` (default cwd) to the filesystem root, returning the
+ * nearest ancestor that contains a parseable .hobble plus the directory it
+ * lives in. The walk stops when `dirname(dir) === dir` (filesystem root) and
+ * returns null if no .hobble is found along the way — mirroring how git/npm/
+ * eslint discover their root config.
+ *
+ * A .hobble that exists but fails to read/parse is treated like "not here" and
+ * the walk continues upward, so the nearest *valid* ancestor wins. This keeps
+ * the historical swallow-and-return-null tolerance (an unparseable cwd .hobble
+ * previously yielded null) while being strictly more forgiving.
+ */
+export async function findProjectConfig(startDir = process.cwd()) {
+    let dir = startDir;
+    for (;;) {
+        const candidate = join(dir, PROJECT_CONFIG_FILE);
+        try {
+            const raw = await readFile(candidate, "utf-8");
+            return { config: JSON.parse(raw), dir };
+        }
+        catch {
+            // Not present (or unreadable/unparseable) here — keep walking up.
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null; // reached filesystem root
+        dir = parent;
     }
 }
-export async function saveProjectConfig(config) {
-    await writeFile(PROJECT_CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+export async function loadProjectConfig() {
+    const found = await findProjectConfig();
+    return found?.config ?? null;
+}
+export async function saveProjectConfig(config, dir = process.cwd()) {
+    await writeFile(join(dir, PROJECT_CONFIG_FILE), JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 /**
  * Returns true when the project's .gitignore already contains an entry for
  * the project config file (PROJECT_CONFIG_FILE). Returns false when the
  * .gitignore exists but does not mention it, or when .gitignore is missing.
  */
-export async function isHobbleInGitignore() {
-    const gitignorePath = join(process.cwd(), ".gitignore");
+export async function isHobbleInGitignore(dir = process.cwd()) {
+    const gitignorePath = join(dir, ".gitignore");
     try {
         const content = await readFile(gitignorePath, "utf-8");
         return content.includes(PROJECT_CONFIG_FILE);
@@ -28,8 +52,8 @@ export async function isHobbleInGitignore() {
         return false;
     }
 }
-export async function addToGitignore() {
-    const gitignorePath = join(process.cwd(), ".gitignore");
+export async function addToGitignore(dir = process.cwd()) {
+    const gitignorePath = join(dir, ".gitignore");
     try {
         const content = await readFile(gitignorePath, "utf-8");
         if (content.includes(PROJECT_CONFIG_FILE))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hobble-env/cli",
-  "version": "3.3.7",
+  "version": "3.3.9",
   "description": "CLI for managing secrets via hobble",
   "type": "module",
   "repository": {
@@ -9,7 +9,7 @@
     "directory": "cli"
   },
   "bin": {
-    "hobble": "./dist/bin/hobble.js"
+    "hobble": "dist/bin/hobble.js"
   },
   "files": [
     "dist",