@pingvinen/donna-assistant 0.9.1 → 0.10.0

package/README.md

@@ -92,7 +92,7 @@ For CLI tools, Donna verifies installation and authentication, learns capabiliti
 
 When multiple tools are registered, Donna runs them in parallel — one agent per tool — so your morning brief stays fast regardless of how many tools you have.
 
-Edit a tool's configuration (scope, capabilities, auth, command, type) at any time:
+Edit a tool's configuration (scope, capabilities, auth, command) at any time:
 
 ```
 /donna:adjust-tool
@@ -126,22 +126,50 @@ The storage repo is yours. Donna only writes to the `donna/` and `daily/` direct
 
 Most commands are safe to run again. Want to update your role? Run `/donna:set-role` again. Added a new tool mid-day? Run `/donna:begin-the-day` again to pull its data in. Re-running a command updates state rather than duplicating it.
 
+## Why not automate tool pulls?
+
+Donna intentionally does not support automated periodic invocations of `/donna:run-tools` (e.g., via cron or background timers). Each tool pull runs inside an AI coding assistant session, which means:
+
+- **Cost** -- every invocation consumes API tokens. A cron job running hourly would burn tokens even when you are not working.
+- **Context** -- tool data is most useful when you are actively looking at it. Pulling data while you are away produces stale results by the time you return.
+- **Conflicts** -- background runs could write to your daily file while you are editing it, causing git merge conflicts in your storage repo.
+
+Instead, run `/donna:run-tools` on demand when you want fresh data, or let `/donna:begin-the-day` handle it as part of your morning routine.
+
 ## All commands
 
+### Setup and configuration
+
 | Command | What it does |
 |---------|-------------|
 | `/donna:setup` | First-time configuration (storage repo, directories) |
 | `/donna:set-role` | Define your job role, get recurring task suggestions |
+
+### Daily workflow
+
+| Command | What it does |
+|---------|-------------|
 | `/donna:begin-the-day` | Morning brief with carry-forward, recurring tasks, tool data |
 | `/donna:add-task` | Capture a task instantly |
 | `/donna:done` | Mark a task complete |
+| `/donna:focus` | Distill today's tasks into a short prioritized focus list |
+
+### Tool management
+
+| Command | What it does |
+|---------|-------------|
 | `/donna:add-tool` | Register an external tool (CLI, REST API, GraphQL API, MCP server) |
-| `/donna:adjust-tool` | Edit a tool's configuration (scope, capabilities, auth, command, type) |
+| `/donna:adjust-tool` | Edit a tool's configuration (scope, capabilities, auth, command) |
+| `/donna:remove-tool` | Remove a registered tool from tools.md |
 | `/donna:run-tools` | Refresh tool data mid-day |
 | `/donna:relearn-tools` | Update CLI tool knowledge after upgrades |
+
+### Help and feedback
+
+| Command | What it does |
+|---------|-------------|
 | `/donna:help` | Conversational troubleshooting for config, storage, or skill issues |
 | `/donna:contribute-idea` | Submit a feature idea or bug report via GitHub Issues |
-| `/donna:focus` | Distill today's tasks into a short prioritized focus list |
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pingvinen/donna-assistant",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Donna - your AI powered personal assistant",
   "bin": {
     "donna-assistant": "./bin/donna-assistant"

package/src/donna-tools.cjs

@@ -0,0 +1,429 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const https = require("node:https");
+const { execSync } = require("node:child_process");
+
+const { readVersion } = require("./version.cjs");
+const { runMigrations } = require("./migrator.cjs");
+const { semverGt } = require("./changelog.cjs");
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Config reader
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Read and parse ~/.config/donna/config.md YAML frontmatter.
+ *
+ * @param {string} homeDir - Home directory override (for testing)
+ * @returns {{ storage_repo: string|null, daily_folder: string, auto_push: boolean }|null}
+ */
+function readConfig(homeDir) {
+    const configPath = path.join(homeDir, ".config", "donna", "config.md");
+    if (!fs.existsSync(configPath)) return null;
+
+    const content = fs.readFileSync(configPath, "utf8");
+
+    const storage_repo = content.match(/^storage_repo:\s*(.+)$/m)?.[1]?.trim() || null;
+    const daily_folder = content.match(/^daily_folder:\s*(.+)$/m)?.[1]?.trim() || "daily";
+    const auto_push_str = content.match(/^auto_push:\s*(.+)$/m)?.[1]?.trim() || "false";
+    const auto_push = auto_push_str === "true";
+
+    return { storage_repo, daily_folder, auto_push };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Version check
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Fetch the latest version from npm registry.
+ * Returns the latest version string or null on any failure.
+ *
+ * @param {number} [timeout=3000] - Socket timeout in ms
+ * @returns {Promise<string|null>}
+ */
+function fetchLatestVersionFromRegistry(timeout = 3000) {
+    return new Promise((resolve) => {
+        const req = https.get(
+            "https://registry.npmjs.org/@pingvinen%2Fdonna-assistant",
+            { headers: { Accept: "application/json" } },
+            (res) => {
+                if (res.statusCode !== 200) {
+                    resolve(null);
+                    return;
+                }
+                let data = "";
+                res.on("data", (chunk) => {
+                    data += chunk;
+                });
+                res.on("end", () => {
+                    try {
+                        const latest = JSON.parse(data)["dist-tags"]?.latest || null;
+                        resolve(latest);
+                    } catch {
+                        resolve(null);
+                    }
+                });
+            },
+        );
+        req.setTimeout(timeout, () => {
+            req.destroy();
+            resolve(null);
+        });
+        req.on("error", () => resolve(null));
+    });
+}
+
+/**
+ * Read version-check.md cache from donnaDir.
+ * Returns { date, latest } or null if file doesn't exist or can't be parsed.
+ *
+ * @param {string} donnaDir
+ * @returns {{ date: string, latest: string }|null}
+ */
+function readVersionCache(donnaDir) {
+    const cachePath = path.join(donnaDir, "version-check.md");
+    if (!fs.existsSync(cachePath)) return null;
+
+    const content = fs.readFileSync(cachePath, "utf8");
+    const date = content.match(/^checked_on:\s*(.+)$/m)?.[1]?.trim();
+    const latest = content.match(/^latest_version:\s*(.+)$/m)?.[1]?.trim();
+    if (!date || !latest) return null;
+    return { date, latest };
+}
+
+/**
+ * Write version-check.md cache to donnaDir.
+ *
+ * @param {string} donnaDir
+ * @param {string} date - YYYY-MM-DD
+ * @param {string} latestVersion
+ */
+function writeVersionCache(donnaDir, date, latestVersion) {
+    const cachePath = path.join(donnaDir, "version-check.md");
+    fs.writeFileSync(
+        cachePath,
+        `---\nchecked_on: ${date}\nlatest_version: ${latestVersion}\n---\n`,
+    );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Obsidian daily-notes sync
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Sync Obsidian daily-notes.json with the configured daily_folder.
+ * Mutates the configMd file if the folder differs.
+ *
+ * @param {string} storageRepo
+ * @param {string} configPath
+ * @param {string} dailyFolder
+ * @returns {string} - Possibly updated daily_folder
+ */
+function syncObsidianDailyNotes(storageRepo, configPath, dailyFolder) {
+    const obsidianDir = path.join(storageRepo, ".obsidian");
+    const dailyNotesJson = path.join(obsidianDir, "daily-notes.json");
+
+    if (fs.existsSync(dailyNotesJson)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(dailyNotesJson, "utf8"));
+            if (parsed.folder && parsed.folder !== dailyFolder) {
+                // Sync config to Obsidian's value
+                const configContent = fs.readFileSync(configPath, "utf8");
+                const updated = configContent.replace(
+                    /^daily_folder:\s*.+$/m,
+                    `daily_folder: ${parsed.folder}`,
+                );
+                fs.writeFileSync(configPath, updated);
+                return parsed.folder;
+            }
+        } catch {
+            // Parse error — ignore
+        }
+    } else if (fs.existsSync(obsidianDir)) {
+        // .obsidian/ exists but no daily-notes.json — write it
+        try {
+            fs.writeFileSync(dailyNotesJson, JSON.stringify({ folder: dailyFolder }, null, 2));
+        } catch {
+            // Ignore errors writing Obsidian config
+        }
+    }
+
+    return dailyFolder;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Subcommand handlers
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Run the `init` subcommand.
+ *
+ * Reads config, runs migrations, syncs Obsidian, checks for updates.
+ *
+ * @param {string[]} _args
+ * @param {object} [options]
+ * @param {string} [options.homeDir] - Override home directory (for testing)
+ * @param {Function} [options.fetchLatestVersion] - Override for network call (for testing)
+ * @returns {Promise<object>}
+ */
+async function runInit(_args, options = {}) {
+    const homeDir = options.homeDir || os.homedir();
+    const donnaDir = path.join(homeDir, ".donna");
+    const migrationsDir = path.join(__dirname, "..", "migrations");
+    const fetchLatestVersion = options.fetchLatestVersion || fetchLatestVersionFromRegistry;
+
+    // Read config
+    const config = readConfig(homeDir);
+    if (!config || !config.storage_repo) {
+        return { error: "not_configured", storage_repo: null };
+    }
+
+    let { storage_repo, daily_folder, auto_push } = config;
+
+    // Sync Obsidian daily-notes
+    const configPath = path.join(homeDir, ".config", "donna", "config.md");
+    daily_folder = syncObsidianDailyNotes(storage_repo, configPath, daily_folder);
+
+    // Run migrations
+    const versionInfo = readVersion(donnaDir);
+    const lastMigration = versionInfo?.lastMigration || 0;
+    const migrationResults = runMigrations(migrationsDir, donnaDir, lastMigration);
+    const migrations_applied = migrationResults.filter((r) => r.ok).map((r) => r.description);
+
+    // Version check (once per day, non-blocking)
+    let update_available = null;
+    try {
+        const today = new Date().toISOString().slice(0, 10);
+        const cache = readVersionCache(donnaDir);
+
+        let latestVersion;
+        if (cache && cache.date === today) {
+            // Cache hit — use cached value
+            latestVersion = cache.latest;
+        } else {
+            // Cache miss — fetch from registry
+            latestVersion = await fetchLatestVersion();
+            if (latestVersion) {
+                writeVersionCache(donnaDir, today, latestVersion);
+            }
+        }
+
+        if (latestVersion) {
+            const pkg = require("../package.json");
+            const currentVersion = versionInfo?.version || pkg.version;
+            if (semverGt(latestVersion, currentVersion)) {
+                update_available = latestVersion;
+            }
+        }
+    } catch {
+        // Never throw from version check — treat as no update available
+        update_available = null;
+    }
+
+    return {
+        storage_repo,
+        daily_folder,
+        auto_push,
+        update_available,
+        migrations_applied,
+        error: null,
+    };
+}
+
+/**
+ * Run the `commit` subcommand.
+ *
+ * Args: commit <msg> --files f1 f2 ...
+ *
+ * @param {string[]} args
+ * @param {object} [options]
+ * @param {string} [options.homeDir] - Override home directory (for testing)
+ * @returns {Promise<object>}
+ */
+async function runCommit(args, options = {}) {
+    const homeDir = options.homeDir || os.homedir();
+    const config = readConfig(homeDir);
+    if (!config || !config.storage_repo) {
+        return { error: "not_configured" };
+    }
+
+    const { storage_repo, auto_push } = config;
+
+    // Parse message and files
+    const filesIdx = args.indexOf("--files");
+    const message = args[0] || "";
+    const files = filesIdx !== -1 ? args.slice(filesIdx + 1) : [];
+
+    try {
+        // Stage files
+        if (files.length > 0) {
+            for (const file of files) {
+                execSync(`git -C ${JSON.stringify(storage_repo)} add ${JSON.stringify(file)}`, {
+                    stdio: "pipe",
+                });
+            }
+        } else {
+            execSync(`git -C ${JSON.stringify(storage_repo)} add -A`, { stdio: "pipe" });
+        }
+
+        // Check if there's anything to commit
+        const status = execSync(`git -C ${JSON.stringify(storage_repo)} status --porcelain`, {
+            stdio: "pipe",
+            encoding: "utf8",
+        });
+
+        if (!status || status.trim() === "") {
+            return { committed: false, reason: "nothing_to_commit" };
+        }
+
+        // Commit
+        execSync(`git -C ${JSON.stringify(storage_repo)} commit -m ${JSON.stringify(message)}`, {
+            stdio: "pipe",
+        });
+
+        // Push if auto_push
+        if (auto_push) {
+            execSync(`git -C ${JSON.stringify(storage_repo)} push`, { stdio: "pipe" });
+        }
+
+        return { committed: true, message };
+    } catch (err) {
+        return { error: err.message, committed: false };
+    }
+}
+
+/**
+ * Run the `daily-path` subcommand.
+ *
+ * @param {string[]} _args
+ * @param {object} [options]
+ * @param {string} [options.homeDir] - Override home directory (for testing)
+ * @returns {Promise<object>}
+ */
+async function runDailyPath(_args, options = {}) {
+    const homeDir = options.homeDir || os.homedir();
+    const config = readConfig(homeDir);
+    if (!config || !config.storage_repo) {
+        return { error: "not_configured" };
+    }
+
+    const { storage_repo, daily_folder } = config;
+    const today = new Date().toISOString().slice(0, 10);
+    const dailyDir = path.join(storage_repo, daily_folder);
+    const filePath = path.join(dailyDir, `${today}.md`);
+
+    // Create directory if it doesn't exist
+    fs.mkdirSync(dailyDir, { recursive: true });
+
+    return { path: filePath };
+}
+
+/**
+ * Run the `resolve-secret` subcommand.
+ *
+ * Args: resolve-secret <key>
+ *
+ * @param {string[]} args
+ * @param {object} [options]
+ * @param {string} [options.homeDir] - Override home directory (for testing)
+ * @returns {Promise<object>}
+ */
+async function runResolveSecret(args, options = {}) {
+    const homeDir = options.homeDir || os.homedir();
+    const config = readConfig(homeDir);
+    if (!config || !config.storage_repo) {
+        return { error: "not_configured" };
+    }
+
+    const { storage_repo } = config;
+    const key = args[0];
+
+    if (!key) {
+        return { error: "missing_key" };
+    }
+
+    const secretsPath = path.join(storage_repo, "donna", "secrets.md");
+    if (!fs.existsSync(secretsPath)) {
+        return { error: "secrets_not_found", key };
+    }
+
+    const content = fs.readFileSync(secretsPath, "utf8");
+
+    // Parse "- KEY: value" pattern (allowing optional spaces)
+    const pattern = new RegExp(`^-\\s+${key}:\\s*(.+)$`, "m");
+    const match = content.match(pattern);
+
+    if (!match) {
+        return { error: "key_not_found", key };
+    }
+
+    const value = match[1].trim();
+
+    // Check for placeholder patterns
+    if (
+        /^your-.+-here$/i.test(value) ||
+        value === "TODO" ||
+        value === "PLACEHOLDER" ||
+        value === "xxx" ||
+        /^<.+>$/.test(value)
+    ) {
+        return { error: "placeholder_value", key, value };
+    }
+
+    return { key, value };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// CLI entry point
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Main CLI entry point. Routes subcommands and prints JSON to stdout.
+ */
+async function main() {
+    const args = process.argv.slice(2);
+    const cmd = args[0];
+
+    if (cmd === "init") {
+        const result = await runInit(args.slice(1));
+        console.log(JSON.stringify(result));
+        return;
+    }
+
+    if (cmd === "commit") {
+        const result = await runCommit(args.slice(1));
+        console.log(JSON.stringify(result));
+        return;
+    }
+
+    if (cmd === "daily-path") {
+        const result = await runDailyPath(args.slice(1));
+        console.log(JSON.stringify(result));
+        return;
+    }
+
+    if (cmd === "resolve-secret") {
+        const result = await runResolveSecret(args.slice(1));
+        console.log(JSON.stringify(result));
+        return;
+    }
+
+    process.stderr.write(`Unknown command: ${cmd}\n`);
+    process.exit(1);
+}
+
+main.catch = undefined; // prevent accidental chaining — the module handles it below
+
+module.exports = { main, runInit, runCommit, runDailyPath, runResolveSecret };
+
+// Only run main when invoked directly (not when require()'d in tests)
+if (require.main === module) {
+    main().catch((err) => {
+        process.stderr.write(`${err.message}\n`);
+        process.exit(1);
+    });
+}

package/src/installer.cjs

@@ -79,7 +79,7 @@ async function run(options = {}) {
         for (const provider of detected) {
             fs.cpSync(provider.stubSource, provider.stubTarget, { recursive: true });
             output.success(
-                `Copied donna skills (setup, add-task, done, set-role, begin-the-day, add-tool, relearn-tools, run-tools, help, contribute-idea, adjust-tool, focus) to ${provider.stubTarget}`,
+                `Copied donna skills (setup, add-task, done, set-role, begin-the-day, add-tool, remove-tool, relearn-tools, run-tools, help, contribute-idea, adjust-tool, focus) to ${provider.stubTarget}`,
             );
         }
     } else {
@@ -93,13 +93,35 @@ async function run(options = {}) {
     fs.cpSync(workflowsSource, workflowsTarget, { recursive: true });
     output.success("Installed workflows to ~/.donna/workflows/");
 
+    // Copy donna-tools.cjs and its dependencies to donnaDir for workflow access
+    const toolFiles = [
+        "donna-tools.cjs",
+        "version.cjs",
+        "migrator.cjs",
+        "changelog.cjs",
+        "output.cjs",
+    ];
+    for (const file of toolFiles) {
+        const src = path.join(__dirname, file);
+        if (fs.existsSync(src)) {
+            fs.copyFileSync(src, path.join(donnaDir, file));
+        }
+    }
+    output.success("Installed donna-tools.cjs + dependencies to ~/.donna/");
+
     // Write version.md
     version.writeVersion(donnaDir, packageVersion, lastSuccessful);
     output.success(`Version ${packageVersion} installed`);
 
-    // Final message
-    console.log("");
-    output.info("Run /donna:setup in Claude Code to get started.");
+    // Final message — suppress setup prompt if already configured (D-04)
+    const configPath = path.join(homeDir, ".config", "donna", "config.md");
+    const isConfigured =
+        fs.existsSync(configPath) && fs.readFileSync(configPath, "utf8").includes("storage_repo:");
+
+    if (!isConfigured) {
+        console.log("");
+        output.info("Run /donna:setup in Claude Code to get started.");
+    }
 }
 
 module.exports = { run };

package/stubs/claude-code/donna/remove-tool.md

@@ -0,0 +1,17 @@
+---
+name: donna:remove-tool
+description: Remove a registered tool from tools.md
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Run the Donna remove-tool workflow. Remove a registered tool cleanly.
+</objective>
+
+<execution_context>
+@~/.donna/workflows/remove-tool.md
+</execution_context>

package/workflows/add-task.md

@@ -4,62 +4,25 @@
 Capture a new task to today's daily journal file in the storage repo and commit it to git.
 </objective>
 
-<step name="read-config">
-Read `~/.config/donna/config.md`.
-
-If the file does not exist, print:
-```
-✗ Donna is not configured. Run /donna:setup first.
-```
-Stop.
-
-Extract the `storage_repo`, `daily_folder` (default: `daily`), and `auto_push` (default: false) fields from the YAML frontmatter.
-
-**Obsidian sync:** Check if `<storage_repo>/.obsidian/daily-notes.json` exists.
-- If it exists and has a `folder` field that differs from `<daily_folder>`: update `<daily_folder>` to match Obsidian's value, and update `~/.config/donna/config.md` with the new `daily_folder`. Print `✓ Synced daily folder with Obsidian: <daily_folder>`.
-- If `<storage_repo>/.obsidian/` exists but `daily-notes.json` does not exist or has no `folder` field: write `<storage_repo>/.obsidian/daily-notes.json` with `{"folder":"<daily_folder>"}`. Print `✓ Configured Obsidian daily notes to use <daily_folder>/`.
-- Otherwise: do nothing.
-</step>
-
-<step name="check-pending-migrations">
-Read `~/.donna/state.md` with the Read tool. If the file does not exist or has no `pending_migrations` field in its YAML frontmatter, skip this step.
-
-For each entry in `pending_migrations`:
-
-**`move-standing-files`:** Move standing files from storage repo root to donna/ subfolder.
-
+<step name="init">
 Run via Bash:
 ```bash
-STORAGE_REPO="<storage_repo>"
-DONNA_DIR="$STORAGE_REPO/donna"
-MOVED=0
-
-mkdir -p "$DONNA_DIR"
-for FILE in role.md recurring.md role-research.md; do
-    if [ -f "$STORAGE_REPO/$FILE" ] && [ ! -f "$DONNA_DIR/$FILE" ]; then
-        mv "$STORAGE_REPO/$FILE" "$DONNA_DIR/$FILE"
-        echo "Moved $FILE to donna/$FILE"
-        MOVED=$((MOVED + 1))
-    fi
-done
-
-echo "MOVED=$MOVED"
+INIT=$(node ~/.donna/donna-tools.cjs init)
 ```
 
-If MOVED > 0, commit the move:
-```bash
-git -C <storage_repo> add -A
-git -C <storage_repo> diff --cached --quiet || git -C <storage_repo> commit -m "donna(migrate): move standing files to donna/ subfolder"
+Parse the JSON response. If the `error` field is `"not_configured"`, print:
 ```
+x Donna is not configured. Run /donna:setup first.
+```
+Stop.
 
-If `auto_push` is true in config, also push.
+Extract `storage_repo`, `daily_folder`, `auto_push` from the JSON.
 
-After processing all pending migrations, update `~/.donna/state.md` with the Write tool: remove the completed entries from `pending_migrations`. If no entries remain, write:
-```markdown
----
-pending_migrations: []
----
+If `update_available` is non-null, print:
+```
+Donna v<update_available> available -- run npx @pingvinen/donna-assistant to update
 ```
+Continue normally.
 </step>
 
 <step name="get-description">
@@ -74,17 +37,11 @@ Store the response as `<description>`.
 </step>
 
 <step name="ensure-daily-file">
-Run via Bash to get today's date:
-```bash
-date +%Y-%m-%d
-```
-
-Store the result as `<date>`. Construct the daily file path: `<storage_repo>/<daily_folder>/<date>.md`.
-
-Run via Bash to ensure the daily folder exists:
+Get the daily file path via donna-tools:
 ```bash
-mkdir -p <storage_repo>/<daily_folder>
+DAILY_PATH=$(node ~/.donna/donna-tools.cjs daily-path | node -e "process.stdin.resume();let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).path))")
 ```
+Store the result as `<daily_file_path>`. Extract `<date>` from the filename (last path component without `.md`).
 
 If the daily file does not exist, create it with the Write tool using this content (substituting the actual date):
 ```markdown
@@ -107,24 +64,7 @@ Write the updated file with the Write tool.
 <step name="git-commit">
 Run via Bash:
 ```bash
-git -C <storage_repo> add -A
-```
-
-Check whether there is anything to commit:
-```bash
-git -C <storage_repo> status --porcelain
-```
-
-If the output is empty, skip the commit and continue.
-
-Otherwise, run:
-```bash
-git -C <storage_repo> commit -m "donna(add-task): <description>"
-```
-
-If `auto_push` is true in config, also run:
-```bash
-git -C <storage_repo> push
+node ~/.donna/donna-tools.cjs commit "donna(task): added <description>" --files <daily_folder>/<date>.md
 ```
 </step>