hotmilk 0.1.9 → 0.1.11

package/src/bootstrap/global-extension-sources.ts

@@ -0,0 +1,154 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  detectGlobalProviderForBundledExtension,
+  HOTMILK_PACKAGE_NAME,
+} from "../config/bundled-package-registry.ts";
+import { BUNDLED_EXTENSION_IDS, type BundledExtensionId } from "../config/hotmilk.ts";
+
+const PI_PROJECT_CONFIG_DIR = ".pi";
+
+export type GlobalBundledExtensionSkip = {
+  id: BundledExtensionId;
+  packageName: string;
+};
+
+export type CollectGlobalExtensionSourcesOptions = {
+  cwd?: string;
+  homedir?: string;
+};
+
+function isLocalPackageEntry(entry: string): boolean {
+  return entry.startsWith("/") || /^[a-zA-Z]:[/\\]/.test(entry);
+}
+
+function readPackageName(dir: string): string | null {
+  try {
+    const pkgPath = path.join(dir, "package.json");
+    if (!fs.existsSync(pkgPath)) return null;
+    const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as { name?: unknown };
+    return typeof parsed.name === "string" ? parsed.name : null;
+  } catch {
+    return null;
+  }
+}
+
+function resolvePackageNameFromLocalPath(entry: string, baseDir: string): string | null {
+  const resolved = path.isAbsolute(entry) ? entry : path.resolve(baseDir, entry);
+  if (!fs.existsSync(resolved)) {
+    return null;
+  }
+
+  let dir = resolved;
+  try {
+    if (!fs.statSync(resolved).isDirectory()) {
+      dir = path.dirname(resolved);
+    }
+  } catch {
+    return null;
+  }
+
+  while (true) {
+    const name = readPackageName(dir);
+    if (name) {
+      return name;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+
+/** Parse `npm:@scope/pkg@1.2.3` → `@scope/pkg`, or `npm:pkg` → `pkg`. */
+export function parseNpmPackageName(entry: string): string | null {
+  const trimmed = entry.trim();
+  if (!trimmed.startsWith("npm:")) {
+    return null;
+  }
+
+  const spec = trimmed.slice("npm:".length).trim();
+  if (!spec) {
+    return null;
+  }
+
+  const versionAt = spec.startsWith("@") ? spec.indexOf("@", 1) : spec.indexOf("@");
+  return versionAt === -1 ? spec : spec.slice(0, versionAt);
+}
+
+function toStringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((entry): entry is string => typeof entry === "string")
+    : [];
+}
+
+function readSettingsEntries(settingsPath: string): string[] {
+  if (!fs.existsSync(settingsPath)) {
+    return [];
+  }
+
+  try {
+    const raw = fs.readFileSync(settingsPath, "utf-8").trim();
+    if (!raw) return [];
+    const settings = JSON.parse(raw) as Record<string, unknown>;
+    return [...toStringArray(settings.packages), ...toStringArray(settings.extensions)];
+  } catch {
+    return [];
+  }
+}
+
+/** Collect npm package names referenced by Pi settings (global + project). */
+export function collectInstalledPackageNamesFromPiSettings(
+  options: CollectGlobalExtensionSourcesOptions = {},
+): Set<string> {
+  const home = options.homedir ?? process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
+  const cwd = options.cwd ?? process.cwd();
+  const names = new Set<string>();
+
+  const sources: Array<{ settingsPath: string; baseDir: string }> = [
+    {
+      settingsPath: path.join(home, ".pi", "agent", "settings.json"),
+      baseDir: path.join(home, ".pi", "agent"),
+    },
+    { settingsPath: path.join(cwd, PI_PROJECT_CONFIG_DIR, "settings.json"), baseDir: cwd },
+  ];
+
+  for (const { settingsPath, baseDir } of sources) {
+    for (const entry of readSettingsEntries(settingsPath)) {
+      const npmName = parseNpmPackageName(entry);
+      if (npmName) {
+        names.add(npmName);
+        continue;
+      }
+
+      if (isLocalPackageEntry(entry)) {
+        const localName = resolvePackageNameFromLocalPath(entry, baseDir);
+        if (localName) {
+          names.add(localName);
+        }
+      }
+    }
+  }
+
+  names.delete(HOTMILK_PACKAGE_NAME);
+  return names;
+}
+
+/** Bundled ids that should not register because Pi settings already provide the package. */
+export function detectGlobalBundledExtensionSkips(
+  options: CollectGlobalExtensionSourcesOptions = {},
+): GlobalBundledExtensionSkip[] {
+  const installed = collectInstalledPackageNamesFromPiSettings(options);
+  const skips: GlobalBundledExtensionSkip[] = [];
+
+  for (const id of BUNDLED_EXTENSION_IDS) {
+    const packageName = detectGlobalProviderForBundledExtension(id, installed);
+    if (packageName) {
+      skips.push({ id, packageName });
+    }
+  }
+
+  return skips;
+}

package/src/bootstrap/resolve-bundled.ts

@@ -0,0 +1,55 @@
+import { existsSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+/** Split `pkg/subpath` — supports scoped packages (`@scope/name/...`). */
+export function parseBundledModulePath(relativePath: string): { pkgName: string; subpath: string } {
+  if (relativePath.startsWith("@")) {
+    const parts = relativePath.split("/");
+    return { pkgName: `${parts[0]}/${parts[1]}`, subpath: parts.slice(2).join("/") };
+  }
+  const slash = relativePath.indexOf("/");
+  if (slash === -1) {
+    return { pkgName: relativePath, subpath: "index.ts" };
+  }
+  return { pkgName: relativePath.slice(0, slash), subpath: relativePath.slice(slash + 1) };
+}
+
+/**
+ * Resolve a bundled dependency file whether npm nested it under hotmilk or hoisted
+ * it next to hotmilk (e.g. `~/.pi/npm/node_modules/context-mode`).
+ */
+export function resolveBundledModule(
+  relativePath: string,
+  fromModuleUrl = import.meta.url,
+): string {
+  const { pkgName, subpath } = parseBundledModulePath(relativePath);
+  let dir = dirname(fileURLToPath(fromModuleUrl));
+
+  while (true) {
+    const nested = join(dir, "node_modules", pkgName, subpath);
+    if (existsSync(nested)) {
+      return nested;
+    }
+
+    if (basename(dir) === "node_modules") {
+      const sibling = join(dir, pkgName, subpath);
+      if (existsSync(sibling)) {
+        return sibling;
+      }
+    }
+
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+
+  throw new Error(`Cannot resolve bundled module "${relativePath}" from hotmilk`);
+}
+
+/** Dynamic import URL for a bundled extension entry (works with nested and hoisted installs). */
+export function bundledImportUrl(relativePath: string): string {
+  return pathToFileURL(resolveBundledModule(relativePath)).href;
+}

package/src/bootstrap/session.ts

@@ -16,6 +16,16 @@ const HOTMILK_PARSE_ERROR_MESSAGE = (path: string, error: string): string =>
 const MCP_SEEDED_MESSAGE = (path: string): string =>
   `Created ${path} from hotmilk MCP template (add servers for pi-mcp-adapter; context-mode uses the extension bridge).`;
 
+function formatGlobalExtensionSkipsMessage(
+  skips: HotmilkRuntime["globalExtensionSkips"],
+): string | undefined {
+  if (skips.length === 0) {
+    return undefined;
+  }
+  const rows = skips.map((skip) => `${skip.id}: global ${skip.packageName}`).join("\n");
+  return `Bundled extensions skipped (Pi settings already provide the package):\n${rows}`;
+}
+
 export function registerSessionHandlers(pi: ExtensionAPI, runtime: HotmilkRuntime): void {
   const termProgram = process.env.TERM_PROGRAM ?? "none";
 
@@ -39,6 +49,11 @@ export function registerSessionHandlers(pi: ExtensionAPI, runtime: HotmilkRuntim
 
     applyContextStackOnSessionStart(runtime, uiNotify);
 
+    const globalSkipMessage = formatGlobalExtensionSkipsMessage(runtime.globalExtensionSkips);
+    if (globalSkipMessage) {
+      uiNotify(globalSkipMessage, "info");
+    }
+
     if (shouldWarnCavemanJaConflict(runtime.extensionToggles.caveman, runtime.defaults.language)) {
       uiNotify(CAVEMAN_JA_CONFLICT_MESSAGE, "warning");
     }

package/src/config/bundled-extensions.ts

@@ -0,0 +1,235 @@
+/** npm package name(s) that provide a bundled extension when installed via Pi settings. */
+export type BundledPackageSpec = {
+  /** Primary npm package for `npm:<name>` entries and bundled loader resolution. */
+  packageName: string;
+  /** Extra package names that satisfy the same bundled id (e.g. dashboard bridge shim). */
+  aliases?: readonly string[];
+};
+
+export type BundledExtensionLoadPhase = "context-stack" | "parallel";
+
+export type BundledExtensionDefinition = {
+  readonly id: string;
+  readonly package: BundledPackageSpec;
+  /** Path passed to `loadBundled()` / `bundledImportUrl()`. */
+  readonly module: string;
+  /** `/mode` section label — must appear in {@link BUNDLED_EXTENSION_GROUP_ORDER}. */
+  readonly group: string;
+  readonly loadPhase?: BundledExtensionLoadPhase;
+};
+
+/** Stable `/mode` section order (independent of manifest row order). */
+export const BUNDLED_EXTENSION_GROUP_ORDER = [
+  "Harness",
+  "Agent tools",
+  "Context & performance",
+  "Integrations",
+  "Workflow",
+  "Output",
+  "Experiments",
+] as const;
+
+export type BundledExtensionGroupLabel = (typeof BUNDLED_EXTENSION_GROUP_ORDER)[number];
+
+/**
+ * Single registry for bundled Pi extensions.
+ * Adding an extension: one row here + `hotmilk.json` default + `package.json` dep + README.
+ */
+export const BUNDLED_EXTENSION_DEFINITIONS = [
+  {
+    id: "skill-registry",
+    package: { packageName: "gentle-pi" },
+    module: "gentle-pi/extensions/skill-registry.ts",
+    group: "Harness",
+  },
+  {
+    id: "sdd-init",
+    package: { packageName: "gentle-pi" },
+    module: "gentle-pi/extensions/sdd-init.ts",
+    group: "Harness",
+  },
+  {
+    id: "gentle-ai",
+    package: { packageName: "gentle-pi" },
+    module: "gentle-pi/extensions/gentle-ai.ts",
+    group: "Harness",
+  },
+  {
+    id: "context-mode",
+    package: { packageName: "context-mode" },
+    module: "context-mode/build/adapters/pi/extension.js",
+    group: "Context & performance",
+    loadPhase: "context-stack",
+  },
+  {
+    id: "ask-user",
+    package: { packageName: "pi-ask-user" },
+    module: "pi-ask-user/index.ts",
+    group: "Agent tools",
+  },
+  {
+    id: "graphify",
+    package: { packageName: "graphify-pi" },
+    module: "graphify-pi/extensions/graphify.ts",
+    group: "Agent tools",
+  },
+  {
+    id: "subagents",
+    package: { packageName: "pi-subagents" },
+    module: "pi-subagents/src/extension/index.ts",
+    group: "Agent tools",
+  },
+  {
+    id: "goal",
+    package: { packageName: "pi-goal" },
+    module: "pi-goal/.pi/extensions/pi-goal/index.ts",
+    group: "Integrations",
+  },
+  {
+    id: "docparser",
+    package: { packageName: "pi-docparser" },
+    module: "pi-docparser/extensions/docparser/index.ts",
+    group: "Integrations",
+  },
+  {
+    id: "obsidian",
+    package: { packageName: "@haispeed/pi-obsidian" },
+    module: "@haispeed/pi-obsidian/extensions/obsidian-cli.ts",
+    group: "Integrations",
+  },
+  {
+    id: "btw",
+    package: { packageName: "pi-btw" },
+    module: "pi-btw/extensions/btw.ts",
+    group: "Integrations",
+  },
+  {
+    id: "simplify",
+    package: { packageName: "pi-simplify" },
+    module: "pi-simplify/dist/index.js",
+    group: "Context & performance",
+  },
+  {
+    id: "rtk-optimizer",
+    package: { packageName: "pi-rtk-optimizer" },
+    module: "pi-rtk-optimizer/index.ts",
+    group: "Context & performance",
+    loadPhase: "context-stack",
+  },
+  {
+    id: "mcp-adapter",
+    package: { packageName: "pi-mcp-adapter" },
+    module: "pi-mcp-adapter/index.ts",
+    group: "Integrations",
+  },
+  {
+    id: "planning-with-files",
+    package: { packageName: "@tomxprime/planning-with-files" },
+    module: "@tomxprime/planning-with-files/extensions/planning-with-files/index.ts",
+    group: "Workflow",
+  },
+  {
+    id: "caveman",
+    package: { packageName: "pi-caveman" },
+    module: "pi-caveman/extensions/caveman.ts",
+    group: "Output",
+  },
+  {
+    id: "red-green",
+    package: { packageName: "pi-red-green" },
+    module: "pi-red-green/dist/index.js",
+    group: "Workflow",
+  },
+  {
+    id: "agent-dashboard",
+    package: {
+      packageName: "@blackbelt-technology/pi-agent-dashboard",
+      aliases: ["@blackbelt-technology/pi-dashboard-extension"],
+    },
+    module: "@blackbelt-technology/pi-agent-dashboard/packages/extension/src/bridge.ts",
+    group: "Agent tools",
+  },
+  {
+    id: "web-access",
+    package: { packageName: "pi-web-access" },
+    module: "pi-web-access/index.ts",
+    group: "Agent tools",
+  },
+  {
+    id: "pi-flows",
+    package: { packageName: "@blackbelt-technology/pi-flows" },
+    module: "@blackbelt-technology/pi-flows/extensions/index.ts",
+    group: "Agent tools",
+  },
+  {
+    id: "kanagawa",
+    package: { packageName: "pi-kanagawa" },
+    module: "pi-kanagawa/index.ts",
+    group: "Output",
+  },
+  {
+    id: "tetris",
+    package: { packageName: "pi-tetris" },
+    module: "pi-tetris/extensions/pi-tetris.ts",
+    group: "Experiments",
+  },
+] as const satisfies readonly BundledExtensionDefinition[];
+
+export type BundledExtensionId = (typeof BUNDLED_EXTENSION_DEFINITIONS)[number]["id"];
+
+export const BUNDLED_EXTENSION_IDS: BundledExtensionId[] = BUNDLED_EXTENSION_DEFINITIONS.map(
+  (definition) => definition.id,
+);
+
+export const BUNDLED_EXTENSION_PACKAGES: Record<BundledExtensionId, BundledPackageSpec> =
+  Object.fromEntries(
+    BUNDLED_EXTENSION_DEFINITIONS.map((definition) => [definition.id, definition.package]),
+  ) as Record<BundledExtensionId, BundledPackageSpec>;
+
+export const CONTEXT_STACK_EXTENSION_IDS = BUNDLED_EXTENSION_DEFINITIONS.filter(
+  (definition) => "loadPhase" in definition && definition.loadPhase === "context-stack",
+).map((definition) => definition.id);
+
+export type BundledExtensionGroup = {
+  label: BundledExtensionGroupLabel;
+  ids: BundledExtensionId[];
+};
+
+export function buildBundledExtensionGroups(): BundledExtensionGroup[] {
+  const idsByGroup = new Map<BundledExtensionGroupLabel, BundledExtensionId[]>();
+  for (const label of BUNDLED_EXTENSION_GROUP_ORDER) {
+    idsByGroup.set(label, []);
+  }
+
+  for (const definition of BUNDLED_EXTENSION_DEFINITIONS) {
+    const group = definition.group as BundledExtensionGroupLabel;
+    if (!idsByGroup.has(group)) {
+      throw new Error(
+        `Bundled extension ${definition.id} uses unknown group "${definition.group}" — add it to BUNDLED_EXTENSION_GROUP_ORDER`,
+      );
+    }
+    idsByGroup.get(group)!.push(definition.id);
+  }
+
+  return BUNDLED_EXTENSION_GROUP_ORDER.map((label) => ({
+    label,
+    ids: idsByGroup.get(label)!,
+  }));
+}
+
+export const BUNDLED_EXTENSION_GROUPS = buildBundledExtensionGroups();
+
+const groupedIds = new Set(BUNDLED_EXTENSION_GROUPS.flatMap((group) => group.ids));
+for (const id of BUNDLED_EXTENSION_IDS) {
+  if (!groupedIds.has(id)) {
+    throw new Error(`BUNDLED_EXTENSION_GROUPS is missing extension id: ${id}`);
+  }
+}
+
+const seenIds = new Set<string>();
+for (const definition of BUNDLED_EXTENSION_DEFINITIONS) {
+  if (seenIds.has(definition.id)) {
+    throw new Error(`Duplicate bundled extension id: ${definition.id}`);
+  }
+  seenIds.add(definition.id);
+}

package/src/config/bundled-package-registry.ts

@@ -0,0 +1,28 @@
+import {
+  BUNDLED_EXTENSION_PACKAGES,
+  type BundledExtensionId,
+  type BundledPackageSpec,
+} from "./bundled-extensions.ts";
+
+export type { BundledPackageSpec };
+
+export { BUNDLED_EXTENSION_PACKAGES };
+
+export const HOTMILK_PACKAGE_NAME = "hotmilk";
+
+export function packageNamesForBundledExtension(id: BundledExtensionId): readonly string[] {
+  const spec = BUNDLED_EXTENSION_PACKAGES[id];
+  return spec.aliases ? [spec.packageName, ...spec.aliases] : [spec.packageName];
+}
+
+export function detectGlobalProviderForBundledExtension(
+  id: BundledExtensionId,
+  installedPackageNames: ReadonlySet<string>,
+): string | undefined {
+  for (const name of packageNamesForBundledExtension(id)) {
+    if (installedPackageNames.has(name)) {
+      return name;
+    }
+  }
+  return undefined;
+}

package/src/config/hotmilk.ts

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveBundledExtensionToggles } from "./resolve.ts";
+import { BUNDLED_EXTENSION_IDS, type BundledExtensionId } from "./bundled-extensions.ts";
 
 const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "../..");
 const BUNDLED_TEMPLATE_PATH = join(PACKAGE_ROOT, "hotmilk.json");
@@ -52,31 +53,7 @@ function buildDefaultConfigFromTemplate(template: HotmilkConfig): {
 export const CONFIG_FILENAME = "hotmilk.json";
 export const AGENT_HOTMILK_CONFIG_LABEL = "~/.pi/agent/hotmilk.json";
 
-export const BUNDLED_EXTENSION_IDS = [
-  "skill-registry",
-  "sdd-init",
-  "gentle-ai",
-  "context-mode",
-  "ask-user",
-  "graphify",
-  "subagents",
-  "goal",
-  "docparser",
-  "obsidian",
-  "cursor-provider",
-  "btw",
-  "simplify",
-  "rtk-optimizer",
-  "mcp-adapter",
-  "planning-with-files",
-  "caveman",
-  "red-green",
-  "agent-dashboard",
-  "web-access",
-  "pi-flows",
-] as const;
-
-export type BundledExtensionId = (typeof BUNDLED_EXTENSION_IDS)[number];
+export { BUNDLED_EXTENSION_IDS, type BundledExtensionId } from "./bundled-extensions.ts";
 
 export type PersonaMode = "gentleman" | "neutral";
 

package/src/config/runtime.ts

@@ -1,3 +1,4 @@
+import type { GlobalBundledExtensionSkip } from "../bootstrap/global-extension-sources.ts";
 import {
   loadHotmilkConfig,
   type BundledExtensionId,
@@ -18,6 +19,8 @@ export type HotmilkRuntime = {
   configPath: string;
   configError?: string;
   extensionToggles: Record<BundledExtensionId, boolean>;
+  /** Bundled ids skipped because the same npm package is in Pi settings. */
+  globalExtensionSkips: GlobalBundledExtensionSkip[];
   defaults: ResolvedDefaults;
   graph: ResolvedGraphSettings;
   mcp: ResolvedMcpSettings;
@@ -30,6 +33,7 @@ export function createHotmilkRuntime(configRoot?: string): HotmilkRuntime {
     configPath: loaded.path,
     configError: loaded.error,
     extensionToggles: resolveBundledExtensionToggles(loaded.config),
+    globalExtensionSkips: [],
     defaults: resolveDefaults(loaded.config),
     graph: resolveGraphSettings(loaded.config),
     mcp: resolveMcpSettings(loaded.config),

package/src/controller/input.ts

@@ -1,5 +1,4 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { ExtensionContext } from "./context.ts";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { openModeSettingsModal } from "./mode.ts";
 
 const INTERRUPT_PREFIX = "/interrupt ";

package/src/controller/mode.ts

@@ -1,6 +1,6 @@
-import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import { getSettingsListTheme, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Container, SettingsList, Text, type SettingItem } from "@earendil-works/pi-tui";
-import { BUNDLED_EXTENSION_GROUPS } from "../config/extension-groups.ts";
+import { BUNDLED_EXTENSION_GROUPS } from "../config/bundled-extensions.ts";
 import {
   AGENT_HOTMILK_CONFIG_LABEL,
   type BundledExtensionId,
@@ -8,7 +8,6 @@ import {
   loadHotmilkConfig,
   saveHotmilkConfig,
 } from "../config/hotmilk.ts";
-import type { ExtensionContext } from "./context.ts";
 
 function formatToggleState(enabled: boolean): "on" | "off" {
   return enabled ? "on" : "off";

package/src/index.ts

@@ -15,18 +15,18 @@ import { registerHotmilkSessionLogo } from "./ui/session-logo.ts";
 export default async function registerHotmilk(pi: ExtensionAPI): Promise<void> {
   const runtime = createHotmilkRuntime();
 
-  if (runtime.extensionToggles["agent-dashboard"]) {
-    const { scheduleDashboardWarmStart } = await import("./bootstrap/dashboard.ts");
-    scheduleDashboardWarmStart();
-  }
+  // Register before bundled imports so session_start handlers exist when bindExtensions emits.
+  registerHotmilkSessionLogo(pi);
 
   prepareContextStack(runtime.extensionToggles);
 
-  await registerBundledExtensions(pi, runtime.extensionToggles);
+  const bundled = await registerBundledExtensions(pi, runtime.extensionToggles, {
+    cwd: process.cwd(),
+  });
+  runtime.globalExtensionSkips = bundled.globalSkips;
   registerGraphHandlers(pi, runtime.graph);
   registerDefaultsHandlers(pi, runtime.defaults);
   registerSessionHandlers(pi, runtime);
   registerInputCommands(pi);
-  registerHotmilkSessionLogo(pi);
   pi.on("input", (event, ctx) => routeInputCommand(event.text, pi, ctx));
 }