@dev_desh/flux-cap 0.1.2 → 0.2.0

package/README.md

@@ -6,6 +6,46 @@
 
 flux-cap is a terminal-native tool that captures your thoughts, tracks your context, and integrates seamlessly with your git workflow. Built specifically for developers who context-switch frequently.
 
+## Installation
+
+Install flux-cap globally using your preferred package manager:
+
+```bash
+# Using npm
+npm install -g @dev_desh/flux-cap
+
+# Using pnpm  
+pnpm install -g @dev_desh/flux-cap
+
+# Using bun
+bun install -g @dev_desh/flux-cap
+```
+
+## Quick Start
+
+### 1. Initialize flux-cap in your project root folder
+```bash
+flux init
+```
+*Interactive setup will ask about your privacy preferences*
+
+### 2. Start capturing thoughts
+```bash
+flux dump "remember to add error handling to auth module"
+flux dump "bug in user validation - check line 42" 
+flux dump "idea: add dark mode toggle"
+```
+
+### 3. Search your brain dumps
+```bash
+# Search with a query
+flux search "auth"
+
+# List recent dumps (no query)
+flux search
+```
+
+
 ## Features
 
 ### Brain Dump System
@@ -32,53 +72,96 @@ flux-cap is a terminal-native tool that captures your thoughts, tracks your cont
 - .gitignore management
 - Works in non-git directories too
 
-## Installation
+### Parent Directory Support
+- Initialize flux-cap once in your project root and use it from any subdirectory
+- Automatically discovers `.flux` configuration by traversing up the directory tree
+- No need to initialize in every subfolder - works project-wide
+- Seamlessly handles monorepos and complex project structures
 
-```bash
-# Clone the repository
-git clone https://github.com/yourusername/flux-cap
-cd flux-cap
 
-# Install dependencies
-bun install
+## Commands
 
-# Run locally
-bun run dev <command>
-```
+| Command | Description | Example |
+|---------|-------------|---------|
+| `flux init` | Initialize flux-cap with privacy setup | `flux init` |
+| `flux dump <message...>` | Capture a brain dump | `flux dump "fix the bug in auth.ts"` |
+| `flux search [query...]` | Search brain dumps or list recent ones | `flux search "authentication"` |
+| `flux config <fields...>` | View or update configuration | `flux config` |
+| `flux reset` | Complete reset (deletes all data) | `flux reset` |
 
-## Quick Start
+## Use Cases
+
+### Context Switching
+```bash
+# Before switching tasks
+flux dump "was working on user auth, next: add validation to login form"
+
+# After interruption  
+flux search "auth"  # Quickly find where you left off
+```
 
-### 1. Initialize flux-cap in your project
+### Bug Tracking
 ```bash
-bun run dev init
+flux dump "weird bug in payment flow - users can't checkout"
+flux dump "bug seems related to session timeout"
+
+# Later...
+flux search "payment bug"
 ```
-*Interactive setup will ask about your privacy preferences*
 
-### 2. Start capturing thoughts
+### Idea Capture
 ```bash
-bun run dev dump "remember to add error handling to auth module"
-bun run dev dump "bug in user validation - check line 42"
-bun run dev dump "idea: add dark mode toggle"
+flux dump "idea: add keyboard shortcuts to dashboard" 
+flux dump "maybe use React.memo for performance optimization"
 ```
 
-### 3. Search your brain dumps
+## Automated Versioning
+
+flux-cap uses [Changesets](https://github.com/changesets/changesets) for automated semantic versioning:
+
+### What happens when you merge a PR:
+1. **Automatic Analysis**: GitHub Actions analyzes your PR changes
+2. **Smart Version Bumping**: Determines appropriate version (major/minor/patch) based on:
+   - PR title and description
+   - Commit messages  
+   - Files changed
+3. **Changelog Generation**: Creates detailed changelog entries
+4. **Version Updates**: Updates `package.json` automatically
+5. **Git Integration**: Commits changes back to main branch
+
+### Version Bump Rules:
+- **Major** (`1.0.0 → 2.0.0`): Breaking changes, removed features, incompatible API changes
+- **Minor** (`1.0.0 → 1.1.0`): New features, new commands, backwards-compatible enhancements
+- **Patch** (`1.0.0 → 1.0.1`): Bug fixes, documentation updates, refactoring, performance improvements
+
+### Manual Changesets:
 ```bash
-# Search with a query
-bun run dev search "auth"
+# Add a changeset manually (if needed)
+bun run changeset
 
-# List recent dumps (no query)
-bun run dev search
-```
+# Check pending changesets
+bun run changeset:status
 
-## Commands
+# Apply version changes locally
+bun run changeset:version
 
-| Command | Description | Example |
-|---------|-------------|---------|
-| `flux init` | Initialize flux-cap with privacy setup | `bun run dev init` |
-| `flux dump <message...>` | Capture a brain dump | `bun run dev dump "fix the bug in auth.ts"` |
-| `flux search [query...]` | Search brain dumps or list recent ones | `bun run dev search "authentication"` |
-| `flux config <fields...>` | View or update configuration | `bun run dev config` |
-| `flux reset` | Complete reset (deletes all data) | `bun run dev reset` |
+## Development
+
+Want to contribute or run locally?
+
+```bash
+# Clone and setup
+git clone https://github.com/yourusername/flux-cap
+cd flux-cap
+bun install
+
+# Run in development mode
+bun run dev <command>
+
+# Build and test locally  
+bun run build
+npm link
+```
 
 ## Configuration
 
@@ -211,6 +294,31 @@ src/
 
 This is currently a personal learning project, but feedback and suggestions are welcome!
 
+How to control version bumps:
+
+### Method 1: Use GitHub Labels
+Add these labels to your repository and apply them to PRs:
+- `major` or `breaking` → Major version bump
+- `minor` or `feature` → Minor version bump  
+- `patch` or `bugfix` → Patch version bump
+
+### Method 2: Use PR Title Syntax
+Start your PR title with the version type in brackets:
+- `[major] Remove deprecated API endpoints`
+- `[minor] Add new search command` 
+- `[patch] Fix memory leak in dump command`
+
+### Method 3: Automatic Detection (Conservative)
+The system will now only auto-detect major bumps with very explicit indicators like:
+- "breaking change"
+- "breaking:"
+- "major:"
+- "!breaking"
+- "remove api"
+- "delete command"
+
+**Everything else defaults to patch unless you have clear feature indicators for minor.**
+
 ## License
 
 MIT

package/dist/index.js

@@ -7861,10 +7861,10 @@ var require_lib2 = __commonJS((exports) => {
   exports.analyse = analyse;
   var detectFile = (filepath, opts = {}) => new Promise((resolve, reject) => {
     let fd;
-    const fs = (0, node_1.default)();
+    const fs2 = (0, node_1.default)();
     const handler = (err, buffer) => {
       if (fd) {
-        fs.closeSync(fd);
+        fs2.closeSync(fd);
       }
       if (err) {
         reject(err);
@@ -7876,9 +7876,9 @@ var require_lib2 = __commonJS((exports) => {
     };
     const sampleSize = (opts === null || opts === undefined ? undefined : opts.sampleSize) || 0;
     if (sampleSize > 0) {
-      fd = fs.openSync(filepath, "r");
+      fd = fs2.openSync(filepath, "r");
       let sample = Buffer.allocUnsafe(sampleSize);
-      fs.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+      fs2.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
         if (err) {
           handler(err, null);
         } else {
@@ -7890,22 +7890,22 @@ var require_lib2 = __commonJS((exports) => {
       });
       return;
     }
-    fs.readFile(filepath, handler);
+    fs2.readFile(filepath, handler);
   });
   exports.detectFile = detectFile;
   var detectFileSync = (filepath, opts = {}) => {
-    const fs = (0, node_1.default)();
+    const fs2 = (0, node_1.default)();
     if (opts && opts.sampleSize) {
-      const fd = fs.openSync(filepath, "r");
+      const fd = fs2.openSync(filepath, "r");
       let sample = Buffer.allocUnsafe(opts.sampleSize);
-      const bytesRead = fs.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+      const bytesRead = fs2.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
       if (bytesRead < opts.sampleSize) {
         sample = sample.subarray(0, bytesRead);
       }
-      fs.closeSync(fd);
+      fs2.closeSync(fd);
       return (0, exports.detect)(sample);
     }
-    return (0, exports.detect)(fs.readFileSync(filepath));
+    return (0, exports.detect)(fs2.readFileSync(filepath));
   };
   exports.detectFileSync = detectFileSync;
   exports.default = {
@@ -20625,7 +20625,7 @@ var {
 } = import__.default;
 
 // src/commands/init.command.ts
-import fs from "fs";
+import fs2 from "fs";
 
 // src/utils/constants.ts
 var FLUX_FOLDER_PATH = ".flux/";
@@ -20645,7 +20645,7 @@ var FLUX_DEFAULT_CONFIG = {
     hideUncommittedChanges: false
   },
   search: {
-    searchFields: ["message", "workingDir", "branch", "tags"],
+    searchFields: ["message", "workingDir", "branch", "tags", "id"],
     resultLimit: 10,
     fuseOptions: {
       threshold: 0.3,
@@ -20681,21 +20681,40 @@ function getCurrentBranch(config) {
   }
 }
 // src/utils/lib.ts
+import fs from "fs";
+import path from "path";
+async function getFluxPath() {
+  const cwd = process.cwd();
+  let fullPath = cwd.split(path.sep);
+  while (true) {
+    let parentPath = fullPath.join(path.sep) + "/.flux";
+    if (fs.existsSync(parentPath)) {
+      return parentPath.split(".flux")[0];
+      break;
+    }
+    fullPath.pop();
+    if (fullPath.length === 0) {
+      break;
+    }
+  }
+  console.error("No .flux directory found in the current or parent directories. Please run 'flux init' to initialize.");
+  process.exit(1);
+}
 async function createIfNotExists(folderPath, type, data) {
   try {
-    const fs = await import("fs");
-    if (!fs.existsSync(folderPath)) {
+    const fs2 = await import("fs");
+    if (!fs2.existsSync(folderPath)) {
       if (type === "file") {
-        fs.writeFileSync(folderPath, data || "");
+        fs2.writeFileSync(folderPath, data || "");
         return;
       }
-      fs.mkdirSync(folderPath, { recursive: true });
+      fs2.mkdirSync(folderPath, { recursive: true });
     } else {
       if (type === "file") {
         try {
-          const stats = fs.statSync(folderPath);
+          const stats = fs2.statSync(folderPath);
           if (stats.size === 0 && data) {
-            fs.writeFileSync(folderPath, data);
+            fs2.writeFileSync(folderPath, data);
           }
         } catch (writeError) {
           if (writeError.code === "EACCES" || writeError.code === "EPERM") {
@@ -20705,7 +20724,7 @@ async function createIfNotExists(folderPath, type, data) {
         }
       } else {
         try {
-          fs.accessSync(folderPath, fs.constants.W_OK);
+          fs2.accessSync(folderPath, fs2.constants.W_OK);
         } catch (accessError) {
           if (accessError.code === "EACCES" || accessError.code === "EPERM") {
             throw new Error(`No write permissions for directory: ${folderPath}`);
@@ -20717,24 +20736,24 @@ async function createIfNotExists(folderPath, type, data) {
     throw error;
   }
 }
-async function createBrainDumpFileIfNotExists(dateString) {
-  await createIfNotExists(`${FLUX_BRAIN_DUMP_PATH}${dateString}.json`, "file", JSON.stringify({
+async function createBrainDumpFileIfNotExists(dateString, fluxPath) {
+  await createIfNotExists(`${fluxPath}${FLUX_BRAIN_DUMP_PATH}${dateString}.json`, "file", JSON.stringify({
     fluxVersion: "0.0.1",
     month: dateString,
     dumps: []
   }));
 }
-async function getConfigFile() {
-  const fs = await import("fs");
-  const configPath = `${FLUX_CONFIG_PATH}`;
-  let config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+async function getConfigFile(fluxPath) {
+  const fs2 = await import("fs");
+  const configPath = `${fluxPath}${FLUX_CONFIG_PATH}`;
+  let config = JSON.parse(fs2.readFileSync(configPath, "utf8"));
   return config;
 }
-async function getAllBrainDumpFilePaths() {
-  const fs = await import("fs");
-  const path = await import("path");
-  const files = fs.readdirSync(FLUX_BRAIN_DUMP_PATH);
-  return files.filter((file) => file.endsWith(".json")).map((file) => path.join(FLUX_BRAIN_DUMP_PATH, file));
+async function getAllBrainDumpFilePaths(fluxPath) {
+  const fs2 = await import("fs");
+  const path2 = await import("path");
+  const files = fs2.readdirSync(fluxPath + FLUX_BRAIN_DUMP_PATH);
+  return files.filter((file) => file.endsWith(".json")).map((file) => path2.join(fluxPath + FLUX_BRAIN_DUMP_PATH, file));
 }
 // src/utils/helper.ts
 function getMonthString() {
@@ -20743,9 +20762,79 @@ function getMonthString() {
   const month = String(currentDate.getMonth() + 1).padStart(2, "0");
   return `${year}-${month}`;
 }
-function searchResultFormat({ message, timestamp, score, index }) {
-  const formattedTimestamp = new Date(timestamp).toLocaleString();
-  return `${index !== undefined ? index + 1 : ""}. [${score || "0.00"}] [${formattedTimestamp}] ${message}`;
+function displaySearchResults(results, query) {
+  if (results.length === 0) {
+    if (query) {
+      console.log(`No brain dumps found matching "${query}"`);
+    } else {
+      console.log("No brain dumps found. Try 'flux dump' to create your first one!");
+    }
+    return;
+  }
+  const queryText = query ? ` for "${query}"` : "";
+  console.log(`
+Found ${results.length} brain dump${results.length === 1 ? "" : "s"}${queryText}:
+`);
+  const terminalWidth = process.stdout.columns || 80;
+  const maxIndexWidth = results.length.toString().length;
+  results.forEach((result, index) => {
+    const dump = result.item;
+    const score = result.score?.toFixed(2) || "0.00";
+    const shortId = dump.id.substring(0, 8);
+    const indexStr = `${(index + 1).toString().padStart(maxIndexWidth)}`;
+    const scoreStr = `[${score}]`;
+    const idStr = `${shortId}`;
+    const headerLine = `${indexStr} ${idStr} ${scoreStr}`;
+    console.log(headerLine);
+    const messageIndent = " ".repeat(maxIndexWidth + 1);
+    const lines = dump.message.split(`
+`).map((l) => l.trim()).filter((l) => l.length > 0);
+    const availableWidth = terminalWidth - messageIndent.length - 2;
+    if (lines.length === 0) {
+      console.log(`${messageIndent}(empty message)`);
+    } else {
+      lines.forEach((line, lineIndex) => {
+        if (lineIndex < 3) {
+          const truncatedLine = line.length > availableWidth ? line.substring(0, availableWidth - 3) + "..." : line;
+          console.log(`${messageIndent}${truncatedLine}`);
+        }
+      });
+      if (lines.length > 3) {
+        console.log(`${messageIndent}... (+${lines.length - 3} more line${lines.length - 3 === 1 ? "" : "s"})`);
+      }
+    }
+    const contextInfo = [];
+    const date = new Date(dump.timestamp);
+    const timeAgo = getTimeAgo(date);
+    contextInfo.push("----------------");
+    contextInfo.push(`${timeAgo}`);
+    contextInfo.push("----------------");
+    contextInfo.push(`
+`);
+    if (dump.branch && dump.branch !== "main") {
+      contextInfo.push(`${dump.branch}${dump.hasUncommittedChanges ? " (uncommitted)" : ""}`);
+    }
+    if (contextInfo.length > 0) {
+      console.log(`${messageIndent}${contextInfo.join(" • ")}`);
+    }
+    console.log("");
+  });
+  console.log(`!! Use the 8-character ID (like ${results[0]?.item.id.substring(0, 8)}) to reference specific dumps
+`);
+}
+function getTimeAgo(date) {
+  const now = new Date;
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / (1000 * 60));
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffMins < 60)
+    return `${diffMins}m ago`;
+  if (diffHours < 24)
+    return `${diffHours}h ago`;
+  if (diffDays < 7)
+    return `${diffDays}d ago`;
+  return date.toLocaleDateString();
 }
 // node_modules/@inquirer/core/dist/lib/key.js
 var isUpKey = (key, keybindings = []) => key.name === "up" || keybindings.includes("vim") && key.name === "k" || keybindings.includes("emacs") && key.ctrl && key.name === "p";
@@ -22328,16 +22417,16 @@ var dist_default4 = createPrompt((config, done) => {
 `).trimEnd();
   return `${lines}${cursorHide}`;
 });
-// node_modules/@inquirer/external-editor/dist/index.js
+// node_modules/@inquirer/editor/node_modules/@inquirer/external-editor/dist/index.js
 var import_chardet = __toESM(require_lib2(), 1);
 var import_iconv_lite = __toESM(require_lib3(), 1);
 import { spawn, spawnSync } from "child_process";
 import { readFileSync, unlinkSync, writeFileSync } from "fs";
-import path from "node:path";
+import path2 from "node:path";
 import os from "node:os";
 import { randomUUID } from "node:crypto";
 
-// node_modules/@inquirer/external-editor/dist/errors/CreateFileError.js
+// node_modules/@inquirer/editor/node_modules/@inquirer/external-editor/dist/errors/CreateFileError.js
 class CreateFileError extends Error {
   originalError;
   constructor(originalError) {
@@ -22346,7 +22435,7 @@ class CreateFileError extends Error {
   }
 }
 
-// node_modules/@inquirer/external-editor/dist/errors/LaunchEditorError.js
+// node_modules/@inquirer/editor/node_modules/@inquirer/external-editor/dist/errors/LaunchEditorError.js
 class LaunchEditorError extends Error {
   originalError;
   constructor(originalError) {
@@ -22355,7 +22444,7 @@ class LaunchEditorError extends Error {
   }
 }
 
-// node_modules/@inquirer/external-editor/dist/errors/ReadFileError.js
+// node_modules/@inquirer/editor/node_modules/@inquirer/external-editor/dist/errors/ReadFileError.js
 class ReadFileError extends Error {
   originalError;
   constructor(originalError) {
@@ -22364,7 +22453,7 @@ class ReadFileError extends Error {
   }
 }
 
-// node_modules/@inquirer/external-editor/dist/errors/RemoveFileError.js
+// node_modules/@inquirer/editor/node_modules/@inquirer/external-editor/dist/errors/RemoveFileError.js
 class RemoveFileError extends Error {
   originalError;
   constructor(originalError) {
@@ -22373,7 +22462,7 @@ class RemoveFileError extends Error {
   }
 }
 
-// node_modules/@inquirer/external-editor/dist/index.js
+// node_modules/@inquirer/editor/node_modules/@inquirer/external-editor/dist/index.js
 function editAsync(text = "", callback, fileOptions) {
   const editor = new ExternalEditor(text, fileOptions);
   editor.runAsync((err, result) => {
@@ -22469,8 +22558,8 @@ class ExternalEditor {
       const prefix = sanitizeAffix(this.fileOptions.prefix);
       const postfix = sanitizeAffix(this.fileOptions.postfix);
       const filename = `${prefix}${id}${postfix}`;
-      const candidate = path.resolve(baseDir, filename);
-      const baseResolved = path.resolve(baseDir) + path.sep;
+      const candidate = path2.resolve(baseDir, filename);
+      const baseResolved = path2.resolve(baseDir) + path2.sep;
       if (!candidate.startsWith(baseResolved)) {
         throw new Error("Resolved temporary file escaped the base directory");
       }
@@ -23408,9 +23497,9 @@ var import_run_async = __toESM(require_run_async(), 1);
 var import_mute_stream2 = __toESM(require_lib(), 1);
 import readline3 from "node:readline";
 var _ = {
-  set: (obj, path2 = "", value) => {
+  set: (obj, path3 = "", value) => {
     let pointer = obj;
-    path2.split(".").forEach((key, index, arr) => {
+    path3.split(".").forEach((key, index, arr) => {
       if (key === "__proto__" || key === "constructor")
         return;
       if (index === arr.length - 1) {
@@ -23421,8 +23510,8 @@ var _ = {
       pointer = pointer[key];
     });
   },
-  get: (obj, path2 = "", defaultValue) => {
-    const travel = (regexp) => String.prototype.split.call(path2, regexp).filter(Boolean).reduce((res, key) => res == null ? res : res[key], obj);
+  get: (obj, path3 = "", defaultValue) => {
+    const travel = (regexp) => String.prototype.split.call(path3, regexp).filter(Boolean).reduce((res, key) => res == null ? res : res[key], obj);
     const result = travel(/[,[\]]+?/) || travel(/[,.[\]]+?/);
     return result === undefined || result === obj ? defaultValue : result;
   }
@@ -23706,22 +23795,22 @@ async function initFluxCommand() {
     process.exit(1);
   }
   try {
-    if (fs.existsSync(".git/")) {
+    if (fs2.existsSync(".git/")) {
       console.log("Git repository detected.");
     } else {
       console.log("Not a git repository. Skipping git integration.");
     }
-    if (fs.existsSync(".gitignore")) {
+    if (fs2.existsSync(".gitignore")) {
       console.log("Gitignore file exists");
-      const gitignoreContent = fs.readFileSync(".gitignore", "utf8");
+      const gitignoreContent = fs2.readFileSync(".gitignore", "utf8");
       if (gitignoreContent.includes(FLUX_FOLDER_PATH)) {
         console.log(".flux is already in .gitignore");
       } else {
-        fs.appendFileSync(".gitignore", `
+        fs2.appendFileSync(".gitignore", `
 ${FLUX_FOLDER_PATH}`);
       }
     } else {
-      fs.writeFileSync(".gitignore", ".flux");
+      fs2.writeFileSync(".gitignore", ".flux");
       console.log("Created .gitignore file.");
     }
   } catch (error) {
@@ -23733,6 +23822,7 @@ ${FLUX_FOLDER_PATH}`);
 }
 var resetFluxCommand = async () => {
   console.log("Resetting Flux Capacitor...");
+  const fluxPath = await getFluxPath() + FLUX_FOLDER_PATH;
   const { confirmed } = await dist_default14.prompt([{
     type: "confirm",
     name: "confirmed",
@@ -23744,8 +23834,8 @@ var resetFluxCommand = async () => {
     return;
   }
   try {
-    if (fs.existsSync(FLUX_FOLDER_PATH)) {
-      fs.rmSync(FLUX_FOLDER_PATH, { recursive: true, force: true });
+    if (fs2.existsSync(fluxPath)) {
+      fs2.rmSync(fluxPath, { recursive: true, force: true });
       console.log("Removed .flux directory and all its contents.");
     } else {
       console.log("Flux Capacitor is not initialized in this repository.");
@@ -23759,27 +23849,61 @@ var resetFluxCommand = async () => {
 
 // src/commands/dump.command.ts
 import { randomUUID as randomUUID2 } from "crypto";
-async function brainDumpAddCommand(message) {
-  const fs2 = await import("fs");
+async function handleBrainDump(message, options) {
+  try {
+    let finalMessage;
+    if (options.multiline) {
+      console.log("Opening editor for multiline input...");
+      const initialText = message ? message.join(" ") : "";
+      const multilineInput = await dist_default5({
+        message: "Enter your brain dump (save & exit when done):",
+        default: initialText,
+        waitForUserInput: false
+      });
+      if (!multilineInput.trim()) {
+        console.log("Brain dump cancelled - no content provided");
+        return;
+      }
+      finalMessage = multilineInput.trim();
+    } else {
+      if (!message || message.length === 0) {
+        console.log('Please provide a message: flux dump "your message"');
+        return;
+      }
+      finalMessage = message.join(" ");
+    }
+    await brainDumpAddCommand(finalMessage, { multiline: options.multiline });
+  } catch (error) {
+    console.error("Error creating brain dump:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+async function brainDumpAddCommand(message, options = {}) {
+  const fluxPath = await getFluxPath();
+  const fs3 = await import("fs");
   console.log("Creating brain dump...");
   const monthString = getMonthString();
-  await createBrainDumpFileIfNotExists(monthString);
-  const config = await getConfigFile();
+  await createBrainDumpFileIfNotExists(monthString, fluxPath);
+  const config = await getConfigFile(fluxPath);
   const workingDir = await getWorkingDir(config);
   const branch = getCurrentBranch(config);
   const hasUncommittedChanges = getGitUncommittedChanges(config);
   const newDump = {
     id: randomUUID2(),
     timestamp: new Date().toISOString(),
-    message: message.join(" "),
+    message,
     workingDir,
     branch,
     hasUncommittedChanges
   };
-  const data = JSON.parse(fs2.readFileSync(`${FLUX_BRAIN_DUMP_PATH}/${monthString}.json`, "utf8"));
+  const data = JSON.parse(fs3.readFileSync(`${fluxPath}${FLUX_BRAIN_DUMP_PATH}/${monthString}.json`, "utf8"));
   config.sorted ? data.dumps.unshift(newDump) : data.dumps.push(newDump);
-  fs2.writeFileSync(`${FLUX_BRAIN_DUMP_PATH}/${monthString}.json`, JSON.stringify(data, null, 2));
-  console.log(`✅ Brain dump saved: "${message.join(" ")}"`);
+  fs3.writeFileSync(`${fluxPath}${FLUX_BRAIN_DUMP_PATH}/${monthString}.json`, JSON.stringify(data, null, 2));
+  const displayMessage = message.length > 50 ? message.substring(0, 47) + "..." : message;
+  const preview = message.includes(`
+`) ? `${message.split(`
+`)[0]}... (multiline)` : displayMessage;
+  console.log(`✅ Brain dump saved: "${preview}"`);
 }
 
 // node_modules/fuse.js/dist/fuse.mjs
@@ -23854,14 +23978,14 @@ class KeyStore {
   }
 }
 function createKey(key) {
-  let path2 = null;
+  let path3 = null;
   let id = null;
   let src = null;
   let weight = 1;
   let getFn = null;
   if (isString(key) || isArray(key)) {
     src = key;
-    path2 = createKeyPath(key);
+    path3 = createKeyPath(key);
     id = createKeyId(key);
   } else {
     if (!hasOwn.call(key, "name")) {
@@ -23875,11 +23999,11 @@ function createKey(key) {
         throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
       }
     }
-    path2 = createKeyPath(name);
+    path3 = createKeyPath(name);
     id = createKeyId(name);
     getFn = key.getFn;
   }
-  return { path: path2, id, weight, src, getFn };
+  return { path: path3, id, weight, src, getFn };
 }
 function createKeyPath(key) {
   return isArray(key) ? key : key.split(".");
@@ -23887,34 +24011,34 @@ function createKeyPath(key) {
 function createKeyId(key) {
   return isArray(key) ? key.join(".") : key;
 }
-function get(obj, path2) {
+function get(obj, path3) {
   let list = [];
   let arr = false;
-  const deepGet = (obj2, path3, index) => {
+  const deepGet = (obj2, path4, index) => {
     if (!isDefined(obj2)) {
       return;
     }
-    if (!path3[index]) {
+    if (!path4[index]) {
       list.push(obj2);
     } else {
-      let key = path3[index];
+      let key = path4[index];
       const value = obj2[key];
       if (!isDefined(value)) {
         return;
       }
-      if (index === path3.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {
+      if (index === path4.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {
         list.push(toString(value));
       } else if (isArray(value)) {
         arr = true;
         for (let i = 0, len = value.length;i < len; i += 1) {
-          deepGet(value[i], path3, index + 1);
+          deepGet(value[i], path4, index + 1);
         }
-      } else if (path3.length) {
-        deepGet(value, path3, index + 1);
+      } else if (path4.length) {
+        deepGet(value, path4, index + 1);
       }
     }
   };
-  deepGet(obj, isString(path2) ? path2.split(".") : path2, 0);
+  deepGet(obj, isString(path3) ? path3.split(".") : path3, 0);
   return arr ? list : list[0];
 }
 var MatchOptions = {
@@ -25086,58 +25210,51 @@ function createFuseInstance(data, config) {
 }
 
 // src/commands/search.command.ts
-import fs2 from "fs";
+import fs3 from "fs";
 async function searchBrainDumpCommand(query) {
   console.log("Searching all brain dumps...");
-  const config = await getConfigFile();
-  const monthString = getMonthString();
+  const fluxPath = await getFluxPath();
+  const config = await getConfigFile(fluxPath);
+  const searchQuery = query.join(" ").trim();
   let searchResults = [];
-  const allFilePaths = await getAllBrainDumpFilePaths();
+  const allFilePaths = await getAllBrainDumpFilePaths(fluxPath);
   for await (const filePath of allFilePaths) {
-    const fileData = JSON.parse(fs2.readFileSync(filePath, "utf8"));
-    const fuse = createFuseInstance(fileData.dumps, config);
-    const results = fuse.search(query.join(" "));
-    searchResults.push(...results);
-    if (searchResults.length > 30) {
-      break;
+    const fileData = JSON.parse(fs3.readFileSync(filePath, "utf8"));
+    if (searchQuery) {
+      const fuse = createFuseInstance(fileData.dumps, config);
+      const results = fuse.search(searchQuery);
+      searchResults.push(...results);
+    } else {
+      const recentDumps = fileData.dumps.filter((dump) => dump && dump.message && dump.message.trim() !== "").map((dump) => ({
+        item: dump,
+        score: 0,
+        timestamp: new Date(dump.timestamp).getTime()
+      }));
+      searchResults.push(...recentDumps);
     }
   }
-  if (query.length > 0) {
-    if (searchResults.length === 0) {
-      console.log("No brain dumps found matching the query.");
-      return;
-    }
-    const resultLimit = config?.search?.resultLimit || 10;
-    const limitedResults = searchResults.slice(0, resultLimit);
-    console.log(`Found ${searchResults.length} brain dumps matching the query${searchResults.length > resultLimit ? ` (showing first ${resultLimit})` : ""}:`);
-    limitedResults.forEach((result, index) => {
-      const dump = result.item;
-      console.log(searchResultFormat({ index, timestamp: dump.timestamp, message: dump.message, score: result.score?.toFixed(2) }));
-    });
+  if (searchQuery) {
+    searchResults.sort((a, b) => (a.score || 0) - (b.score || 0));
   } else {
-    const resultLimit = config?.search?.resultLimit || 3;
-    let totalCount = 0;
-    for await (const filePath of allFilePaths) {
-      if (totalCount >= resultLimit) {
-        break;
-      }
-      const fileData = JSON.parse(fs2.readFileSync(filePath, "utf8"));
-      for (let i = 0;i < fileData.dumps.length && totalCount < resultLimit; i++) {
-        const dump = fileData.dumps[i];
-        if (!dump || !dump.message || dump.message.trim() === "") {
-          continue;
-        }
-        totalCount += 1;
-        console.log(searchResultFormat({ index: totalCount, timestamp: dump.timestamp, message: dump.message, score: "0.00" }));
-      }
-    }
+    searchResults.sort((a, b) => {
+      const timeA = new Date(a.item.timestamp).getTime();
+      const timeB = new Date(b.item.timestamp).getTime();
+      return timeB - timeA;
+    });
   }
+  const resultLimit = config?.search?.resultLimit || (searchQuery ? 10 : 5);
+  const limitedResults = searchResults.slice(0, resultLimit);
+  if (searchResults.length > limitedResults.length) {
+    console.log(`
+(Showing ${limitedResults.length} of ${searchResults.length} results)`);
+  }
+  displaySearchResults(limitedResults, searchQuery || undefined);
 }
 
 // src/commands/config.command.ts
 async function configCommand(fields) {
   console.log("This command is still to be implemented");
-  const fs3 = await import("fs");
+  const fs4 = await import("fs");
   const config = await getConfigFile();
   const value = fields[fields.length - 1];
   const keys = fields.slice(0, -1)[0]?.split(".").map((k) => k.trim()) || [];
@@ -25151,7 +25268,8 @@ async function configCommand(fields) {
 // package.json
 var package_default = {
   name: "@dev_desh/flux-cap",
-  version: "0.1.2",
+  type: "module",
+  version: "0.2.0",
   description: "Git-aware CLI context manager for ADHD developers",
   bin: {
     flux: "./dist/index.js"
@@ -25165,8 +25283,15 @@ var package_default = {
     build: "bun build src/index.ts --outdir dist --target node --format esm",
     dev: "bun run src/index.ts",
     prepublishOnly: "bun run build",
+    publish: "npm publish --access=public",
     "local-install": "bun run build && npm link",
-    "local-uninstall": "npm unlink -g flux-cap"
+    "local-uninstall": "npm unlink -g flux-cap",
+    "local-reinstall": "bun run local-uninstall && bun run local-install",
+    changeset: "changeset",
+    "changeset:add": "changeset add",
+    "changeset:status": "changeset status",
+    "changeset:version": "changeset version",
+    "changeset:publish": "changeset publish"
   },
   engines: {
     node: ">=18.0.0"
@@ -25184,6 +25309,7 @@ var package_default = {
     inquirer: "^13.2.5"
   },
   devDependencies: {
+    "@changesets/cli": "^2.29.8",
     "@types/inquirer": "^9.0.9"
   },
   repository: {
@@ -25197,7 +25323,9 @@ var program2 = new Command;
 program2.name(`flux`).description("Git-aware CLI context manager for ADHD developers").version(package_default.version);
 program2.command("init").description("Initialize flux in the current repository").action(initFluxCommand);
 program2.command("reset").description("Resets flux in the current repository").action(resetFluxCommand);
-program2.command("dump <message...>").description("Add a brain dump with a message. You can also include tags by using #tag in the message.").action(brainDumpAddCommand);
+program2.command("dump [message...]").option("-m, --multiline", "Enable multiline input mode").description("Add a brain dump with a message. Use --multiline for multi-line input.").action(async (message, options) => {
+  await handleBrainDump(message, options);
+});
 program2.command("search [query...]").description("Search brain dumps with a query. If no query is provided, lists all brain dumps for the current month.").action((query) => {
   searchBrainDumpCommand(query ? query : [""]);
 });

package/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "@dev_desh/flux-cap",
-	"version": "0.1.2",
+	"type": "module",
+	"version": "0.2.0",
 	"description": "Git-aware CLI context manager for ADHD developers",
 	"bin": {
 		"flux": "./dist/index.js"
@@ -14,8 +15,15 @@
 		"build": "bun build src/index.ts --outdir dist --target node --format esm",
 		"dev": "bun run src/index.ts",
 		"prepublishOnly": "bun run build",
+		"publish": "npm publish --access=public",
 		"local-install": "bun run build && npm link",
-		"local-uninstall": "npm unlink -g flux-cap"
+		"local-uninstall": "npm unlink -g flux-cap",
+		"local-reinstall": "bun run local-uninstall && bun run local-install",
+		"changeset": "changeset",
+		"changeset:add": "changeset add",
+		"changeset:status": "changeset status",
+		"changeset:version": "changeset version",
+		"changeset:publish": "changeset publish"
 	},
 	"engines": {
 		"node": ">=18.0.0"
@@ -33,6 +41,7 @@
 		"inquirer": "^13.2.5"
 	},
 	"devDependencies": {
+		"@changesets/cli": "^2.29.8",
 		"@types/inquirer": "^9.0.9"
 	},
 	"repository": {