@chriswiegman/hugo-tools 0.1.0

package/src/config-init.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Generates a default .hugo-tools.json config file in the current Hugo site root.
+ * Usage:
+ *   config
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { requireHugoSite, DEFAULTS } = require('./config');
+
+function main() {
+  requireHugoSite();
+
+  const dest = path.join(process.cwd(), '.hugo-tools.json');
+
+  if (fs.existsSync(dest)) {
+    process.stderr.write('Error: .hugo-tools.json already exists.\n');
+    process.exit(1);
+  }
+
+  fs.writeFileSync(dest, JSON.stringify(DEFAULTS, null, 2) + '\n', 'utf8');
+  console.log(`Created ${dest}`);
+  console.log('Edit the values to match your Hugo site layout.');
+}
+
+main();

package/src/config.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULTS = {
+  timezone: 'America/Chicago',
+  postsDir: 'content/posts',
+  draftsDir: 'content/drafts',
+  notesDir: 'content/notes',
+  booksDir: 'content/books',
+  imagesDir: 'assets/images',
+  vscodeDir: '.vscode',
+};
+
+let override = {};
+const configPath = path.join(process.cwd(), '.hugo-tools.json');
+try {
+  if (fs.existsSync(configPath)) {
+    override = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  }
+} catch (e) {
+  process.stderr.write(`Warning: could not read .hugo-tools.json: ${e.message}\n`);
+}
+
+const HUGO_CONFIGS = [
+  'hugo.toml', 'hugo.yaml', 'hugo.yml', 'hugo.json',
+  'config.toml', 'config.yaml', 'config.yml', 'config.json',
+  'config',
+];
+
+function requireHugoSite() {
+  const cwd = process.cwd();
+  const found = HUGO_CONFIGS.some(name => fs.existsSync(path.join(cwd, name)));
+  if (!found) {
+    process.stderr.write('Error: no Hugo config file found. Run this command from the root of your Hugo site.\n');
+    process.exit(1);
+  }
+}
+
+module.exports = { ...DEFAULTS, ...override, requireHugoSite, DEFAULTS };

package/src/draft.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Creates a new Hugo draft using the standard drafts archetype.
+ * Usage:
+ *   new-draft
+ *
+ * Generates a timestamp-based filename (YYYYMMDD-HHMMSS.md) in the configured
+ * drafts directory, writes the archetype front matter without a date: line,
+ * then opens the file in VS Code.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const config = require('./config');
+
+function timestampFilename() {
+  const now = new Date();
+  const parts = new Intl.DateTimeFormat('en-CA', {
+    timeZone: config.timezone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hour12: false,
+  }).formatToParts(now);
+  const get = (type) => parts.find(p => p.type === type).value;
+  let hour = get('hour');
+  if (hour === '24') hour = '00';
+  return `${get('year')}${get('month')}${get('day')}-${hour}${get('minute')}${get('second')}`;
+}
+
+function buildArchetype() {
+  return [
+    '---',
+    'title: ""',
+    'description: ""',
+    'draft: true',
+    'images:',
+    '  -',
+    'categories:',
+    '  -',
+    'tags:',
+    '  -',
+    '---',
+    '',
+  ].join('\n');
+}
+
+function main() {
+  config.requireHugoSite();
+
+  const stamp = timestampFilename();
+  const draftsDir = path.join(process.cwd(), config.draftsDir);
+  const destPath = path.join(draftsDir, `${stamp}.md`);
+
+  fs.mkdirSync(draftsDir, { recursive: true });
+  fs.writeFileSync(destPath, buildArchetype(), 'utf8');
+
+  console.log(destPath);
+
+  try {
+    execFileSync('code', [destPath], { stdio: 'ignore' });
+  } catch {
+    // VS Code not available — silently continue
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { buildArchetype, timestampFilename };

package/src/draft.test.mjs

@@ -0,0 +1,77 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { buildArchetype, timestampFilename } = require('./draft.js');
+
+// ---------------------------------------------------------------------------
+// buildArchetype
+// ---------------------------------------------------------------------------
+
+test('buildArchetype: starts with front matter delimiter', () => {
+  assert.ok(buildArchetype().startsWith('---\n'));
+});
+
+test('buildArchetype: contains blank title', () => {
+  assert.ok(buildArchetype().includes('title: ""'));
+});
+
+test('buildArchetype: contains blank description', () => {
+  assert.ok(buildArchetype().includes('description: ""'));
+});
+
+test('buildArchetype: sets draft true', () => {
+  assert.ok(buildArchetype().includes('draft: true'));
+});
+
+test('buildArchetype: contains images placeholder', () => {
+  const out = buildArchetype();
+  assert.ok(out.includes('images:\n  -'));
+});
+
+test('buildArchetype: contains categories placeholder', () => {
+  const out = buildArchetype();
+  assert.ok(out.includes('categories:\n  -'));
+});
+
+test('buildArchetype: contains tags placeholder', () => {
+  const out = buildArchetype();
+  assert.ok(out.includes('tags:\n  -'));
+});
+
+test('buildArchetype: does not contain a date key', () => {
+  assert.ok(!buildArchetype().includes('date:'));
+});
+
+test('buildArchetype: ends with closing delimiter and trailing newline', () => {
+  assert.ok(buildArchetype().endsWith('---\n'));
+});
+
+// ---------------------------------------------------------------------------
+// timestampFilename
+// ---------------------------------------------------------------------------
+
+test('timestampFilename: matches YYYYMMDD-HHMMSS format', () => {
+  assert.match(timestampFilename(), /^\d{8}-\d{6}$/);
+});
+
+test('timestampFilename: date portion is a plausible date', () => {
+  const stamp = timestampFilename();
+  const year = parseInt(stamp.slice(0, 4), 10);
+  const month = parseInt(stamp.slice(4, 6), 10);
+  const day = parseInt(stamp.slice(6, 8), 10);
+  assert.ok(year >= 2024);
+  assert.ok(month >= 1 && month <= 12);
+  assert.ok(day >= 1 && day <= 31);
+});
+
+test('timestampFilename: time portion is a plausible time', () => {
+  const stamp = timestampFilename();
+  const hour = parseInt(stamp.slice(9, 11), 10);
+  const minute = parseInt(stamp.slice(11, 13), 10);
+  const second = parseInt(stamp.slice(13, 15), 10);
+  assert.ok(hour >= 0 && hour <= 23);
+  assert.ok(minute >= 0 && minute <= 59);
+  assert.ok(second >= 0 && second <= 59);
+});

package/src/extract-tags.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+
+/**
+ * Extracts all unique categories and tags from published Hugo posts.
+ * Outputs a JSON file that can be used for autocomplete/reference.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const config = require('./config');
+
+const CONTENT_DIR = path.join(process.cwd(), config.postsDir);
+const OUTPUT_FILE = path.join(process.cwd(), config.vscodeDir, 'tags-categories.json');
+const SNIPPETS_FILE = path.join(process.cwd(), config.vscodeDir, 'markdown.code-snippets');
+
+/**
+ * Extracts frontmatter from a markdown file
+ */
+function extractFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Parses YAML-style list items from frontmatter
+ */
+function parseListItems(frontmatter, key) {
+  const items = [];
+  const blockRegex = new RegExp(`^${key}:\\s*\\n((\\s*-\\s*.+\\n)+)`, 'm');
+  const match = frontmatter.match(blockRegex);
+
+  if (match) {
+    const lines = match[1].split('\n');
+    for (const line of lines) {
+      const itemMatch = line.match(/^\s*-\s*(.+)\s*$/);
+      if (itemMatch) {
+        const value = itemMatch[1].trim().replace(/^["']|["']$/g, '');
+        if (value) {
+          items.push(value);
+        }
+      }
+    }
+  }
+
+  return items;
+}
+
+/**
+ * Recursively finds all markdown files
+ */
+function findMarkdownFiles(dir) {
+  const files = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findMarkdownFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Main extraction logic
+ */
+function extractTagsAndCategories() {
+  const categories = new Set();
+  const tags = new Set();
+  const categoryCount = {};
+  const tagCount = {};
+
+  const files = findMarkdownFiles(CONTENT_DIR);
+  console.log(`Found ${files.length} markdown files`);
+
+  for (const file of files) {
+    const content = fs.readFileSync(file, 'utf8');
+    const frontmatter = extractFrontmatter(content);
+
+    if (!frontmatter) continue;
+
+    // Extract categories
+    const fileCategories = parseListItems(frontmatter, 'categories');
+    for (const cat of fileCategories) {
+      categories.add(cat);
+      categoryCount[cat] = (categoryCount[cat] || 0) + 1;
+    }
+
+    // Extract tags
+    const fileTags = parseListItems(frontmatter, 'tags');
+    for (const tag of fileTags) {
+      tags.add(tag);
+      tagCount[tag] = (tagCount[tag] || 0) + 1;
+    }
+  }
+
+  // Sort by usage count (most used first)
+  const sortedCategories = Array.from(categories).sort((a, b) => {
+    return (categoryCount[b] || 0) - (categoryCount[a] || 0);
+  });
+
+  const sortedTags = Array.from(tags).sort((a, b) => {
+    return (tagCount[b] || 0) - (tagCount[a] || 0);
+  });
+
+  return {
+    categories: sortedCategories,
+    tags: sortedTags,
+    stats: {
+      categoryCount,
+      tagCount,
+      totalCategories: categories.size,
+      totalTags: tags.size,
+      totalFiles: files.length,
+      generatedAt: new Date().toISOString()
+    }
+  };
+}
+
+/**
+ * Generate snippet prefixes for a tag/category
+ */
+function generatePrefixes(name) {
+  const lower = name.toLowerCase();
+  const prefixes = [lower];
+
+  // Add concatenated version for multi-word items (e.g., "Digital Life" -> "digitallife")
+  if (name.includes(' ')) {
+    const concat = lower.replace(/\s+/g, '');
+    if (concat !== lower) {
+      prefixes.push(concat);
+    }
+  }
+
+  // Add common abbreviations
+  const abbrevMap = {
+    'Technology': ['tech'],
+    'Personal': ['pers'],
+    'WordPress': ['wp'],
+    'Infrastructure': ['infra'],
+    'Open Source': ['oss'],
+    'Reflection': ['reflect'],
+    'Web Development': ['webdev', 'web'],
+    'Development': ['dev'],
+    'Digital Life': ['digital'],
+    'Social Media': ['social'],
+    'Education': ['edu'],
+    'Self-hosting': ['selfhost'],
+    'Content Management Systems': ['cms', 'contentmanagement']
+  };
+
+  if (abbrevMap[name]) {
+    prefixes.push(...abbrevMap[name]);
+  }
+
+  // Return single string if only one prefix, otherwise return array
+  return prefixes.length === 1 ? prefixes[0] : prefixes;
+}
+
+/**
+ * Generate VSCode snippets from tags and categories
+ */
+function generateSnippets(data) {
+  const snippets = {};
+
+  // Generate category snippets
+  for (const category of data.categories) {
+    snippets[`Category: ${category}`] = {
+      prefix: generatePrefixes(category),
+      body: category,
+      description: `Category: ${category}`
+    };
+  }
+
+  // Generate tag snippets
+  for (const tag of data.tags) {
+    snippets[`Tag: ${tag}`] = {
+      prefix: generatePrefixes(tag),
+      body: tag,
+      description: `Tag: ${tag}`
+    };
+  }
+
+  return snippets;
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  config.requireHugoSite();
+
+  console.log('Extracting tags and categories from published posts...');
+
+  const data = extractTagsAndCategories();
+
+  // Ensure .vscode directory exists
+  const vscodePath = path.dirname(OUTPUT_FILE);
+  if (!fs.existsSync(vscodePath)) {
+    fs.mkdirSync(vscodePath, { recursive: true });
+  }
+
+  // Write JSON data file
+  fs.writeFileSync(OUTPUT_FILE, JSON.stringify(data, null, 2));
+
+  // Generate and write snippets file
+  const snippets = generateSnippets(data);
+  fs.writeFileSync(SNIPPETS_FILE, JSON.stringify(snippets, null, 2));
+
+  console.log('\nResults:');
+  console.log(`  Categories: ${data.stats.totalCategories}`);
+  console.log(`  Tags: ${data.stats.totalTags}`);
+  console.log(`  Files processed: ${data.stats.totalFiles}`);
+  console.log(`\nOutput written to:`);
+  console.log(`  - ${OUTPUT_FILE}`);
+  console.log(`  - ${SNIPPETS_FILE}`);
+  console.log('\nMost used categories:');
+  data.categories.slice(0, 5).forEach(cat => {
+    console.log(`  - ${cat} (${data.stats.categoryCount[cat]} posts)`);
+  });
+  console.log('\nMost used tags:');
+  data.tags.slice(0, 10).forEach(tag => {
+    console.log(`  - ${tag} (${data.stats.tagCount[tag]} posts)`);
+  });
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { extractFrontmatter, parseListItems, generatePrefixes };

package/src/extract-tags.test.mjs

@@ -0,0 +1,121 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { extractFrontmatter, parseListItems, generatePrefixes } = require('./extract-tags.js');
+
+// ---------------------------------------------------------------------------
+// extractFrontmatter
+// ---------------------------------------------------------------------------
+
+test('extractFrontmatter: returns frontmatter content between --- delimiters', () => {
+  const content = '---\ntitle: My Post\ndraft: true\n---\nBody text here.';
+  assert.equal(extractFrontmatter(content), 'title: My Post\ndraft: true');
+});
+
+test('extractFrontmatter: returns null when no frontmatter', () => {
+  assert.equal(extractFrontmatter('Just body text with no delimiters.'), null);
+});
+
+test('extractFrontmatter: returns null when only one --- delimiter', () => {
+  assert.equal(extractFrontmatter('---\ntitle: foo\nno closing delimiter'), null);
+});
+
+test('extractFrontmatter: handles empty frontmatter block', () => {
+  assert.equal(extractFrontmatter('---\n\n---\nBody.'), '');
+});
+
+test('extractFrontmatter: does not include body content', () => {
+  const content = '---\ntitle: foo\n---\nThis body should not appear.';
+  const result = extractFrontmatter(content);
+  assert.ok(!result.includes('This body'));
+});
+
+test('extractFrontmatter: handles --- appearing in body without confusion', () => {
+  const content = '---\ntitle: foo\n---\nBody line.\n---\nAnother section.';
+  const result = extractFrontmatter(content);
+  assert.equal(result, 'title: foo');
+});
+
+// ---------------------------------------------------------------------------
+// parseListItems
+// ---------------------------------------------------------------------------
+
+test('parseListItems: parses a simple list', () => {
+  const fm = 'tags:\n  - JavaScript\n  - Go\n';
+  assert.deepEqual(parseListItems(fm, 'tags'), ['JavaScript', 'Go']);
+});
+
+test('parseListItems: strips double quotes from values', () => {
+  const fm = 'categories:\n  - "Technology"\n  - "Open Source"\n';
+  assert.deepEqual(parseListItems(fm, 'categories'), ['Technology', 'Open Source']);
+});
+
+test('parseListItems: strips single quotes from values', () => {
+  const fm = "tags:\n  - 'JavaScript'\n";
+  assert.deepEqual(parseListItems(fm, 'tags'), ['JavaScript']);
+});
+
+test('parseListItems: returns empty array when key is not present', () => {
+  assert.deepEqual(parseListItems('title: My Post\n', 'tags'), []);
+});
+
+test('parseListItems: returns empty array for empty file', () => {
+  assert.deepEqual(parseListItems('', 'tags'), []);
+});
+
+test('parseListItems: handles multiple spaces before list items', () => {
+  const fm = 'tags:\n    - foo\n    - bar\n';
+  assert.deepEqual(parseListItems(fm, 'tags'), ['foo', 'bar']);
+});
+
+test('parseListItems: does not confuse tags and categories', () => {
+  const fm = 'categories:\n  - Tech\ntags:\n  - Go\n';
+  assert.deepEqual(parseListItems(fm, 'tags'), ['Go']);
+  assert.deepEqual(parseListItems(fm, 'categories'), ['Tech']);
+});
+
+test('parseListItems: single item list', () => {
+  const fm = 'tags:\n  - solo\n';
+  assert.deepEqual(parseListItems(fm, 'tags'), ['solo']);
+});
+
+// ---------------------------------------------------------------------------
+// generatePrefixes
+// ---------------------------------------------------------------------------
+
+test('generatePrefixes: single word returns a string', () => {
+  assert.equal(generatePrefixes('Go'), 'go');
+});
+
+test('generatePrefixes: single word with no abbreviation returns lowercase string', () => {
+  assert.equal(generatePrefixes('JavaScript'), 'javascript');
+});
+
+test('generatePrefixes: multi-word returns array including concatenated form', () => {
+  const result = generatePrefixes('Open Source');
+  assert.ok(Array.isArray(result));
+  assert.ok(result.includes('open source'));
+  assert.ok(result.includes('opensource'));
+});
+
+test('generatePrefixes: known abbreviation is included', () => {
+  const result = generatePrefixes('Technology');
+  assert.ok(Array.isArray(result));
+  assert.ok(result.includes('technology'));
+  assert.ok(result.includes('tech'));
+});
+
+test('generatePrefixes: multi-word with abbreviation includes all forms', () => {
+  const result = generatePrefixes('Web Development');
+  assert.ok(result.includes('web development'));
+  assert.ok(result.includes('webdevelopment'));
+  assert.ok(result.includes('webdev'));
+  assert.ok(result.includes('web'));
+});
+
+test('generatePrefixes: Open Source includes oss abbreviation', () => {
+  const result = generatePrefixes('Open Source');
+  assert.ok(result.includes('oss'));
+});

package/src/pick-image.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+'use strict';
+
+// Lists images in the configured images directory for the current year/month
+// and copies the selected path to the clipboard.
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { execSync, execFileSync } = require('child_process');
+const config = require('./config');
+
+config.requireHugoSite();
+
+const IMAGE_EXTS = new Set(['.jpg', '.jpeg', '.png', '.webp', '.gif']);
+
+const now = new Date();
+const year = now.getFullYear().toString();
+const month = String(now.getMonth() + 1).padStart(2, '0');
+const imageDir = path.join(process.cwd(), config.imagesDir, year, month);
+const imagePath = `/${config.imagesDir}/${year}/${month}`;
+
+if (!fs.existsSync(imageDir)) {
+  console.error(`No image directory found at ${imageDir}`);
+  process.exit(1);
+}
+
+const files = fs.readdirSync(imageDir)
+  .filter(f => IMAGE_EXTS.has(path.extname(f).toLowerCase()))
+  .sort();
+
+if (files.length === 0) {
+  console.error(`No images found in ${imageDir}`);
+  process.exit(1);
+}
+
+console.log(`\nImages in ${imagePath}/:\n`);
+files.forEach((f, i) => console.log(`  ${i + 1}) ${f}`));
+console.log('');
+
+function copyToClipboard(text) {
+  const platform = process.platform;
+  if (platform === 'darwin') {
+    execSync(`echo ${JSON.stringify(text)} | pbcopy`);
+    return;
+  }
+  if (platform === 'win32') {
+    execFileSync('clip', { input: text });
+    return;
+  }
+  // Linux: try common clipboard tools in order
+  const tools = [
+    ['xclip', ['-selection', 'clipboard']],
+    ['xsel', ['--clipboard', '--input']],
+    ['wl-copy', []],
+  ];
+  for (const [cmd, args] of tools) {
+    try {
+      execFileSync(cmd, args, { input: text });
+      return;
+    } catch {
+      // try next
+    }
+  }
+  console.log('(clipboard unavailable — copy the path above manually)');
+}
+
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+rl.question(`Select image (1-${files.length}): `, answer => {
+  rl.close();
+  const choice = parseInt(answer, 10);
+  if (choice >= 1 && choice <= files.length) {
+    const result = `${imagePath}/${files[choice - 1]}`;
+    copyToClipboard(result);
+    console.log(`\nCopied to clipboard: ${result}`);
+  } else {
+    console.error('Invalid selection');
+    process.exit(1);
+  }
+});