@natjswenson/devlog 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nate Swenson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,162 @@
+# devlog
+
+A Claude Code skill that turns your daily git commits into a published dev log — and a React example for displaying it on your site.
+
+> **Build in public, automatically.** Make commits like you always do. Run `/devlog`. Today's work shows up on your site as a narrative entry, not raw commit messages.
+
+## Live example
+
+The skill is in production at [natejswenson.io/devlog](https://natejswenson.io/devlog), publishing entries to [github.com/natejswenson/daily-dev-log](https://github.com/natejswenson/daily-dev-log).
+
+## How it works
+
+1. **You commit code** in your projects, like you already do.
+2. **Run `/devlog` in Claude Code.** The skill reads today's commits, writes a narrative markdown entry, and pushes it to your dev-log GitHub repo.
+3. **Your site fetches it.** Static `manifest.json` + per-day markdown files served from `raw.githubusercontent.com` — no backend needed.
+
+## Quick start
+
+```sh
+npx @natjswenson/devlog init
+```
+
+That command:
+- Creates `<your-username>/daily-dev-log` on GitHub
+- Installs the skill at `~/.claude/skills/devlog/`
+- Writes `~/.claude/skills/devlog/config.json` with your answers
+
+Then:
+```sh
+npx @natjswenson/devlog preview
+```
+to see your dev log rendered locally.
+
+## Prerequisites
+
+- **Node 18+** — for the CLI and preview app
+- **GitHub CLI** (`gh`), authenticated — used to create your dev-log repo and push entries
+- **Claude Code** — to run the `/devlog` skill
+
+## What you end up with
+
+```
+~/.claude/skills/devlog/
+├── SKILL.md          # The slash command
+└── config.json       # Your settings (target repo, projects, etc)
+
+github.com/<you>/daily-dev-log/   # Created by `init`, populated by /devlog
+├── myproject/
+│   ├── manifest.json
+│   ├── 2026-05-01.md
+│   └── ...
+└── ...
+```
+
+## Manual setup (if you'd rather not use the CLI)
+
+1. **Create your dev-log repo:**
+   ```sh
+   gh repo create <you>/daily-dev-log --public --add-readme
+   ```
+2. **Install the skill:**
+   ```sh
+   mkdir -p ~/.claude/skills/devlog
+   curl -o ~/.claude/skills/devlog/SKILL.md \
+     https://raw.githubusercontent.com/natejswenson/devlog/main/SKILL.md
+   ```
+3. **Write your config** at `~/.claude/skills/devlog/config.json` — copy [`config.example.json`](./config.example.json) and fill in.
+
+## Add to your site
+
+### React (drop-in)
+
+```sh
+cp -r examples/react/ your-site/src/devlog/
+```
+
+Edit `your-site/src/devlog/devlog-config.js` to point at your repo, then mount:
+
+```jsx
+import DevLogPage from './devlog/DevLogPage.jsx';
+
+<DevLogPage project="myproject" />
+```
+
+Full instructions: [`examples/react/README.md`](./examples/react/README.md).
+
+### No site yet?
+
+The `preview/` directory is a complete deployable Vite app. Set `VITE_DEVLOG_OWNER` / `VITE_DEVLOG_REPO` / `VITE_DEVLOG_PROJECTS` env vars on Vercel, Netlify, or Cloudflare Pages, build with `vite build`, deploy `dist/`. Done — you have a public dev log at your own URL. See [`preview/README.md`](./preview/README.md).
+
+### Other stacks (Next, Astro, plain HTML, anything)
+
+It's static JSON and Markdown on GitHub. Build whatever UI you want — see the **Data contract** below.
+
+## Data contract
+
+The dev-log repo has this layout, all served as raw files from `https://raw.githubusercontent.com/<owner>/<repo>/main/`:
+
+```
+<repo>/
+└── <project-key>/
+    ├── manifest.json          # Index of all entries (newest first)
+    ├── 2026-05-01.md          # One entry per day
+    ├── 2026-04-30.md
+    └── ...
+```
+
+**`manifest.json`:**
+```json
+{
+  "entries": [
+    { "date": "2026-05-01", "file": "2026-05-01.md", "title": "...", "summary": "..." }
+  ]
+}
+```
+
+**Entry markdown:**
+```markdown
+---
+title: "Concise day summary"
+date: 2026-05-01
+project: myproject
+summary: "1-2 sentence summary"
+---
+
+## What I Built
+Narrative paragraphs.
+
+## What's Next
+Forward-looking note.
+
+## Public Commits
+- [myproject] commit message ([abc1234](https://github.com/.../commit/abc1234567...))
+```
+
+That's the entire contract.
+
+## Configuration reference
+
+`~/.claude/skills/devlog/config.json`:
+
+| Field | Type | Description |
+|---|---|---|
+| `targetRepo` | `"<owner>/<repo>"` | Repo where dev log entries are published. **You create this — `init` does it for you, or `gh repo create` manually.** |
+| `gitAuthor` | string | Used as `git log --author=...` to find your commits. |
+| `githubUser` | string | Your GitHub username (for constructing commit links). |
+| `projects` | array | One entry per project you want dev logs for. |
+| `projects[].key` | string | Subdirectory name in the dev-log repo + tab label on the UI. |
+| `projects[].path` | string | Local filesystem path to the project. |
+| `projects[].remote` | `"<owner>/<repo>"` | The project's GitHub remote, used to mark public commits and link them. |
+
+See [`config.example.json`](./config.example.json) for a complete template.
+
+## Customization
+
+- **Tweak the entry template:** edit `~/.claude/skills/devlog/SKILL.md` (Step 4 — generate the entry).
+- **Tweak the UI:** override the `--devlog-*` CSS variables in `examples/react/DevLogPage.css` to match your theme. Or build your own UI against the data contract above.
+- **Add more projects:** edit `~/.claude/skills/devlog/config.json` directly.
+
+## License
+
+MIT

package/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: devlog
+description: Generate a daily dev log entry from today's git commits and publish to GitHub
+user_invocable: true
+---
+
+# /devlog — Daily Dev Log Generator
+
+You are generating a daily dev log entry from the user's git commits and publishing it to a GitHub repo configured in `~/.claude/skills/devlog/config.json`.
+
+Usage: `/devlog` (all configured projects) or `/devlog <project-key>` (single project)
+
+## Configuration
+
+This skill is configuration-driven. All user-specific values (target repo, git author, project list) live in `~/.claude/skills/devlog/config.json`.
+
+Schema:
+
+```json
+{
+  "targetRepo": "<owner>/<repo>",
+  "gitAuthor": "Your Name",
+  "githubUser": "<your-github-username>",
+  "projects": [
+    {
+      "key": "project-key",
+      "path": "/absolute/path/to/project",
+      "remote": "<owner>/<repo>"
+    }
+  ]
+}
+```
+
+## Step 0: Load and validate config
+
+```bash
+cat ~/.claude/skills/devlog/config.json
+```
+
+If the file does not exist or cannot be parsed, stop and tell the user:
+
+> No devlog config found at `~/.claude/skills/devlog/config.json`. Run `npx @natjswenson/devlog init` to set up, or copy `config.example.json` from the devlog repo and fill it in manually.
+
+Validate that `targetRepo`, `gitAuthor`, `githubUser`, and `projects` (non-empty array) are all present. Each project must have `key`, `path`, and `remote`.
+
+## Step 1: Determine scope
+
+- If the user passed a project argument (e.g. `/devlog myproject`), filter `projects` to that one. If the key is not in the registry, list available keys and stop.
+- If no argument, run for **all projects** in `config.projects`. Generate a separate entry per project (only for projects that have commits today). Use a single clone of the target repo and a single commit/push for all entries.
+
+## Step 2: Gather today's commits
+
+For each project in scope, run:
+
+```bash
+cd <project.path> && git log --author="<config.gitAuthor>" --since="midnight" --format="%H|%s|%D" --all
+```
+
+If no commits are found for a project, skip it. If no commits are found across all projects, inform the user and stop.
+
+## Step 3: Check for public commits
+
+For each commit, check if it's on the `main` branch and if the remote is public:
+
+```bash
+cd <project.path> && git remote get-url origin
+git branch --contains <hash> -r 2>/dev/null | grep -q 'origin/main'
+```
+
+- If the remote URL matches `<project.remote>` (i.e. `github.com/<project.remote>` or the SSH equivalent) and the commit is on `origin/main`, it's a public commit — include a link using `https://github.com/<project.remote>/commit/<hash>`.
+- Otherwise, describe the feature without linking.
+
+## Step 4: Generate the entry
+
+Based on the commit messages, generate a markdown entry with this structure:
+
+```markdown
+---
+title: "<concise title summarizing the day's work>"
+date: YYYY-MM-DD
+project: <project.key>
+summary: "<1-2 sentence summary>"
+---
+
+## What I Built
+
+<Narrative paragraphs about features implemented. Focus on WHAT was built and WHY, not raw commit messages. Group related commits into coherent feature descriptions. Write in first person, casual but professional tone.>
+
+## What's Next
+
+<Brief 1-2 sentence forward-looking note based on the trajectory of current work.>
+
+## Public Commits
+
+- [<project.key>] commit message ([short-hash](https://github.com/<project.remote>/commit/full-hash))
+```
+
+**Important rules for content generation:**
+- The "What I Built" section is a NARRATIVE, not a commit list. Describe features, not individual commits.
+- Only include "Public Commits" section if there are commits on `main` of a public repo.
+- "What's Next" should be a reasonable inference from the work done today.
+- Tone: first person, casual but professional, like a senior engineer's standup notes for a public audience.
+
+## Step 5: Check for existing entry (append mode)
+
+For each project with commits, check if an entry for today already exists:
+
+```bash
+gh api repos/<config.targetRepo>/contents/<project.key>/YYYY-MM-DD.md --jq '.content' 2>/dev/null | base64 -d
+```
+
+**If the entry exists:**
+1. Fetch and read the existing content
+2. Keep the original frontmatter (title, date, project, summary) unchanged
+3. Append new content under an `## Update — HH:MM AM/PM` heading
+4. Merge any new public commits into the existing "Public Commits" section
+5. Update "What's Next" with the latest context
+
+**If the entry does NOT exist:**
+1. Create a new file with the full structure above
+
+## Step 6: Push to GitHub
+
+Clone the repo once, write all project entries, then push:
+
+```bash
+# Clone to temp directory
+TMPDIR=$(mktemp -d)
+cd "$TMPDIR"
+git clone https://github.com/<config.targetRepo>.git
+cd $(basename <config.targetRepo>)
+
+# For each project with commits:
+# - Create directory if needed: mkdir -p <project.key>/
+# - Write the entry file to <project.key>/YYYY-MM-DD.md
+# - Update <project.key>/manifest.json
+#   - Read manifest, add/update entry in entries array (newest first)
+#   - Entry object: { "date": "YYYY-MM-DD", "file": "YYYY-MM-DD.md", "title": "...", "summary": "..." }
+#   - If appending to existing entry, update title/summary only if changed
+#   - If manifest doesn't exist, create it as { "entries": [...] }
+
+# Stage all changed project directories
+git add .
+
+# Single commit covering all projects
+git commit -m "devlog: add entries for YYYY-MM-DD"
+git push origin main
+
+# Cleanup
+rm -rf "$TMPDIR"
+```
+
+## Step 7: Confirm
+
+After pushing, output a summary for each project:
+
+```
+Dev log entries published for <Month Day, Year>
+
+  Project: <project.key>
+  Commits summarized: <count>
+  Public commits linked: <count>
+  URL: https://github.com/<config.targetRepo>/blob/main/<project.key>/YYYY-MM-DD.md
+```
+
+## Edge Cases
+
+- **No commits today:** Stop with a message. Do not create an empty entry.
+- **Project path doesn't exist:** Error with "Repository not found at <project.path>" and skip that project.
+- **Push fails:** Inform the user of the error. Do not retry automatically.
+- **All WIP/fixup commits:** Still generate a narrative about the intent of the work.
+- **Manifest doesn't exist:** Create it with the standard structure.
+- **Unknown project argument:** List available project keys from `config.projects`.
+- **Config missing or invalid:** Stop at Step 0 with the setup instructions above.

package/bin/devlog.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+import { spawn, execSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve, basename } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+import prompts from 'prompts';
+import kleur from 'kleur';
+
+const require = createRequire(import.meta.url);
+const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const SKILL_SRC = join(PACKAGE_ROOT, 'SKILL.md');
+const CONFIG_DIR = join(homedir(), '.claude', 'skills', 'devlog');
+const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+const SKILL_DEST = join(CONFIG_DIR, 'SKILL.md');
+const PREVIEW_DIR = join(PACKAGE_ROOT, 'preview');
+
+const log = {
+  info: (msg) => console.log(msg),
+  ok: (msg) => console.log(kleur.green('✓ ') + msg),
+  warn: (msg) => console.log(kleur.yellow('! ') + msg),
+  err: (msg) => console.error(kleur.red('✗ ') + msg),
+  step: (msg) => console.log(kleur.cyan('→ ') + msg),
+};
+
+function readPackageVersion() {
+  const pkg = JSON.parse(readFileSync(join(PACKAGE_ROOT, 'package.json'), 'utf8'));
+  return pkg.version;
+}
+
+function tryExec(cmd) {
+  try {
+    return execSync(cmd, { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function expandHome(p) {
+  if (!p) return p;
+  if (p === '~') return homedir();
+  if (p.startsWith('~/')) return join(homedir(), p.slice(2));
+  return p;
+}
+
+async function preflight() {
+  const nodeMajor = parseInt(process.versions.node.split('.')[0], 10);
+  if (nodeMajor < 18) {
+    log.err(`Node 18+ required (you have ${process.versions.node}).`);
+    process.exit(1);
+  }
+
+  const ghVersion = tryExec('gh --version');
+  if (!ghVersion) {
+    log.err('GitHub CLI (`gh`) is not installed.');
+    log.info('Install: https://cli.github.com/');
+    process.exit(1);
+  }
+
+  const ghAuth = tryExec('gh auth status');
+  if (!ghAuth) {
+    log.err('GitHub CLI is not authenticated.');
+    log.info('Run: gh auth login');
+    process.exit(1);
+  }
+}
+
+function detectGhUser() {
+  const out = tryExec('gh api user --jq .login');
+  return out || null;
+}
+
+function detectGitName() {
+  return tryExec('git config --global user.name');
+}
+
+function detectProjectRemote(path) {
+  const url = tryExec(`git -C "${path}" remote get-url origin`);
+  if (!url) return null;
+  const m = url.match(/[:/]([^/:]+\/[^/]+?)(?:\.git)?$/);
+  return m ? m[1] : null;
+}
+
+async function confirmOverwrite(label, path) {
+  if (!existsSync(path)) return true;
+  const { ok } = await prompts({
+    type: 'confirm',
+    name: 'ok',
+    message: `${label} already exists at ${path}. Overwrite?`,
+    initial: false,
+  });
+  return ok === true;
+}
+
+async function cmdInit() {
+  log.info(kleur.bold('\ndevlog setup\n'));
+  await preflight();
+
+  const defaults = {
+    gitAuthor: detectGitName() || '',
+    githubUser: detectGhUser() || '',
+    targetRepoName: 'daily-dev-log',
+  };
+
+  const answers = await prompts([
+    {
+      type: 'text',
+      name: 'gitAuthor',
+      message: 'Your name (used to filter `git log --author`):',
+      initial: defaults.gitAuthor,
+      validate: (v) => v.trim().length > 0 || 'Required',
+    },
+    {
+      type: 'text',
+      name: 'githubUser',
+      message: 'Your GitHub username:',
+      initial: defaults.githubUser,
+      validate: (v) => /^[a-z0-9-]+$/i.test(v.trim()) || 'Invalid username',
+    },
+    {
+      type: 'text',
+      name: 'targetRepoName',
+      message: 'Name of the repo where dev logs will be published:',
+      initial: defaults.targetRepoName,
+      validate: (v) => /^[a-z0-9._-]+$/i.test(v.trim()) || 'Invalid repo name',
+    },
+    {
+      type: 'confirm',
+      name: 'registerProject',
+      message: 'Register a project now? (you can add more later by editing config.json)',
+      initial: true,
+    },
+  ], { onCancel: () => process.exit(1) });
+
+  let projectAnswers = null;
+  if (answers.registerProject) {
+    const cwd = process.cwd();
+    const cwdRemote = detectProjectRemote(cwd);
+    projectAnswers = await prompts([
+      {
+        type: 'text',
+        name: 'path',
+        message: 'Project absolute path:',
+        initial: cwd,
+        validate: (v) => existsSync(expandHome(v)) || 'Path does not exist',
+      },
+      {
+        type: 'text',
+        name: 'key',
+        message: 'Project key (used as dev-log subdir name):',
+        initial: (prev) => basename(expandHome(prev || cwd)),
+        validate: (v) => /^[a-z0-9._-]+$/i.test(v.trim()) || 'Invalid key',
+      },
+      {
+        type: 'text',
+        name: 'remote',
+        message: 'Project GitHub remote (<owner>/<repo>):',
+        initial: (_prev, values) => detectProjectRemote(expandHome(values.path)) || cwdRemote || `${answers.githubUser}/${basename(expandHome(values.path))}`,
+        validate: (v) => /^[\w.-]+\/[\w.-]+$/.test(v.trim()) || 'Expected <owner>/<repo>',
+      },
+    ], { onCancel: () => process.exit(1) });
+  }
+
+  const targetRepo = `${answers.githubUser}/${answers.targetRepoName}`;
+  const config = {
+    targetRepo,
+    gitAuthor: answers.gitAuthor,
+    githubUser: answers.githubUser,
+    projects: projectAnswers ? [{
+      key: projectAnswers.key,
+      path: expandHome(projectAnswers.path),
+      remote: projectAnswers.remote,
+    }] : [],
+  };
+
+  log.info('\n' + kleur.bold('Summary:'));
+  log.info(`  Target repo:    ${kleur.cyan(`github.com/${targetRepo}`)}`);
+  log.info(`  Git author:     ${config.gitAuthor}`);
+  log.info(`  GitHub user:    ${config.githubUser}`);
+  log.info(`  Projects:       ${config.projects.length === 0 ? '(none — add later)' : config.projects.map(p => p.key).join(', ')}`);
+  log.info(`  Skill location: ${CONFIG_DIR}`);
+
+  const { proceed } = await prompts({
+    type: 'confirm',
+    name: 'proceed',
+    message: 'Continue?',
+    initial: true,
+  }, { onCancel: () => process.exit(1) });
+  if (!proceed) process.exit(0);
+
+  log.info('');
+
+  const repoExists = tryExec(`gh repo view ${targetRepo} --json name`) !== null;
+  if (repoExists) {
+    log.warn(`Repo github.com/${targetRepo} already exists. Will use it as-is.`);
+  } else {
+    log.step(`Creating github.com/${targetRepo}...`);
+    try {
+      execSync(`gh repo create ${targetRepo} --public --description "Daily dev log" --add-readme`, {
+        stdio: 'inherit',
+      });
+      log.ok('Repo created');
+    } catch {
+      log.err('Failed to create repo. Check `gh` permissions.');
+      process.exit(1);
+    }
+  }
+
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    log.ok(`Created ${CONFIG_DIR}`);
+  }
+
+  if (await confirmOverwrite('SKILL.md', SKILL_DEST)) {
+    copyFileSync(SKILL_SRC, SKILL_DEST);
+    log.ok(`Installed SKILL.md → ${SKILL_DEST}`);
+  } else {
+    log.warn('Skipped SKILL.md');
+  }
+
+  if (await confirmOverwrite('config.json', CONFIG_PATH)) {
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
+    log.ok(`Wrote config → ${CONFIG_PATH}`);
+  } else {
+    log.warn('Skipped config.json');
+  }
+
+  log.info('\n' + kleur.bold().green('Done.') + '\n');
+  log.info('Next steps:');
+  log.info(`  1. ${config.projects.length === 0 ? 'Edit config.json to register projects' : '(Optional) edit config.json to register more projects'}`);
+  log.info('  2. Make some commits in a registered project');
+  log.info('  3. In Claude Code, run: /devlog');
+  log.info('  4. Preview locally: npx @natjswenson/devlog preview');
+  log.info('');
+}
+
+async function cmdPreview() {
+  if (!existsSync(CONFIG_PATH)) {
+    log.err(`No config found at ${CONFIG_PATH}`);
+    log.info('Run `npx @natjswenson/devlog init` first.');
+    process.exit(1);
+  }
+
+  let config;
+  try {
+    config = JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+  } catch (e) {
+    log.err(`Failed to parse config: ${e.message}`);
+    process.exit(1);
+  }
+
+  const [owner, repo] = (config.targetRepo || '').split('/');
+  if (!owner || !repo) {
+    log.err('config.targetRepo is not in <owner>/<repo> format');
+    process.exit(1);
+  }
+
+  const projects = (config.projects || []).map((p) => ({ key: p.key, label: p.key }));
+
+  log.step(`Launching preview against github.com/${config.targetRepo}...`);
+
+  const vitePkgPath = require.resolve('vite/package.json');
+  const vitePkg = JSON.parse(readFileSync(vitePkgPath, 'utf8'));
+  const viteBin = resolve(dirname(vitePkgPath), vitePkg.bin?.vite || 'bin/vite.js');
+
+  const proc = spawn(process.execPath, [viteBin], {
+    cwd: PREVIEW_DIR,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      VITE_DEVLOG_OWNER: owner,
+      VITE_DEVLOG_REPO: repo,
+      VITE_DEVLOG_BRANCH: 'main',
+      VITE_DEVLOG_PROJECTS: JSON.stringify(projects),
+    },
+  });
+  proc.on('exit', (code) => process.exit(code ?? 0));
+}
+
+function printHelp() {
+  console.log(`
+${kleur.bold('@natjswenson/devlog')} — daily dev log generator
+
+Usage:
+  npx @natjswenson/devlog init       Set up the skill, create your dev-log repo, write config
+  npx @natjswenson/devlog preview    Run a local preview of your published dev log
+  npx @natjswenson/devlog --help
+  npx @natjswenson/devlog --version
+
+Docs: https://github.com/natejswenson/devlog
+`);
+}
+
+const arg = process.argv[2];
+switch (arg) {
+  case 'init':
+    cmdInit();
+    break;
+  case 'preview':
+    cmdPreview();
+    break;
+  case '-v':
+  case '--version':
+    console.log(readPackageVersion());
+    break;
+  case undefined:
+  case '-h':
+  case '--help':
+    printHelp();
+    break;
+  default:
+    log.err(`Unknown command: ${arg}`);
+    printHelp();
+    process.exit(1);
+}

package/config.example.json

@@ -0,0 +1,17 @@
+{
+  "targetRepo": "yourusername/daily-dev-log",
+  "gitAuthor": "Your Name",
+  "githubUser": "yourusername",
+  "projects": [
+    {
+      "key": "midnight-side-quest",
+      "path": "/Users/yourusername/code/midnight-side-quest",
+      "remote": "yourusername/midnight-side-quest"
+    },
+    {
+      "key": "todays-existential-crisis",
+      "path": "/Users/yourusername/code/todays-existential-crisis",
+      "remote": "yourusername/todays-existential-crisis"
+    }
+  ]
+}