granite-mem 0.1.2 → 0.1.3

package/README.md

@@ -77,7 +77,7 @@ npm run build
 npm link
 ```
 
-Create a vault and start capturing:
+Create the default vault in `~/.granite` and start capturing:
 
 ```bash
 mem init
@@ -153,8 +153,9 @@ Granite keeps the source of truth boring and durable:
 
 - notes are Markdown files
 - metadata lives in YAML frontmatter
-- vault configuration lives in `granite.yml`
-- full-text search and link resolution are backed by a local SQLite index in `.granite/index.db`
+- the default vault lives in `~/.granite`
+- vault configuration lives in `~/.granite/granite.yml`
+- full-text search and link resolution are backed by a local SQLite index in `~/.granite/index.db`
 - the index can be rebuilt from the files at any time
 
 This keeps the system transparent, portable, and inspectable.

package/dist/index.js

@@ -4,8 +4,8 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 
 // src/core/config.ts
 import fs from "fs";
@@ -116,59 +116,76 @@ function loadConfig(vaultRoot) {
   return parsed;
 }
 
+// src/core/vault.ts
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+var DEFAULT_VAULT_DIRNAME = ".granite";
+function hasVaultConfig(dir) {
+  return fs2.existsSync(path2.join(dir, CONFIG_FILENAME));
+}
+function getDefaultVaultRoot(homeDir = os.homedir()) {
+  return path2.resolve(homeDir, DEFAULT_VAULT_DIRNAME);
+}
+function findVaultRoot(from) {
+  let dir = from ? path2.resolve(from) : process.cwd();
+  while (true) {
+    if (hasVaultConfig(dir)) {
+      return dir;
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const defaultVaultRoot = getDefaultVaultRoot();
+  return hasVaultConfig(defaultVaultRoot) ? defaultVaultRoot : null;
+}
+function requireVaultRoot(from) {
+  const root = findVaultRoot(from);
+  if (!root) {
+    throw new Error(`No Granite vault found. Run "mem init" to create ${getDefaultVaultRoot()}.`);
+  }
+  return root;
+}
+function getIndexDbPath(vaultRoot) {
+  if (path2.basename(path2.resolve(vaultRoot)) === DEFAULT_VAULT_DIRNAME) {
+    return path2.join(vaultRoot, "index.db");
+  }
+  return path2.join(vaultRoot, ".granite", "index.db");
+}
+
 // src/commands/init.ts
-function initVault(dir) {
-  const targetDir = path2.resolve(dir);
-  if (fs2.existsSync(path2.join(targetDir, CONFIG_FILENAME))) {
+function initVault(dir = getDefaultVaultRoot()) {
+  const targetDir = path3.resolve(dir);
+  fs3.mkdirSync(targetDir, { recursive: true });
+  if (fs3.existsSync(path3.join(targetDir, CONFIG_FILENAME))) {
     console.error(`Vault already exists in ${targetDir}`);
     process.exit(1);
   }
   writeDefaultConfig(targetDir);
-  fs2.mkdirSync(path2.join(targetDir, ".granite"), { recursive: true });
+  fs3.mkdirSync(path3.dirname(getIndexDbPath(targetDir)), { recursive: true });
   const config = loadConfig(targetDir);
   for (const typeConfig of Object.values(config.note_types)) {
-    fs2.mkdirSync(path2.join(targetDir, typeConfig.folder), { recursive: true });
+    fs3.mkdirSync(path3.join(targetDir, typeConfig.folder), { recursive: true });
   }
   console.log(`Vault initialized in ${targetDir}`);
   console.log("");
   console.log("Created:");
   console.log(`  ${CONFIG_FILENAME}`);
-  console.log("  .granite/");
+  const indexDir = path3.relative(targetDir, path3.dirname(getIndexDbPath(targetDir)));
+  if (indexDir) {
+    console.log(`  ${indexDir}/`);
+  }
   for (const [name, typeConfig] of Object.entries(config.note_types)) {
     console.log(`  ${typeConfig.folder}/  (${name})`);
   }
   console.log("");
-  console.log('Next: mem new fleeting "My first note"');
+  console.log('Next: mem new "My first note" --type fleeting');
 }
 
 // src/commands/new.ts
 import fs6 from "fs";
 
-// src/core/vault.ts
-import fs3 from "fs";
-import path3 from "path";
-function findVaultRoot(from) {
-  let dir = from ? path3.resolve(from) : process.cwd();
-  while (true) {
-    if (fs3.existsSync(path3.join(dir, CONFIG_FILENAME))) {
-      return dir;
-    }
-    const parent = path3.dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-function requireVaultRoot(from) {
-  const root = findVaultRoot(from);
-  if (!root) {
-    throw new Error('Not inside a Granite vault. Run "mem init" to create one.');
-  }
-  return root;
-}
-function getIndexDbPath(vaultRoot) {
-  return path3.join(vaultRoot, ".granite", "index.db");
-}
-
 // src/core/note.ts
 import fs4 from "fs";
 import path4 from "path";
@@ -1945,8 +1962,8 @@ function printRecommendations(vaultRoot, config, filepath, strategy) {
 // src/index.ts
 var program = new Command();
 program.name("mem").description("Granite \u2014 a local-first markdown memory system").version("0.1.0");
-program.command("init").description("Initialize a new vault in the current directory").action(() => {
-  initVault(process.cwd());
+program.command("init").description("Initialize the default vault in ~/.granite").action(() => {
+  initVault();
 });
 program.command("new").description("Create a new note").argument("<title>", "Note title").option("-t, --type <type>", "Note type (e.g. fleeting, permanent, reference)").option("--source <source>", "Set source (human, agent, extraction)").option("--status <status>", "Set status (inbox, active, archived)").option("--json", "Output as JSON (agent-friendly)").action((title, options) => {
   newNote(title, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "granite-mem",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "A local-first markdown memory system for humans and agents",
   "type": "module",
   "bin": {