chub-dev 0.2.0-beta.2 → 0.2.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chub-dev",
-  "version": "0.2.0-beta.2",
+  "version": "0.2.0-beta.4",
   "description": "CLI for Context Hub - search and retrieve LLM-optimized docs and skills",
   "type": "module",
   "bin": {
@@ -46,6 +46,6 @@
     "yaml": "^2.3.0"
   },
   "devDependencies": {
-    "vitest": "^3.0.0"
+    "vitest": "^4.0.18"
   }
 }

package/src/commands/annotate.js

@@ -0,0 +1,83 @@
+import chalk from 'chalk';
+import { readAnnotation, writeAnnotation, clearAnnotation, listAnnotations } from '../lib/annotations.js';
+import { output, error, info } from '../lib/output.js';
+
+export function registerAnnotateCommand(program) {
+  program
+    .command('annotate [id] [note]')
+    .description('Attach agent notes to a doc or skill')
+    .option('--clear', 'Remove annotation for this entry')
+    .option('--list', 'List all annotations')
+    .action((id, note, opts) => {
+      const globalOpts = program.optsWithGlobals();
+
+      if (opts.list) {
+        const annotations = listAnnotations();
+        output(
+          annotations,
+          (data) => {
+            if (data.length === 0) {
+              console.log('No annotations.');
+              return;
+            }
+            for (const a of data) {
+              console.log(`${chalk.bold(a.id)} ${chalk.dim(`(${a.updatedAt})`)}`);
+              console.log(`  ${a.note}`);
+              console.log();
+            }
+          },
+          globalOpts
+        );
+        return;
+      }
+
+      if (!id) {
+        error('Usage: chub annotate <id> <note> | chub annotate <id> --clear | chub annotate --list', globalOpts);
+      }
+
+      if (opts.clear) {
+        const removed = clearAnnotation(id);
+        output(
+          { id, cleared: removed },
+          (data) => {
+            if (data.cleared) {
+              console.log(`Annotation cleared for ${chalk.bold(id)}.`);
+            } else {
+              console.log(`No annotation found for ${chalk.bold(id)}.`);
+            }
+          },
+          globalOpts
+        );
+        return;
+      }
+
+      if (!note) {
+        // Show existing annotation
+        const existing = readAnnotation(id);
+        if (existing) {
+          output(
+            existing,
+            (data) => {
+              console.log(`${chalk.bold(data.id)} ${chalk.dim(`(${data.updatedAt})`)}`);
+              console.log(data.note);
+            },
+            globalOpts
+          );
+        } else {
+          output(
+            { id, note: null },
+            () => console.log(`No annotation for ${chalk.bold(id)}.`),
+            globalOpts
+          );
+        }
+        return;
+      }
+
+      const data = writeAnnotation(id, note);
+      output(
+        data,
+        (d) => console.log(`Annotation saved for ${chalk.bold(d.id)}.`),
+        globalOpts
+      );
+    });
+}

package/src/commands/build.js

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import { parseFrontmatter } from '../lib/frontmatter.js';
 import { info } from '../lib/output.js';
 import { trackEvent } from '../lib/analytics.js';
+import { buildIndex } from '../lib/bm25.js';
 
 /**
  * Recursively find all DOC.md and SKILL.md files under a directory.
@@ -301,6 +302,14 @@ export function registerBuildCommand(program) {
       mkdirSync(outputDir, { recursive: true });
       writeFileSync(join(outputDir, 'registry.json'), JSON.stringify(registry, null, 2));
 
+      // Build and write BM25 search index
+      const allEntries = [
+        ...allDocs.map((d) => ({ ...d, _type: 'doc' })),
+        ...allSkills.map((s) => ({ ...s, _type: 'skill' })),
+      ];
+      const searchIndex = buildIndex(allEntries);
+      writeFileSync(join(outputDir, 'search-index.json'), JSON.stringify(searchIndex));
+
       // Copy content tree
       for (const authorEntry of topLevel) {
         const src = join(contentDir, authorEntry.name);

package/src/commands/get.js

@@ -5,19 +5,17 @@ import { getEntry, resolveDocPath, resolveEntryFile } from '../lib/registry.js';
 import { fetchDoc, fetchDocFull } from '../lib/cache.js';
 import { output, error, info } from '../lib/output.js';
 import { trackEvent } from '../lib/analytics.js';
+import { readAnnotation } from '../lib/annotations.js';
 
 /**
- * Core fetch logic shared by `get docs` and `get skills`.
- * @param {string} type - "doc" or "skill"
- * @param {string[]} ids - one or more entry ids
- * @param {object} opts - command options (lang, version, output, full)
- * @param {object} globalOpts - global options (json)
+ * Fetch one or more entries by ID. Auto-detects doc vs skill per entry.
  */
-async function fetchEntries(type, ids, opts, globalOpts) {
+async function fetchEntries(ids, opts, globalOpts) {
   const results = [];
 
   for (const id of ids) {
-    const result = getEntry(id, type);
+    // Search both docs and skills — auto-detect type
+    const result = getEntry(id);
 
     if (result.ambiguous) {
       error(
@@ -27,16 +25,24 @@ async function fetchEntries(type, ids, opts, globalOpts) {
     }
 
     if (!result.entry) {
-      error(`Entry "${id}" not found in ${type}s.`, globalOpts);
+      error(`Entry "${id}" not found.`, globalOpts);
     }
 
     const entry = result.entry;
+    const type = entry.languages ? 'doc' : 'skill';
     const resolved = resolveDocPath(entry, opts.lang, opts.version);
 
     if (!resolved) {
       error(`Could not resolve path for "${id}" ${opts.lang || ''} ${opts.version || ''}`.trim(), globalOpts);
     }
 
+    if (resolved.versionNotFound) {
+      error(
+        `Version "${resolved.requested}" not found for "${id}". Available versions: ${resolved.available.join(', ')}`,
+        globalOpts
+      );
+    }
+
     if (resolved.needsLanguage) {
       error(
         `Multiple languages available for "${id}": ${resolved.available.join(', ')}. Specify --lang.`,
@@ -49,13 +55,32 @@ async function fetchEntries(type, ids, opts, globalOpts) {
       error(`"${id}" ${entryFile.error}`, globalOpts);
     }
 
+    // Determine which reference files exist (beyond DOC.md/SKILL.md)
+    const entryFileName = type === 'skill' ? 'SKILL.md' : 'DOC.md';
+    const refFiles = resolved.files.filter((f) => f !== entryFileName);
+
     try {
-      if (opts.full && resolved.files.length > 0) {
+      if (opts.file) {
+        // --file mode: fetch specific file(s) by path
+        const requested = opts.file.split(',').map((f) => f.trim());
+        const invalid = requested.filter((f) => !resolved.files.includes(f));
+        if (invalid.length > 0) {
+          const available = refFiles.length > 0 ? refFiles.join(', ') : '(none)';
+          error(`File "${invalid[0]}" not found in ${id}. Available: ${available}`, globalOpts);
+        }
+        if (requested.length === 1) {
+          const content = await fetchDoc(resolved.source, join(resolved.path, requested[0]));
+          results.push({ id: entry.id, type, content, path: join(resolved.path, requested[0]) });
+        } else {
+          const allFiles = await fetchDocFull(resolved.source, resolved.path, requested);
+          results.push({ id: entry.id, type, files: allFiles, path: resolved.path });
+        }
+      } else if (opts.full && resolved.files.length > 0) {
         const allFiles = await fetchDocFull(resolved.source, resolved.path, resolved.files);
-        results.push({ id: entry.id, files: allFiles, path: resolved.path });
+        results.push({ id: entry.id, type, files: allFiles, path: resolved.path });
       } else {
         const content = await fetchDoc(resolved.source, entryFile.filePath);
-        results.push({ id: entry.id, content, path: entryFile.filePath });
+        results.push({ id: entry.id, type, content, path: entryFile.filePath, additionalFiles: refFiles });
       }
     } catch (err) {
       error(err.message, globalOpts);
@@ -64,7 +89,7 @@ async function fetchEntries(type, ids, opts, globalOpts) {
 
   // Track fetches
   for (const r of results) {
-    trackEvent(type === 'doc' ? 'doc_fetched' : 'skill_fetched', {
+    trackEvent(r.type === 'doc' ? 'doc_fetched' : 'skill_fetched', {
       entry_id: r.id,
       full: !!opts.full,
       lang: opts.lang || undefined,
@@ -74,7 +99,6 @@ async function fetchEntries(type, ids, opts, globalOpts) {
   // Output
   if (opts.output) {
     if (opts.full) {
-      // --full -o: write individual files preserving directory structure
       for (const r of results) {
         if (r.files) {
           const baseDir = ids.length > 1 ? join(opts.output, r.id) : opts.output;
@@ -111,18 +135,32 @@ async function fetchEntries(type, ids, opts, globalOpts) {
       }
     }
     if (globalOpts.json) {
-      console.log(JSON.stringify(results.map((r) => ({ id: r.id, path: opts.output }))));
+      console.log(JSON.stringify(results.map((r) => ({ id: r.id, type: r.type, path: opts.output }))));
     }
   } else {
-    // stdout
     if (results.length === 1 && !results[0].files) {
+      const r = results[0];
+      const extraFiles = r.additionalFiles || [];
+      const annotation = readAnnotation(r.id);
+      const jsonData = { id: r.id, type: r.type, content: r.content, path: r.path };
+      if (extraFiles.length > 0) jsonData.additionalFiles = extraFiles;
+      if (annotation) jsonData.annotation = annotation;
       output(
-        { id: results[0].id, content: results[0].content, path: results[0].path },
-        (data) => process.stdout.write(data.content),
+        jsonData,
+        (data) => {
+          process.stdout.write(data.content);
+          if (annotation) {
+            process.stdout.write(`\n\n---\n[Agent note — ${annotation.updatedAt}]\n${annotation.note}\n`);
+          }
+          if (extraFiles.length > 0) {
+            const fileList = extraFiles.map((f) => `  ${f}`).join('\n');
+            const example = `chub get ${r.id} --file ${extraFiles[0]}`;
+            process.stdout.write(`\n\n---\nAdditional files available (use --file to fetch):\n${fileList}\nExample: ${example}\n`);
+          }
+        },
         globalOpts
       );
     } else {
-      // Concatenate all content (--full to stdout, or multiple entries)
       const parts = results.flatMap((r) => {
         if (r.files) {
           return r.files.map((f) => `# FILE: ${f.name}\n\n${f.content}`);
@@ -131,7 +169,7 @@ async function fetchEntries(type, ids, opts, globalOpts) {
       });
       const combined = parts.join('\n\n---\n\n');
       output(
-        results.map((r) => ({ id: r.id, path: r.path })),
+        results.map((r) => ({ id: r.id, type: r.type, path: r.path })),
         () => process.stdout.write(combined),
         globalOpts
       );
@@ -140,29 +178,16 @@ async function fetchEntries(type, ids, opts, globalOpts) {
 }
 
 export function registerGetCommand(program) {
-  const get = program
-    .command('get')
-    .description('Retrieve docs or skills');
-
-  get
-    .command('docs <ids...>')
-    .description('Fetch documentation content')
-    .option('--lang <language>', 'Language variant')
-    .option('--version <version>', 'Specific version')
-    .option('-o, --output <path>', 'Write to file or directory')
-    .option('--full', 'Fetch all files (not just entry point)')
-    .action(async (ids, opts) => {
-      const globalOpts = program.optsWithGlobals();
-      await fetchEntries('doc', ids, opts, globalOpts);
-    });
-
-  get
-    .command('skills <ids...>')
-    .description('Fetch skill content')
+  program
+    .command('get <ids...>')
+    .description('Fetch docs or skills by ID (auto-detects type)')
+    .option('--lang <language>', 'Language variant (for docs)')
+    .option('--version <version>', 'Specific version (for docs)')
     .option('-o, --output <path>', 'Write to file or directory')
     .option('--full', 'Fetch all files (not just entry point)')
+    .option('--file <paths>', 'Fetch specific file(s) by path (comma-separated)')
     .action(async (ids, opts) => {
       const globalOpts = program.optsWithGlobals();
-      await fetchEntries('skill', ids, opts, globalOpts);
+      await fetchEntries(ids, opts, globalOpts);
     });
 }

package/src/index.js

@@ -10,6 +10,7 @@ import { registerSearchCommand } from './commands/search.js';
 import { registerGetCommand } from './commands/get.js';
 import { registerBuildCommand } from './commands/build.js';
 import { registerFeedbackCommand } from './commands/feedback.js';
+import { registerAnnotateCommand } from './commands/annotate.js';
 import { trackEvent, shutdownAnalytics } from './lib/analytics.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -26,17 +27,16 @@ ${chalk.bold.underline('Getting Started')}
   ${chalk.dim('$')} chub search                                ${chalk.dim('# list everything available')}
   ${chalk.dim('$')} chub search "stripe"                       ${chalk.dim('# fuzzy search')}
   ${chalk.dim('$')} chub search stripe/payments                ${chalk.dim('# exact id → full detail')}
-  ${chalk.dim('$')} chub get docs stripe/payments              ${chalk.dim('# print doc to terminal')}
-  ${chalk.dim('$')} chub get docs stripe/payments -o doc.md    ${chalk.dim('# save to file')}
-  ${chalk.dim('$')} chub get docs stripe/payments --lang py    ${chalk.dim('# specific language')}
-  ${chalk.dim('$')} chub get skills pw/login-flows             ${chalk.dim('# fetch a skill')}
-  ${chalk.dim('$')} chub get docs openai/chat stripe/payments  ${chalk.dim('# fetch multiple')}
+  ${chalk.dim('$')} chub get stripe/api                        ${chalk.dim('# print doc to terminal')}
+  ${chalk.dim('$')} chub get stripe/api -o doc.md              ${chalk.dim('# save to file')}
+  ${chalk.dim('$')} chub get openai/chat --lang py             ${chalk.dim('# specific language')}
+  ${chalk.dim('$')} chub get pw-community/login-flows          ${chalk.dim('# fetch a skill')}
+  ${chalk.dim('$')} chub get openai/chat stripe/api            ${chalk.dim('# fetch multiple')}
 
 ${chalk.bold.underline('Commands')}
 
   ${chalk.bold('search')} [query]              Search docs and skills (no query = list all)
-  ${chalk.bold('get docs')} <ids...>           Fetch documentation content
-  ${chalk.bold('get skills')} <ids...>         Fetch skill content
+  ${chalk.bold('get')} <ids...>                 Fetch docs or skills by ID
   ${chalk.bold('update')}                      Refresh the cached registry
   ${chalk.bold('cache')} status|clear          Manage the local cache
   ${chalk.bold('build')} <content-dir>        Build registry from content directory
@@ -56,10 +56,10 @@ ${chalk.bold.underline('Agent Piping Patterns')}
 
   ${chalk.dim('# Search → pick → fetch → save')}
   ${chalk.dim('$')} ID=$(chub search "stripe" --json | jq -r '.results[0].id')
-  ${chalk.dim('$')} chub get docs "$ID" --lang js -o .context/stripe.md
+  ${chalk.dim('$')} chub get "$ID" --lang js -o .context/stripe.md
 
-  ${chalk.dim('# Fetch multiple docs at once')}
-  ${chalk.dim('$')} chub get docs openai/chat stripe/payments -o .context/
+  ${chalk.dim('# Fetch multiple at once')}
+  ${chalk.dim('$')} chub get openai/chat stripe/api -o .context/
 
 ${chalk.bold.underline('Multi-Source Config')} ${chalk.dim('(~/.chub/config.yaml)')}
 
@@ -69,7 +69,7 @@ ${chalk.bold.underline('Multi-Source Config')} ${chalk.dim('(~/.chub/config.yaml
   ${chalk.dim('  - name: internal')}
   ${chalk.dim('    path: /path/to/local/docs')}
 
-  ${chalk.dim('# On id collision, use source: prefix: chub get docs internal:openai/chat')}
+  ${chalk.dim('# On id collision, use source: prefix: chub get internal:openai/chat')}
 `);
 }
 
@@ -78,14 +78,14 @@ const program = new Command();
 program
   .name('chub')
   .description('Context Hub - search and retrieve LLM-optimized docs and skills')
-  .version(pkg.version)
+  .version(pkg.version, '-V, --cli-version')
   .option('--json', 'Output as JSON (machine-readable)')
   .action(() => {
     printUsage();
   });
 
 // Commands that don't need registry
-const SKIP_REGISTRY = ['update', 'cache', 'build', 'feedback', 'help'];
+const SKIP_REGISTRY = ['update', 'cache', 'build', 'feedback', 'annotate', 'help'];
 
 program.hook('preAction', async (thisCommand) => {
   const cmdName = thisCommand.args?.[0] || thisCommand.name();
@@ -112,6 +112,7 @@ registerSearchCommand(program);
 registerGetCommand(program);
 registerBuildCommand(program);
 registerFeedbackCommand(program);
+registerAnnotateCommand(program);
 
 program.parse();
 

package/src/lib/annotations.js

@@ -0,0 +1,57 @@
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { getChubDir } from './config.js';
+
+function getAnnotationsDir() {
+  return join(getChubDir(), 'annotations');
+}
+
+function annotationPath(entryId) {
+  const safe = entryId.replace(/\//g, '--');
+  return join(getAnnotationsDir(), `${safe}.json`);
+}
+
+export function readAnnotation(entryId) {
+  try {
+    return JSON.parse(readFileSync(annotationPath(entryId), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function writeAnnotation(entryId, note) {
+  const dir = getAnnotationsDir();
+  mkdirSync(dir, { recursive: true });
+  const data = {
+    id: entryId,
+    note,
+    updatedAt: new Date().toISOString(),
+  };
+  writeFileSync(annotationPath(entryId), JSON.stringify(data, null, 2));
+  return data;
+}
+
+export function clearAnnotation(entryId) {
+  try {
+    unlinkSync(annotationPath(entryId));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function listAnnotations() {
+  const dir = getAnnotationsDir();
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith('.json'));
+    return files.map((f) => {
+      try {
+        return JSON.parse(readFileSync(join(dir, f), 'utf8'));
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}

package/src/lib/bm25.js

@@ -0,0 +1,170 @@
+/**
+ * BM25 search implementation for Context Hub.
+ * Index is built at `chub build` time, scoring happens at search time.
+ * Tokenizer is shared between build and search to ensure consistency.
+ */
+
+const STOP_WORDS = new Set([
+  'a', 'an', 'and', 'are', 'as', 'at', 'be', 'by', 'for', 'from',
+  'has', 'have', 'in', 'is', 'it', 'its', 'of', 'on', 'or', 'that',
+  'the', 'to', 'was', 'were', 'will', 'with', 'this', 'but', 'not',
+  'you', 'your', 'can', 'do', 'does', 'how', 'if', 'may', 'no',
+  'so', 'than', 'too', 'very', 'just', 'about', 'into', 'over',
+  'such', 'then', 'them', 'these', 'those', 'through', 'under',
+  'use', 'using', 'used',
+]);
+
+// BM25 default parameters
+const DEFAULT_K1 = 1.5;
+const DEFAULT_B = 0.75;
+
+// Field weights for multi-field scoring
+const FIELD_WEIGHTS = {
+  name: 3.0,
+  tags: 2.0,
+  description: 1.0,
+};
+
+/**
+ * Tokenize text into lowercase terms with stop word removal.
+ * Must be used identically at build time and search time.
+ */
+export function tokenize(text) {
+  if (!text) return [];
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, ' ')
+    .split(/[\s-]+/)
+    .filter((t) => t.length > 1 && !STOP_WORDS.has(t));
+}
+
+/**
+ * Build a BM25 search index from registry entries.
+ * Called during `chub build`.
+ *
+ * @param {Array} entries - Combined docs and skills from registry
+ * @returns {Object} The search index
+ */
+export function buildIndex(entries) {
+  const documents = [];
+  const dfMap = {}; // document frequency per term (across all fields)
+  const fieldLengths = { name: [], description: [], tags: [] };
+
+  for (const entry of entries) {
+    const nameTokens = tokenize(entry.name);
+    const descTokens = tokenize(entry.description || '');
+    const tagTokens = (entry.tags || []).flatMap((t) => tokenize(t));
+
+    documents.push({
+      id: entry.id,
+      tokens: {
+        name: nameTokens,
+        description: descTokens,
+        tags: tagTokens,
+      },
+    });
+
+    fieldLengths.name.push(nameTokens.length);
+    fieldLengths.description.push(descTokens.length);
+    fieldLengths.tags.push(tagTokens.length);
+
+    // Count document frequency — a term counts once per document (union of all fields)
+    const allTerms = new Set([...nameTokens, ...descTokens, ...tagTokens]);
+    for (const term of allTerms) {
+      dfMap[term] = (dfMap[term] || 0) + 1;
+    }
+  }
+
+  const N = documents.length;
+
+  // Compute IDF for each term
+  const idf = {};
+  for (const [term, df] of Object.entries(dfMap)) {
+    idf[term] = Math.log((N - df + 0.5) / (df + 0.5) + 1);
+  }
+
+  // Compute average field lengths
+  const avg = (arr) => arr.length === 0 ? 0 : arr.reduce((a, b) => a + b, 0) / arr.length;
+  const avgFieldLengths = {
+    name: avg(fieldLengths.name),
+    description: avg(fieldLengths.description),
+    tags: avg(fieldLengths.tags),
+  };
+
+  return {
+    version: '1.0.0',
+    algorithm: 'bm25',
+    params: { k1: DEFAULT_K1, b: DEFAULT_B },
+    totalDocs: N,
+    avgFieldLengths,
+    idf,
+    documents,
+  };
+}
+
+/**
+ * Compute BM25 score for a single field.
+ */
+function scoreField(queryTerms, fieldTokens, idf, avgFieldLen, k1, b) {
+  if (fieldTokens.length === 0) return 0;
+
+  // Build term frequency map for this field
+  const tf = {};
+  for (const t of fieldTokens) {
+    tf[t] = (tf[t] || 0) + 1;
+  }
+
+  let score = 0;
+  const dl = fieldTokens.length;
+
+  for (const term of queryTerms) {
+    const termFreq = tf[term] || 0;
+    if (termFreq === 0) continue;
+
+    const termIdf = idf[term] || 0;
+    const numerator = termFreq * (k1 + 1);
+    const denominator = termFreq + k1 * (1 - b + b * (dl / (avgFieldLen || 1)));
+    score += termIdf * (numerator / denominator);
+  }
+
+  return score;
+}
+
+/**
+ * Search the BM25 index with a query string.
+ *
+ * @param {string} query - The search query
+ * @param {Object} index - The pre-built BM25 index
+ * @param {Object} opts - Options: { limit }
+ * @returns {Array} Sorted results: [{ id, score }]
+ */
+export function search(query, index, opts = {}) {
+  const queryTerms = tokenize(query);
+  if (queryTerms.length === 0) return [];
+
+  const { k1, b } = index.params;
+  const results = [];
+
+  for (const doc of index.documents) {
+    let totalScore = 0;
+
+    for (const [field, weight] of Object.entries(FIELD_WEIGHTS)) {
+      const fieldTokens = doc.tokens[field] || [];
+      const avgLen = index.avgFieldLengths[field] || 1;
+      const fieldScore = scoreField(queryTerms, fieldTokens, index.idf, avgLen, k1, b);
+      totalScore += fieldScore * weight;
+    }
+
+    if (totalScore > 0) {
+      results.push({ id: doc.id, score: totalScore });
+    }
+  }
+
+  results.sort((a, b) => b.score - a.score);
+
+  if (opts.limit) {
+    return results.slice(0, opts.limit);
+  }
+
+  return results;
+}

package/src/lib/cache.js

@@ -225,6 +225,20 @@ export function loadSourceRegistry(source) {
   return JSON.parse(readFileSync(regPath, 'utf8'));
 }
 
+/**
+ * Load BM25 search index for a single source (if available).
+ */
+export function loadSearchIndex(source) {
+  const basePath = source.path || getSourceDir(source.name);
+  const indexPath = join(basePath, 'search-index.json');
+  if (!existsSync(indexPath)) return null;
+  try {
+    return JSON.parse(readFileSync(indexPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Get cache stats.
  */

package/src/lib/config.js

@@ -18,7 +18,7 @@ const DEFAULTS = {
 let _config = null;
 
 export function getChubDir() {
-  return join(homedir(), '.chub');
+  return process.env.CHUB_DIR || join(homedir(), '.chub');
 }
 
 export function loadConfig() {