@duckmind/dm 0.26.9

package/README.md

@@ -0,0 +1,5 @@
+<p align="center"><code>npm i -g @duckmind/dm@latest</code></p>
+<p align="center">
+<strong>DuckMind (dm)</strong> is a <strong>minimal, fast AI coworker</strong> that runs in your terminal.
+No UI overhead. Just plan, run, and get things done.
+</p>

package/bin/dm.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+const { spawnSync } = require("node:child_process");
+const { homedir } = require("node:os");
+const { dirname, join } = require("node:path");
+const { existsSync, readFileSync } = require("node:fs");
+
+const targets = {
+  darwin: { arm64: "@duckmind/dm-darwin-arm64", x64: "@duckmind/dm-darwin-x64" },
+  linux: { arm64: "@duckmind/dm-linux-arm64", x64: "@duckmind/dm-linux-x64" },
+  win32: { x64: "@duckmind/dm-windows-x64" },
+};
+
+const packageName = targets[process.platform] && targets[process.platform][process.arch];
+if (!packageName) {
+  console.error(`Unsupported platform ${process.platform}/${process.arch}.`);
+  process.exit(1);
+}
+
+let packageJsonPath;
+try {
+  packageJsonPath = require.resolve(`${packageName}/package.json`);
+} catch (error) {
+  console.error(`Missing optional dependency ${packageName}. Reinstall @duckmind/dm for ${process.platform}/${process.arch}.`);
+  process.exit(1);
+}
+
+const binaryName = process.platform === "win32" ? "dm.exe" : "dm";
+const binaryPath = join(dirname(packageJsonPath), binaryName);
+if (!existsSync(binaryPath)) {
+  console.error(`Expected binary not found at ${binaryPath}.`);
+  process.exit(1);
+}
+
+const DM_FREE_MODEL = process.env.DM_FREE_MODEL || "openai/gpt-4o-mini";
+const DM_LITE_MODEL = process.env.DM_LITE_MODEL || "google/gemini-2.5-flash";
+const DM_SMART_MODEL = process.env.DM_SMART_MODEL || "anthropic/claude-sonnet-4.5";
+const DM_DEEP_MODEL = process.env.DM_DEEP_MODEL || "openai/o3";
+
+function readOpenRouterKey(configPath) {
+  if (!existsSync(configPath)) {
+    return undefined;
+  }
+  try {
+    const rows = readFileSync(configPath, "utf8").split(/\r?\n/);
+    for (const raw of rows) {
+      const line = raw.trim();
+      if (!line || line.startsWith("#") || !line.includes("=")) {
+        continue;
+      }
+      const [key, ...rest] = line.split("=");
+      const value = rest.join("=").trim();
+      if ((key.trim() === "OPENROUTER_API_KEY" || key.trim() === "OPENROUTER_KEY") && value) {
+        return value;
+      }
+    }
+  } catch (error) {
+    return undefined;
+  }
+  return undefined;
+}
+
+function findRepoConfigKey() {
+  const candidates = [];
+  let currentDir = process.cwd();
+  while (true) {
+    candidates.push(join(currentDir, "config", "openrouter.cnf"));
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  const homeDir = homedir();
+  candidates.push(join(homeDir, ".dm", "openrouter.cnf"));
+  candidates.push(join(homeDir, ".config", "dm", "openrouter.cnf"));
+  for (const candidate of candidates) {
+    const value = readOpenRouterKey(candidate);
+    if (value) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+const OPENROUTER_API_KEY =
+  process.env.OPENROUTER_API_KEY || process.env.OPENROUTER_KEY || findRepoConfigKey();
+
+function resolveDuckMindModel(value) {
+  switch (value) {
+    case "free":
+    case "@preset/free":
+    case "duckmind/free":
+    case "duckmind/@preset/free":
+    case "openrouter/free":
+    case "openrouter/@preset/free":
+      return DM_FREE_MODEL;
+    case "lite":
+    case "@preset/lite":
+    case "duckmind/lite":
+    case "duckmind/@preset/lite":
+    case "openrouter/lite":
+    case "openrouter/@preset/lite":
+      return DM_LITE_MODEL;
+    case "smart":
+    case "@preset/smart":
+    case "duckmind/smart":
+    case "duckmind/@preset/smart":
+    case "openrouter/smart":
+    case "openrouter/@preset/smart":
+      return DM_SMART_MODEL;
+    case "deep":
+    case "@preset/deep":
+    case "duckmind/deep":
+    case "duckmind/@preset/deep":
+    case "openrouter/deep":
+    case "openrouter/@preset/deep":
+      return DM_DEEP_MODEL;
+    default:
+      return undefined;
+  }
+}
+
+const args = process.argv.slice(2);
+function printUpgradeHelp() {
+  console.log(`Usage:
+  dm upgrade
+
+Install the latest @duckmind/dm release into the active global prefix.`);
+}
+
+function resolveUpgradeCommand() {
+  const userAgent = process.env.npm_config_user_agent || process.env.NPM_CONFIG_USER_AGENT || "";
+  const isWindows = process.platform === "win32";
+  if (userAgent.startsWith("pnpm/")) {
+    return { file: isWindows ? "pnpm.cmd" : "pnpm", args: ["install", "-g", "@duckmind/dm@latest"] };
+  }
+  if (userAgent.startsWith("yarn/")) {
+    return { file: isWindows ? "yarn.cmd" : "yarn", args: ["global", "add", "@duckmind/dm@latest"] };
+  }
+  if (userAgent.startsWith("bun/")) {
+    return { file: isWindows ? "bun.cmd" : "bun", args: ["install", "-g", "@duckmind/dm@latest"] };
+  }
+  return { file: isWindows ? "npm.cmd" : "npm", args: ["install", "-g", "@duckmind/dm@latest"] };
+}
+
+function runUpgrade(extraArgs) {
+  if (extraArgs.length > 0) {
+    if (extraArgs.length === 1 && (extraArgs[0] === "-h" || extraArgs[0] === "--help")) {
+      printUpgradeHelp();
+      return 0;
+    }
+    console.error(`Unknown option ${extraArgs[0]} for "upgrade".`);
+    console.error('Use "dm upgrade" or "dm upgrade --help".');
+    return 1;
+  }
+
+  const command = resolveUpgradeCommand();
+  const child = spawnSync(command.file, command.args, {
+    stdio: "inherit",
+    env: process.env,
+  });
+  if (child.error) {
+    console.error(child.error.message);
+    return 1;
+  }
+  return typeof child.status === "number" ? child.status : 1;
+}
+
+if (args[0] === "upgrade") {
+  process.exit(runUpgrade(args.slice(1)));
+}
+
+function isDuckmindUltraAlias(value) {
+  return value === "ultra" || value === "@preset/ultra" || value === "duckmind/ultra" || value === "duckmind/@preset/ultra";
+}
+
+let openrouterProvider = false;
+let duckmindProvider = false;
+let requestedModel;
+for (let index = 0; index < args.length; index += 1) {
+  const value = args[index];
+  if (value === "--provider" && index + 1 < args.length) {
+    if (args[index + 1] === "openrouter") {
+      args[index + 1] = "openrouter";
+      openrouterProvider = true;
+    }
+    if (args[index + 1] === "duckmind") {
+      duckmindProvider = true;
+    }
+  }
+  if (value === "--provider=openrouter") {
+    args[index] = "--provider=openrouter";
+    openrouterProvider = true;
+  }
+  if (value === "--provider=duckmind") {
+    duckmindProvider = true;
+  }
+  if (value === "--model" && index + 1 < args.length) {
+    requestedModel = args[index + 1];
+  }
+  if (value.startsWith("--model=")) {
+    requestedModel = value.slice("--model=".length);
+  }
+}
+
+if (duckmindProvider && !isDuckmindUltraAlias(requestedModel)) {
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+    if (value === "--provider" && index + 1 < args.length && args[index + 1] === "duckmind") {
+      args[index + 1] = "openrouter";
+      openrouterProvider = true;
+    }
+    if (value === "--provider=duckmind") {
+      args[index] = "--provider=openrouter";
+      openrouterProvider = true;
+    }
+  }
+}
+
+if (openrouterProvider) {
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+    if (value === "--model" && index + 1 < args.length) {
+      const resolved = resolveDuckMindModel(args[index + 1]);
+      if (resolved) {
+        args[index + 1] = resolved;
+      }
+    }
+    if (value.startsWith("--model=")) {
+      const resolved = resolveDuckMindModel(value.slice("--model=".length));
+      if (resolved) {
+        args[index] = `--model=${resolved}`;
+      }
+    }
+  }
+}
+
+const child = spawnSync(binaryPath, args, {
+  stdio: "inherit",
+  env: {
+    ...process.env,
+    ...(OPENROUTER_API_KEY ? { OPENROUTER_API_KEY } : {}),
+    DM_FREE_MODEL,
+    DM_LITE_MODEL,
+    DM_SMART_MODEL,
+    DM_DEEP_MODEL,
+  },
+});
+if (child.error) {
+  console.error(child.error.message);
+  process.exit(1);
+}
+if (typeof child.status === "number") {
+  process.exit(child.status);
+}
+process.exit(1);

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@duckmind/dm",
+  "version": "0.26.9",
+  "description": "DuckMind (dm) terminal AI coworker",
+  "license": "MIT",
+  "bin": {
+    "dm": "bin/dm.js"
+  },
+  "files": [
+    "README.md",
+    "bin"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "optionalDependencies": {
+    "@duckmind/dm-darwin-arm64": "0.26.9",
+    "@duckmind/dm-darwin-x64": "0.26.9",
+    "@duckmind/dm-linux-arm64": "0.26.9",
+    "@duckmind/dm-linux-x64": "0.26.9",
+    "@duckmind/dm-windows-x64": "0.26.9"
+  }
+}