@aliou/pi-neuralwatt 0.7.4 → 0.8.0

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 {

package/src/config.ts

@@ -1,210 +0,0 @@
-import {
-  ConfigLoader,
-  registerSettingsCommand,
-  type SettingsSection,
-} from "@aliou/pi-utils-settings";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { SettingItem } from "@earendil-works/pi-tui";
-
-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 interface NeuralwattExtensionsRegisterPayload {
-  feature: NeuralwattFeatureId;
-}
-
-export interface NeuralwattConfig {
-  /** 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 ResolvedNeuralwattConfig {
-  quotaCommand: boolean;
-  quotaWarnings: boolean;
-  subBarIntegration: boolean;
-  includeLegacyModelIds: boolean;
-  includeHiddenModels: boolean;
-}
-
-const DEFAULTS: ResolvedNeuralwattConfig = {
-  quotaCommand: true,
-  quotaWarnings: true,
-  subBarIntegration: true,
-  includeLegacyModelIds: false,
-  includeHiddenModels: false,
-};
-
-export const configLoader = new ConfigLoader<
-  NeuralwattConfig,
-  ResolvedNeuralwattConfig
->("neuralwatt", DEFAULTS, {
-  migrations: [
-    {
-      name: "disable-legacy-model-ids-by-default",
-      shouldRun: (config) => config.includeLegacyModelIds === undefined,
-      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) => ({ ...config, includeLegacyModelIds: false }),
-    },
-  ],
-});
-
-export const NEURALWATT_CONFIG_UPDATED_EVENT =
-  "neuralwatt:config:updated" as const;
-
-export interface NeuralwattConfigUpdatedPayload {
-  config: ResolvedNeuralwattConfig;
-}
-
-export function emitConfigUpdated(pi: ExtensionAPI): void {
-  pi.events.emit(NEURALWATT_CONFIG_UPDATED_EVENT, {
-    config: configLoader.getConfig(),
-  });
-}
-
-export interface RegisterNeuralwattSettingsOptions {
-  getLoadedFeatures: () => Set<NeuralwattFeatureId>;
-}
-
-function featureRow(
-  id: NeuralwattFeatureId,
-  label: string,
-  description: string,
-  configValue: boolean,
-  isLoaded: boolean,
-): SettingItem {
-  if (isLoaded) {
-    return {
-      id,
-      label,
-      description,
-      currentValue: configValue ? "enabled" : "disabled",
-      values: ["enabled", "disabled"],
-    };
-  }
-  return {
-    id,
-    label,
-    description: `${description} (Not loaded by Pi)`,
-    currentValue: "unavailable",
-    values: [],
-  };
-}
-
-export function registerNeuralwattSettings(
-  pi: ExtensionAPI,
-  options: RegisterNeuralwattSettingsOptions,
-): void {
-  const { getLoadedFeatures } = options;
-
-  registerSettingsCommand<NeuralwattConfig, ResolvedNeuralwattConfig>(pi, {
-    commandName: "neuralwatt:settings",
-    title: "Neuralwatt Settings",
-    configStore: configLoader,
-    buildSections: (tabConfig, resolved): SettingsSection[] => {
-      const loaded = getLoadedFeatures();
-      return [
-        {
-          label: "Features",
-          items: [
-            featureRow(
-              "quotaCommand",
-              "Quota command",
-              "Toggle the /neuralwatt:quota command, showing your API usage at a glance",
-              tabConfig?.quotaCommand ?? resolved.quotaCommand,
-              loaded.has("quotaCommand"),
-            ),
-            featureRow(
-              "quotaWarnings",
-              "Quota warnings",
-              "Toggle notifications when credits or energy are running low",
-              tabConfig?.quotaWarnings ?? resolved.quotaWarnings,
-              loaded.has("quotaWarnings"),
-            ),
-            featureRow(
-              "subBarIntegration",
-              "Sub-bar integration",
-              "Toggle integration with the status bar and sub-core",
-              tabConfig?.subBarIntegration ?? resolved.subBarIntegration,
-              loaded.has("subBarIntegration"),
-            ),
-          ],
-        },
-        {
-          label: "Other settings",
-          items: [
-            {
-              id: "includeLegacyModelIds",
-              label: "Legacy model IDs",
-              description:
-                "Include deprecated Neuralwatt model IDs as aliases in the model picker",
-              currentValue:
-                (tabConfig?.includeLegacyModelIds ??
-                resolved.includeLegacyModelIds)
-                  ? "include"
-                  : "ignore",
-              values: ["include", "ignore"],
-            },
-            {
-              id: "includeHiddenModels",
-              label: "Hidden models",
-              description:
-                "Include Neuralwatt models that are accessible via API key but not advertised in the public model list",
-              currentValue:
-                (tabConfig?.includeHiddenModels ?? resolved.includeHiddenModels)
-                  ? "include"
-                  : "ignore",
-              values: ["include", "ignore"],
-            },
-          ],
-        },
-      ];
-    },
-    onSettingChange: (id, newValue, config) => {
-      // Non-feature toggles are handled first so they are not blocked by the
-      // loaded-features guard (they are managed directly by the provider).
-      if (id === "includeLegacyModelIds") {
-        return { ...config, includeLegacyModelIds: newValue === "include" };
-      }
-
-      if (id === "includeHiddenModels") {
-        return { ...config, includeHiddenModels: newValue === "include" };
-      }
-
-      if (!getLoadedFeatures().has(id as NeuralwattFeatureId)) {
-        return null;
-      }
-
-      const enabled = newValue === "enabled";
-      switch (id) {
-        case "quotaCommand":
-          return { ...config, quotaCommand: enabled };
-        case "quotaWarnings":
-          return { ...config, quotaWarnings: enabled };
-        case "subBarIntegration":
-          return { ...config, subBarIntegration: enabled };
-        default:
-          return null;
-      }
-    },
-    onSave: async () => {
-      emitConfigUpdated(pi);
-    },
-  });
-}