@aliou/pi-neuralwatt 0.7.6 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-neuralwatt",
-  "version": "0.7.6",
+  "version": "0.8.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -15,10 +15,10 @@
   },
   "pi": {
     "extensions": [
-      "./src/extensions/provider/index.ts",
-      "./src/extensions/command-quotas/index.ts",
-      "./src/extensions/quota-warnings/index.ts",
-      "./src/extensions/sub-bar-integration/index.ts"
+      "./extensions/provider/index.ts",
+      "./extensions/command-quotas/index.ts",
+      "./extensions/quota-warnings/index.ts",
+      "./extensions/sub-bar-integration/index.ts"
     ],
     "video": "https://assets.aliou.me/github/aliou/pi-neuralwatt/demo.mp4"
   },
@@ -27,25 +27,28 @@
   },
   "files": [
     "src",
+    "extensions",
     "schema.json",
     "README.md",
-    "!src/**/*.test.ts"
+    "!src/**/*.test.ts",
+    "!extensions/**/*.test.ts"
   ],
   "dependencies": {
-    "@aliou/pi-utils-settings": "^0.17.0",
-    "@aliou/pi-utils-ui": "^0.4.0",
-    "@earendil-works/pi-ai": "$@earendil-works/pi-coding-agent"
+    "@aliou/pi-utils-settings": "^0.18.0",
+    "@aliou/pi-utils-ui": "^0.5.0"
   },
   "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@aliou/biome-plugins": "^0.8.1",
+    "@aliou/biome-plugins": "^0.11.0",
     "@biomejs/biome": "^2.4.15",
     "@changesets/cli": "^2.27.11",
-    "@earendil-works/pi-coding-agent": "0.77.0",
-    "@earendil-works/pi-tui": "0.77.0",
+    "@earendil-works/pi-ai": "0.80.3",
+    "@earendil-works/pi-coding-agent": "0.80.3",
+    "@earendil-works/pi-tui": "0.80.3",
     "@types/node": "^25.0.10",
     "husky": "^9.1.7",
     "ts-json-schema-generator": "^2.4.0",
@@ -64,8 +67,8 @@
     "format": "biome check --write",
     "test": "vitest run",
     "test:watch": "vitest",
-    "gen:schema": "ts-json-schema-generator --path src/config.ts --type NeuralwattConfig --no-type-check -o schema.json",
-    "check:schema": "ts-json-schema-generator --path src/config.ts --type NeuralwattConfig --no-type-check -o /tmp/schema-check.json && diff -q schema.json /tmp/schema-check.json",
+    "gen:schema": "ts-json-schema-generator --path src/config/types.ts --type NeuralwattConfig --no-type-check -o schema.json",
+    "check:schema": "ts-json-schema-generator --path src/config/types.ts --type NeuralwattConfig --no-type-check -o /tmp/schema-check.json && diff -q schema.json /tmp/schema-check.json",
     "check:lockfile": "pnpm install --frozen-lockfile --ignore-scripts",
     "prepare": "[ -d .git ] && husky || true",
     "changeset": "changeset",
@@ -74,6 +77,9 @@
   },
   "packageManager": "pnpm@10.26.1",
   "peerDependenciesMeta": {
+    "@earendil-works/pi-ai": {
+      "optional": true
+    },
     "@earendil-works/pi-coding-agent": {
       "optional": true
     },

package/schema.json

@@ -3,6 +3,32 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "definitions": {
     "NeuralwattConfig": {
+      "additionalProperties": false,
+      "properties": {
+        "$schema": {
+          "description": "$schema URL for editor autocomplete.",
+          "type": "string"
+        },
+        "provider": {
+          "$ref": "#/definitions/NeuralwattProviderConfig",
+          "description": "Provider/model behavior."
+        },
+        "quotaCommand": {
+          "$ref": "#/definitions/NeuralwattQuotaCommandConfig",
+          "description": "Quota command feature."
+        },
+        "quotaWarnings": {
+          "$ref": "#/definitions/NeuralwattQuotaWarningsConfig",
+          "description": "Quota warning feature."
+        },
+        "subBarIntegration": {
+          "$ref": "#/definitions/NeuralwattSubBarIntegrationConfig",
+          "description": "Sub-bar/status-bar integration feature."
+        }
+      },
+      "type": "object"
+    },
+    "NeuralwattProviderConfig": {
       "additionalProperties": false,
       "properties": {
         "includeHiddenModels": {
@@ -12,16 +38,34 @@
         "includeLegacyModelIds": {
           "description": "Include legacy Neuralwatt model IDs in the model picker.",
           "type": "boolean"
-        },
-        "quotaCommand": {
+        }
+      },
+      "type": "object"
+    },
+    "NeuralwattQuotaCommandConfig": {
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
           "description": "Show the quota command (/neuralwatt:quota).",
           "type": "boolean"
-        },
-        "quotaWarnings": {
+        }
+      },
+      "type": "object"
+    },
+    "NeuralwattQuotaWarningsConfig": {
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
           "description": "Show quota warnings when credits or energy are low.",
           "type": "boolean"
-        },
-        "subBarIntegration": {
+        }
+      },
+      "type": "object"
+    },
+    "NeuralwattSubBarIntegrationConfig": {
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
           "description": "Show usage in the sub-bar / status bar.",
           "type": "boolean"
         }

package/src/config/defaults.ts

@@ -0,0 +1,17 @@
+import type { ResolvedNeuralwattConfig } from "./types";
+
+export const DEFAULT_CONFIG: ResolvedNeuralwattConfig = {
+  provider: {
+    includeLegacyModelIds: false,
+    includeHiddenModels: false,
+  },
+  quotaCommand: {
+    enabled: true,
+  },
+  quotaWarnings: {
+    enabled: true,
+  },
+  subBarIntegration: {
+    enabled: true,
+  },
+};

package/src/config/index.ts

@@ -0,0 +1,9 @@
+export { DEFAULT_CONFIG } from "./defaults";
+export { configLoader } from "./loader";
+export { migrations } from "./migration";
+export type {
+  NeuralwattConfig,
+  NeuralwattRawConfig,
+  PreviousNeuralwattConfig,
+  ResolvedNeuralwattConfig,
+} from "./types";

package/src/config/loader.ts

@@ -0,0 +1,74 @@
+import { buildSchemaUrl, ConfigLoader } from "@aliou/pi-utils-settings";
+import packageJson from "../../package.json";
+import { DEFAULT_CONFIG } from "./defaults";
+import { migrations } from "./migration";
+import type { NeuralwattRawConfig, ResolvedNeuralwattConfig } from "./types";
+
+type ConfigRecord = Record<string, unknown>;
+
+type MaybeEnabled = { enabled?: boolean };
+type MaybeProvider = {
+  includeLegacyModelIds?: boolean;
+  includeHiddenModels?: boolean;
+};
+
+function featureEnabled(value: unknown, fallback: boolean): boolean {
+  if (typeof value === "boolean") return value;
+  if (value && typeof value === "object") {
+    const { enabled } = value as MaybeEnabled;
+    if (typeof enabled === "boolean") return enabled;
+  }
+  return fallback;
+}
+
+function normalizeResolvedConfig(
+  resolved: ResolvedNeuralwattConfig,
+): ResolvedNeuralwattConfig {
+  const record = resolved as unknown as ConfigRecord;
+  const provider =
+    record.provider && typeof record.provider === "object"
+      ? (record.provider as MaybeProvider)
+      : {};
+
+  return {
+    provider: {
+      includeLegacyModelIds:
+        provider.includeLegacyModelIds ??
+        (typeof record.includeLegacyModelIds === "boolean"
+          ? record.includeLegacyModelIds
+          : DEFAULT_CONFIG.provider.includeLegacyModelIds),
+      includeHiddenModels:
+        provider.includeHiddenModels ??
+        (typeof record.includeHiddenModels === "boolean"
+          ? record.includeHiddenModels
+          : DEFAULT_CONFIG.provider.includeHiddenModels),
+    },
+    quotaCommand: {
+      enabled: featureEnabled(
+        record.quotaCommand,
+        DEFAULT_CONFIG.quotaCommand.enabled,
+      ),
+    },
+    quotaWarnings: {
+      enabled: featureEnabled(
+        record.quotaWarnings,
+        DEFAULT_CONFIG.quotaWarnings.enabled,
+      ),
+    },
+    subBarIntegration: {
+      enabled: featureEnabled(
+        record.subBarIntegration,
+        DEFAULT_CONFIG.subBarIntegration.enabled,
+      ),
+    },
+  };
+}
+
+export const configLoader = new ConfigLoader<
+  NeuralwattRawConfig,
+  ResolvedNeuralwattConfig
+>("neuralwatt", DEFAULT_CONFIG, {
+  migrations,
+  schemaUrl: buildSchemaUrl("@aliou/pi-neuralwatt", packageJson.version),
+  afterMerge: normalizeResolvedConfig,
+});

package/src/config/migration/01-disable-legacy-model-ids-by-default.ts

@@ -0,0 +1,44 @@
+import type { Migration } from "@aliou/pi-utils-settings";
+import type { NeuralwattConfig, PreviousNeuralwattConfig } from "../types";
+
+type MigrationConfig = PreviousNeuralwattConfig | NeuralwattConfig;
+
+type MutableConfigRecord = Record<string, unknown>;
+
+function hasOwn(record: MutableConfigRecord, key: string): boolean {
+  return Object.hasOwn(record, key);
+}
+
+function hasNestedConfig(config: MigrationConfig): boolean {
+  return Boolean(
+    ("provider" in config && config.provider) ||
+      (config.quotaCommand && typeof config.quotaCommand === "object") ||
+      (config.quotaWarnings && typeof config.quotaWarnings === "object") ||
+      (config.subBarIntegration &&
+        typeof config.subBarIntegration === "object"),
+  );
+}
+
+function isPreviousConfigWithoutLegacyDefault(
+  config: MigrationConfig,
+): config is PreviousNeuralwattConfig {
+  return (
+    !hasNestedConfig(config) &&
+    !hasOwn(config as MutableConfigRecord, "includeLegacyModelIds")
+  );
+}
+
+export const disableLegacyModelIdsByDefaultMigration: Migration<MigrationConfig> =
+  {
+    name: "disable-legacy-model-ids-by-default",
+    shouldRun: isPreviousConfigWithoutLegacyDefault,
+    message:
+      "[neuralwatt] legacy model IDs (ids including the provider and the quantization) are disabled by default. You can enable them with /neuralwatt:settings.",
+    run: (config) => {
+      const previous = config as PreviousNeuralwattConfig;
+      return {
+        ...previous,
+        includeLegacyModelIds: false,
+      };
+    },
+  };

package/src/config/migration/02-flat-to-nested-config.ts

@@ -0,0 +1,149 @@
+import { constants } from "node:fs";
+import { copyFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import type { Migration } from "@aliou/pi-utils-settings";
+import packageJson from "../../../package.json";
+import type { NeuralwattConfig, PreviousNeuralwattConfig } from "../types";
+
+type MigrationConfig = PreviousNeuralwattConfig | NeuralwattConfig;
+
+type FlatConfigKey = keyof Omit<PreviousNeuralwattConfig, "$schema">;
+type MutableConfigRecord = Record<string, unknown>;
+
+const FLAT_CONFIG_KEYS = [
+  "quotaCommand",
+  "quotaWarnings",
+  "subBarIntegration",
+  "includeLegacyModelIds",
+  "includeHiddenModels",
+] as const satisfies readonly FlatConfigKey[];
+
+const FLAT_CONFIG_MIGRATION_MESSAGE =
+  "Config migrated to the nested format. A backup was written next to the original config file.";
+
+function booleanValue(
+  record: MutableConfigRecord,
+  key: FlatConfigKey,
+): boolean | undefined {
+  return typeof record[key] === "boolean"
+    ? (record[key] as boolean)
+    : undefined;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function isPreviousConfig(
+  config: MigrationConfig,
+): config is PreviousNeuralwattConfig {
+  const record = config as MutableConfigRecord;
+  return FLAT_CONFIG_KEYS.some((key) => typeof record[key] === "boolean");
+}
+
+export async function backupConfig(filePath: string): Promise<void> {
+  const dir = dirname(filePath);
+  const base = basename(filePath, ".json");
+  const backupPath = join(
+    dir,
+    `${base}.v${packageJson.version}-flat-config.json`,
+  );
+
+  try {
+    await copyFile(filePath, backupPath, constants.COPYFILE_EXCL);
+  } catch (error) {
+    if (
+      error &&
+      typeof error === "object" &&
+      "code" in error &&
+      error.code === "EEXIST"
+    ) {
+      return;
+    }
+    throw error;
+  }
+}
+
+export const flatToNestedConfigMigration: Migration<MigrationConfig> = {
+  name: "flat-to-nested-config",
+  shouldRun: isPreviousConfig,
+  message: FLAT_CONFIG_MIGRATION_MESSAGE,
+  run: async (config, filePath) => {
+    await backupConfig(filePath);
+
+    const previous = config as PreviousNeuralwattConfig;
+    const nestedConfig = config as NeuralwattConfig;
+    const record = previous as MutableConfigRecord;
+    const nested: NeuralwattConfig = {
+      provider: {
+        ...(isObject(nestedConfig.provider) ? nestedConfig.provider : {}),
+      },
+      quotaCommand: isObject(nestedConfig.quotaCommand)
+        ? { ...nestedConfig.quotaCommand }
+        : {},
+      quotaWarnings: isObject(nestedConfig.quotaWarnings)
+        ? { ...nestedConfig.quotaWarnings }
+        : {},
+      subBarIntegration: isObject(nestedConfig.subBarIntegration)
+        ? { ...nestedConfig.subBarIntegration }
+        : {},
+    };
+
+    const includeLegacyModelIds = booleanValue(record, "includeLegacyModelIds");
+    if (
+      nested.provider?.includeLegacyModelIds === undefined &&
+      includeLegacyModelIds !== undefined
+    ) {
+      nested.provider = {
+        ...nested.provider,
+        includeLegacyModelIds,
+      };
+    }
+
+    const includeHiddenModels = booleanValue(record, "includeHiddenModels");
+    if (
+      nested.provider?.includeHiddenModels === undefined &&
+      includeHiddenModels !== undefined
+    ) {
+      nested.provider = {
+        ...nested.provider,
+        includeHiddenModels,
+      };
+    }
+
+    const quotaCommand = booleanValue(record, "quotaCommand");
+    if (
+      nested.quotaCommand?.enabled === undefined &&
+      quotaCommand !== undefined
+    ) {
+      nested.quotaCommand = {
+        ...nested.quotaCommand,
+        enabled: quotaCommand,
+      };
+    }
+
+    const quotaWarnings = booleanValue(record, "quotaWarnings");
+    if (
+      nested.quotaWarnings?.enabled === undefined &&
+      quotaWarnings !== undefined
+    ) {
+      nested.quotaWarnings = {
+        ...nested.quotaWarnings,
+        enabled: quotaWarnings,
+      };
+    }
+
+    const subBarIntegration = booleanValue(record, "subBarIntegration");
+    if (
+      nested.subBarIntegration?.enabled === undefined &&
+      subBarIntegration !== undefined
+    ) {
+      nested.subBarIntegration = {
+        ...nested.subBarIntegration,
+        enabled: subBarIntegration,
+      };
+    }
+
+    return nested;
+  },
+};

package/src/config/migration/index.ts

@@ -0,0 +1,16 @@
+import type { Migration } from "@aliou/pi-utils-settings";
+import type { NeuralwattRawConfig } from "../types";
+
+export { disableLegacyModelIdsByDefaultMigration } from "./01-disable-legacy-model-ids-by-default";
+export {
+  backupConfig,
+  flatToNestedConfigMigration,
+} from "./02-flat-to-nested-config";
+
+import { disableLegacyModelIdsByDefaultMigration } from "./01-disable-legacy-model-ids-by-default";
+import { flatToNestedConfigMigration } from "./02-flat-to-nested-config";
+
+export const migrations: Migration<NeuralwattRawConfig>[] = [
+  disableLegacyModelIdsByDefaultMigration,
+  flatToNestedConfigMigration,
+];

package/src/config/types.ts

@@ -0,0 +1,77 @@
+export interface PreviousNeuralwattConfig {
+  /** $schema URL for editor autocomplete. */
+  $schema?: string;
+
+  /** Show the quota command (/neuralwatt:quota). */
+  quotaCommand?: boolean;
+
+  /** Show quota warnings when credits or energy are low. */
+  quotaWarnings?: boolean;
+
+  /** Show usage in the sub-bar / status bar. */
+  subBarIntegration?: boolean;
+
+  /** Include legacy Neuralwatt model IDs in the model picker. */
+  includeLegacyModelIds?: boolean;
+
+  /** Include hidden Neuralwatt models discovered via the authenticated API. */
+  includeHiddenModels?: boolean;
+}
+
+export interface NeuralwattProviderConfig {
+  /** Include legacy Neuralwatt model IDs in the model picker. */
+  includeLegacyModelIds?: boolean;
+
+  /** Include hidden Neuralwatt models discovered via the authenticated API. */
+  includeHiddenModels?: boolean;
+}
+
+export interface NeuralwattQuotaCommandConfig {
+  /** Show the quota command (/neuralwatt:quota). */
+  enabled?: boolean;
+}
+
+export interface NeuralwattQuotaWarningsConfig {
+  /** Show quota warnings when credits or energy are low. */
+  enabled?: boolean;
+}
+
+export interface NeuralwattSubBarIntegrationConfig {
+  /** Show usage in the sub-bar / status bar. */
+  enabled?: boolean;
+}
+
+export interface NeuralwattConfig {
+  /** $schema URL for editor autocomplete. */
+  $schema?: string;
+
+  /** Provider/model behavior. */
+  provider?: NeuralwattProviderConfig;
+
+  /** Quota command feature. */
+  quotaCommand?: NeuralwattQuotaCommandConfig;
+
+  /** Quota warning feature. */
+  quotaWarnings?: NeuralwattQuotaWarningsConfig;
+
+  /** Sub-bar/status-bar integration feature. */
+  subBarIntegration?: NeuralwattSubBarIntegrationConfig;
+}
+
+export type NeuralwattRawConfig = PreviousNeuralwattConfig | NeuralwattConfig;
+
+export interface ResolvedNeuralwattConfig {
+  provider: {
+    includeLegacyModelIds: boolean;
+    includeHiddenModels: boolean;
+  };
+  quotaCommand: {
+    enabled: boolean;
+  };
+  quotaWarnings: {
+    enabled: boolean;
+  };
+  subBarIntegration: {
+    enabled: boolean;
+  };
+}

package/src/{types/quota-events.ts → events.ts}

@@ -1,6 +1,19 @@
-import type { NeuralwattQuotas } from "./quota-api";
+import type { ResolvedNeuralwattConfig } from "./config";
+import type { NeuralwattQuotas } from "./types/quota-api";
 
-export type QuotaSource = "header" | "api" | "sse";
+export type NeuralwattFeatureId =
+  | "quotaCommand"
+  | "quotaWarnings"
+  | "subBarIntegration";
+
+export const NEURALWATT_EXTENSIONS_REQUEST_EVENT =
+  "neuralwatt:extensions:request" as const;
+
+export const NEURALWATT_EXTENSIONS_REGISTER_EVENT =
+  "neuralwatt:extensions:register" as const;
+
+export const NEURALWATT_CONFIG_UPDATED_EVENT =
+  "neuralwatt:config:updated" as const;
 
 export const NEURALWATT_QUOTAS_UPDATED_EVENT =
   "neuralwatt:quotas:updated" as const;
@@ -8,22 +21,21 @@ export const NEURALWATT_QUOTAS_UPDATED_EVENT =
 export const NEURALWATT_QUOTAS_REQUEST_EVENT =
   "neuralwatt:quotas:request" as const;
 
+export interface NeuralwattExtensionsRegisterPayload {
+  feature: NeuralwattFeatureId;
+}
+
+export interface NeuralwattConfigUpdatedPayload {
+  config: ResolvedNeuralwattConfig;
+}
+
+export type QuotaSource = "header" | "api" | "sse";
+
 export interface NeuralwattQuotasUpdatedPayload {
   quotas: NeuralwattQuotas;
   source: QuotaSource;
 }
 
-export type QuotasErrorKind =
-  | "cancelled"
-  | "timeout"
-  | "config"
-  | "http"
-  | "network";
-
-export type QuotasResult =
-  | { success: true; data: { quotas: NeuralwattQuotas } }
-  | { success: false; error: { message: string; kind: QuotasErrorKind } };
-
 /** Minimal quota data parsed from response headers */
 export interface NeuralwattHeaderQuotas {
   allowanceRemainingUsd: number;

package/src/lib/neuralwatt-api.ts

@@ -3,7 +3,7 @@ import type {
   NeuralwattApiModelsResponse,
 } from "../types/models-api";
 import type { NeuralwattQuotas } from "../types/quota-api";
-import type { QuotasResult } from "../types/quota-events";
+import type { QuotasResult } from "../types/quota-result";
 
 const BASE_URL = "https://api.neuralwatt.com/v1";
 const FETCH_TIMEOUT_MS = 15_000;

package/src/types/quota-result.ts

@@ -0,0 +1,12 @@
+import type { NeuralwattQuotas } from "./quota-api";
+
+export type QuotasErrorKind =
+  | "cancelled"
+  | "timeout"
+  | "config"
+  | "http"
+  | "network";
+
+export type QuotasResult =
+  | { success: true; data: { quotas: NeuralwattQuotas } }
+  | { success: false; error: { message: string; kind: QuotasErrorKind } };

package/src/utils/quota-bar.ts

@@ -1,5 +1,3 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
-
 export type Severity = "success" | "warning" | "error";
 
 export function severityFromPercent(pct: number): Severity {
@@ -8,42 +6,6 @@ export function severityFromPercent(pct: number): Severity {
   return "error";
 }
 
-export type BarStyle = "filled-used" | "filled-remaining";
-
-/**
- * Render a progress bar.
- *
- * filled-used: filled region = used portion (colored by severity of remaining%)
- * filled-remaining: filled region = remaining portion (colored by severity of remaining%)
- */
-export function renderProgressBar(
-  percent: number,
-  width: number,
-  theme: Theme,
-  severity: Severity,
-  style: BarStyle = "filled-remaining",
-): string {
-  const clamped = Math.max(0, Math.min(100, Math.round(percent)));
-  const filledCount = Math.round((clamped / 100) * width);
-
-  const parts: string[] = [];
-  for (let idx = 0; idx < width; idx++) {
-    const isFilled = idx < filledCount;
-    if (style === "filled-used") {
-      // filled = used (severity color), empty = remaining (dim)
-      parts.push(
-        isFilled ? theme.fg(severity, "\u2593") : theme.fg("success", "\u2591"),
-      );
-    } else {
-      // filled = remaining (severity color), empty = used (dim)
-      parts.push(
-        isFilled ? theme.fg(severity, "\u2588") : theme.fg("dim", "\u2591"),
-      );
-    }
-  }
-  return parts.join("");
-}
-
 export function percentCreditsRemaining(quotas: {
   balance: { credits_remaining_usd: number; total_credits_usd: number };
 }): number {