@pingvinen/donna-assistant 0.0.0 → 0.3.2

package/README.md

@@ -1 +1,2 @@
-Placeholder release for trusted publishing setup. Real content will be published via CI.
+# donna
+A Claude skill based personal assistant

package/bin/donna-assistant

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+"use strict";
+
+const { run } = require("../src/installer.cjs");
+
+run().catch((err) => {
+    console.error(`\nInstallation failed: ${err.message}`);
+    process.exit(1);
+});

package/migrations/001-initial.cjs

@@ -0,0 +1,12 @@
+"use strict";
+
+module.exports = {
+    version: "0.1.0",
+    description: "Initial directory structure",
+    up(ctx) {
+        const dirs = ["workflows", "templates", "references"];
+        for (const dir of dirs) {
+            ctx.fs.mkdirSync(ctx.path.join(ctx.donnaDir, dir), { recursive: true });
+        }
+    },
+};

package/package.json

@@ -1,8 +1,44 @@
 {
-    "name": "@pingvinen/donna-assistant",
-    "version": "0.0.0",
-    "description": "Donna - your AI powered personal assistant (placeholder for trusted publishing setup)",
-    "publishConfig": {
-        "access": "public"
-    }
+  "name": "@pingvinen/donna-assistant",
+  "version": "0.3.2",
+  "description": "Donna - your AI powered personal assistant",
+  "bin": {
+    "donna-assistant": "./bin/donna-assistant"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "stubs/",
+    "workflows/",
+    "migrations/",
+    "templates/",
+    "references/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "test": "node --test 'test/*.test.cjs'",
+    "prepublishOnly": "chmod +x bin/donna-assistant"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.0"
+  },
+  "keywords": [
+    "claude-code",
+    "assistant",
+    "productivity",
+    "ai"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pingvinen/donna"
+  }
 }

package/src/installer.cjs

@@ -0,0 +1,98 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const output = require("./output.cjs");
+const version = require("./version.cjs");
+const migrator = require("./migrator.cjs");
+const providers = require("./providers/index.cjs");
+
+/**
+ * Main installer orchestration.
+ *
+ * @param {object} [options]
+ * @param {string} [options.homeDir] - Override home directory (for testing)
+ * @returns {Promise<void>}
+ */
+async function run(options = {}) {
+    const homeDir = options.homeDir || os.homedir();
+    const donnaDir = path.join(homeDir, ".donna");
+    const migrationsDir = path.join(__dirname, "..", "migrations");
+    const workflowsSource = path.join(__dirname, "..", "workflows");
+    const pkg = require("../package.json");
+    const packageVersion = pkg.version;
+
+    // Print banner
+    output.banner();
+
+    // Create donnaDir if it doesn't exist
+    fs.mkdirSync(donnaDir, { recursive: true });
+
+    // Read current version
+    const current = version.readVersion(donnaDir);
+    const currentVersion = current?.version || null;
+    const lastMigration = current?.lastMigration || 0;
+
+    // Check if already up to date
+    if (currentVersion === packageVersion) {
+        // Check for pending migrations too
+        const pendingResults = migrator.runMigrations(migrationsDir, donnaDir, lastMigration);
+        if (pendingResults.length === 0) {
+            output.info(`Already up to date at ${packageVersion}`);
+            return;
+        }
+    }
+
+    // If upgrading (current version exists but differs)
+    if (currentVersion && currentVersion !== packageVersion) {
+        output.upgradeHeader(currentVersion, packageVersion);
+    }
+
+    // Run migrations
+    const results = migrator.runMigrations(migrationsDir, donnaDir, lastMigration);
+
+    // Track last successful migration number
+    let lastSuccessful = lastMigration;
+
+    for (const result of results) {
+        if (result.ok) {
+            output.migrationLine(result.description);
+            lastSuccessful = result.num;
+        } else {
+            output.fail(`Migration ${result.num} failed: ${result.error.message}`);
+            // Write version.md with last successful migration
+            version.writeVersion(donnaDir, packageVersion, lastSuccessful);
+            throw result.error;
+        }
+    }
+
+    // Detect providers and copy stubs
+    const detected = providers.detectProviders(homeDir);
+
+    if (detected.length > 0) {
+        for (const provider of detected) {
+            fs.cpSync(provider.stubSource, provider.stubTarget, { recursive: true });
+            output.success(`Copied donna:setup to ${provider.stubTarget}`);
+        }
+    } else {
+        output.info("No supported AI providers detected");
+        output.info("Install Claude Code and re-run to add donna skills");
+    }
+
+    // Copy workflows to donnaDir/workflows/
+    const workflowsTarget = path.join(donnaDir, "workflows");
+    fs.mkdirSync(workflowsTarget, { recursive: true });
+    fs.cpSync(workflowsSource, workflowsTarget, { recursive: true });
+    output.success("Installed workflows to ~/.donna/workflows/");
+
+    // Write version.md
+    version.writeVersion(donnaDir, packageVersion, lastSuccessful);
+    output.success(`Version ${packageVersion} installed`);
+
+    // Final message
+    output.info("Run /donna:setup in Claude Code to get started.");
+}
+
+module.exports = { run };

package/src/migrator.cjs

@@ -0,0 +1,44 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+/**
+ * Run pending migrations from migrationsDir against donnaDir.
+ * Skips migrations with numeric prefix <= lastMigration.
+ * Stops on first failure.
+ *
+ * @param {string} migrationsDir - Directory containing numbered .cjs migration files
+ * @param {string} donnaDir - The ~/.donna/ directory
+ * @param {number} lastMigration - Last successfully applied migration number
+ * @returns {Array<{num: number, description: string, ok: boolean, error?: Error}>}
+ */
+function runMigrations(migrationsDir, donnaDir, lastMigration) {
+    if (!fs.existsSync(migrationsDir)) return [];
+
+    const files = fs
+        .readdirSync(migrationsDir)
+        .filter((f) => f.endsWith(".cjs"))
+        .sort((a, b) => Number.parseInt(a, 10) - Number.parseInt(b, 10));
+
+    const pending = files.filter((f) => Number.parseInt(f, 10) > lastMigration);
+    const results = [];
+
+    for (const file of pending) {
+        const migration = require(path.join(migrationsDir, file));
+        const num = Number.parseInt(file, 10);
+
+        try {
+            migration.up({ donnaDir, fs, path, os });
+            results.push({ num, description: migration.description, ok: true });
+        } catch (err) {
+            results.push({ num, description: migration.description, ok: false, error: err });
+            break;
+        }
+    }
+
+    return results;
+}
+
+module.exports = { runMigrations };

package/src/output.cjs

@@ -0,0 +1,29 @@
+"use strict";
+
+function banner() {
+    console.log("");
+    console.log("━━━ DONNA ━━━");
+    console.log("");
+}
+
+function success(msg) {
+    console.log(`  \u2713 ${msg}`);
+}
+
+function fail(msg) {
+    console.log(`  \u2717 ${msg}`);
+}
+
+function info(msg) {
+    console.log(`  ${msg}`);
+}
+
+function upgradeHeader(from, to) {
+    console.log(`  Upgrading ${from} \u2192 ${to}:`);
+}
+
+function migrationLine(desc) {
+    console.log(`    \u2022 ${desc}`);
+}
+
+module.exports = { banner, success, fail, info, upgradeHeader, migrationLine };

package/src/providers/claude-code.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+module.exports = {
+    name: "Claude Code",
+
+    detect(homeDir) {
+        return fs.existsSync(path.join(homeDir, ".claude"));
+    },
+
+    stubSource: path.join(__dirname, "..", "..", "stubs", "claude-code"),
+
+    getStubTarget(homeDir) {
+        return path.join(homeDir, ".claude", "commands");
+    },
+};

package/src/providers/index.cjs

@@ -0,0 +1,21 @@
+"use strict";
+
+const claudeCode = require("./claude-code.cjs");
+
+const PROVIDERS = [claudeCode];
+
+/**
+ * Detect which AI coding assistant providers are installed.
+ *
+ * @param {string} homeDir - The user's home directory
+ * @returns {Array<{name: string, stubSource: string, stubTarget: string}>}
+ */
+function detectProviders(homeDir) {
+    return PROVIDERS.filter((p) => p.detect(homeDir)).map((p) => ({
+        name: p.name,
+        stubSource: p.stubSource,
+        stubTarget: p.getStubTarget(homeDir),
+    }));
+}
+
+module.exports = { detectProviders };

package/src/version.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+function readVersion(donnaDir) {
+    const versionPath = path.join(donnaDir, "version.md");
+    if (!fs.existsSync(versionPath)) return null;
+
+    const content = fs.readFileSync(versionPath, "utf8");
+    const version = content.match(/\*\*Version:\*\* (.+)/)?.[1] || "0.0.0";
+    const lastMigration = Number.parseInt(
+        content.match(/\*\*Last migration:\*\* (\d+)/)?.[1] || "0",
+        10,
+    );
+    const installed = content.match(/\*\*Installed:\*\* (.+)/)?.[1] || null;
+    const updated = content.match(/\*\*Updated:\*\* (.+)/)?.[1] || null;
+
+    return { version, lastMigration, installed, updated };
+}
+
+function writeVersion(donnaDir, version, lastMigration) {
+    const versionPath = path.join(donnaDir, "version.md");
+    const now = new Date().toISOString();
+
+    let installed = now;
+
+    // Preserve the original "Installed" timestamp if file already exists
+    if (fs.existsSync(versionPath)) {
+        const existing = readVersion(donnaDir);
+        if (existing?.installed) {
+            installed = existing.installed;
+        }
+    }
+
+    const content = [
+        "# Donna",
+        "",
+        `- **Version:** ${version}`,
+        `- **Last migration:** ${String(lastMigration).padStart(3, "0")}`,
+        `- **Installed:** ${installed}`,
+        `- **Updated:** ${now}`,
+        "",
+    ].join("\n");
+
+    fs.writeFileSync(versionPath, content);
+}
+
+module.exports = { readVersion, writeVersion };

package/stubs/claude-code/donna/setup.md

@@ -0,0 +1,15 @@
+---
+name: donna:setup
+description: Set up Donna assistant for this machine
+allowed-tools:
+  - Read
+  - Bash
+---
+
+<objective>
+Run the Donna setup workflow. This command verifies that Donna is installed correctly by loading the setup workflow from the shared runtime directory and displaying the current installation status.
+</objective>
+
+<execution_context>
+@~/.donna/workflows/setup.md
+</execution_context>

package/workflows/setup.md

@@ -0,0 +1,42 @@
+# Donna Setup Workflow
+
+<objective>
+Display the Donna installation status and confirm the stub-to-workflow pipeline is working.
+</objective>
+
+<step name="banner">
+Print the DONNA banner:
+```
+━━━ DONNA ▸ Setup ━━━
+```
+</step>
+
+<step name="version">
+Read `~/.donna/version.md` and display the installed version. If the file exists, show:
+```
+Version: {version}
+Installed: {installed date}
+Last updated: {updated date}
+```
+If the file does not exist, show:
+```
+No version file found. Donna may not be installed correctly.
+Try running: npx @pingvinen/donna-assistant
+```
+</step>
+
+<step name="status">
+Print the following message:
+```
+This is a stub -- real setup coming in Phase 2.
+```
+</step>
+
+<step name="next">
+Print next steps:
+```
+Next steps:
+  - Run /donna:setup again after upgrading to see new features
+  - Phase 2 will add role configuration, storage setup, and more
+```
+</step>