peaks-cli 1.0.0

package/dist/src/services/config/config-service.js

@@ -0,0 +1,501 @@
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { DEFAULT_CONFIG } from './config-types.js';
+function getUserConfigPath() {
+    return resolve(homedir(), '.peaks', 'config.json');
+}
+function isInsidePath(childPath, parentPath) {
+    const relativePath = relative(parentPath, childPath);
+    return relativePath === '' || (!relativePath.startsWith('..') && !isAbsolute(relativePath));
+}
+function isSafeProjectConfigMarker(projectRoot) {
+    const peaksPath = resolve(projectRoot, '.peaks');
+    const markerPath = resolve(peaksPath, 'config.json');
+    try {
+        const projectRootReal = realpathSync(projectRoot);
+        const peaksReal = realpathSync(peaksPath);
+        const markerReal = realpathSync(markerPath);
+        if (!isInsidePath(peaksReal, projectRootReal))
+            return false;
+        if (!isInsidePath(markerReal, projectRootReal))
+            return false;
+        return isInsidePath(markerReal, peaksReal);
+    }
+    catch {
+        return false;
+    }
+}
+function findProjectRoot(startPath) {
+    let current = resolve(startPath);
+    let parent = dirname(current);
+    while (current !== parent) {
+        if (existsSync(resolve(current, '.peaks', 'config.json')) && isSafeProjectConfigMarker(current)) {
+            return current;
+        }
+        parent = current;
+        current = dirname(parent);
+    }
+    return null;
+}
+function getProjectConfigPath(projectRoot) {
+    if (!projectRoot)
+        return null;
+    if (!isSafeProjectConfigMarker(projectRoot))
+        return null;
+    return resolve(projectRoot, '.peaks', 'config.json');
+}
+function readJsonFile(path) {
+    if (!path || !existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function ensureDir(dirPath) {
+    if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+    }
+}
+const UNSAFE_NESTED_PATH_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype']);
+function getNestedPathParts(path) {
+    return path.replace(/\[(\d+)\]/g, '.$1').split('.').filter(Boolean);
+}
+function hasUnsafeNestedPathSegment(parts) {
+    return parts.some((part) => UNSAFE_NESTED_PATH_SEGMENTS.has(part));
+}
+function getNestedValue(obj, path) {
+    const parts = getNestedPathParts(path);
+    if (parts.length === 0 || hasUnsafeNestedPathSegment(parts)) {
+        return undefined;
+    }
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined || typeof current !== 'object' || !Object.prototype.hasOwnProperty.call(current, part)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function setNestedValue(obj, path, value) {
+    const parts = getNestedPathParts(path);
+    if (parts.length === 0 || hasUnsafeNestedPathSegment(parts)) {
+        throw new Error('Unsafe config path');
+    }
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (!Object.prototype.hasOwnProperty.call(current, part) || typeof current[part] !== 'object' || current[part] === null || Array.isArray(current[part])) {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    const last = parts[parts.length - 1];
+    current[last] = value;
+}
+function removeProjectProviderSecrets(config) {
+    const { providers, ...safeConfig } = config;
+    return safeConfig;
+}
+export function isConfigLayer(value) {
+    return value === 'user' || value === 'project';
+}
+export function isSensitiveConfigPath(path) {
+    const normalized = path.toLowerCase().replace(/[^a-z0-9]/g, '');
+    return normalized.includes('apikey') || normalized.includes('accesskey') || normalized.includes('privatekey') || normalized.includes('token') || normalized.includes('secret') || normalized.includes('password') || normalized.includes('bearer') || normalized.includes('credential') || normalized.includes('auth');
+}
+function isProviderConfigPath(path) {
+    return path === 'providers' || path.startsWith('providers.');
+}
+function isSecretKey(key) {
+    return isSensitiveConfigPath(key);
+}
+function sanitizeBaseUrlForDisplay(value) {
+    try {
+        const url = new URL(value);
+        url.username = '';
+        url.password = '';
+        url.search = '';
+        url.hash = '';
+        return url.toString();
+    }
+    catch {
+        return '[invalid-url-redacted]';
+    }
+}
+const MINIMAX_API_HOST = 'api.minimaxi.com';
+function isProviderBaseUrlPath(path) {
+    return /^providers\.[^.]+\.baseUrl$/.test(path);
+}
+function isValidProviderBaseUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'https:' && url.username.length === 0 && url.password.length === 0 && url.search.length === 0 && url.hash.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function isValidMiniMaxBaseUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'https:' && url.hostname === MINIMAX_API_HOST && url.username.length === 0 && url.password.length === 0 && url.search.length === 0 && url.hash.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function getMiniMaxBaseUrlCandidate(key, value) {
+    if (key === 'providers.minimax.baseUrl') {
+        return value;
+    }
+    if (key === 'providers.minimax' && value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        return value.baseUrl;
+    }
+    if (key === 'providers' && value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        return value.minimax?.baseUrl;
+    }
+    return undefined;
+}
+function validateProviderBaseUrl(value) {
+    if (value !== undefined && (typeof value !== 'string' || !isValidProviderBaseUrl(value))) {
+        throw new Error('Provider base URL must be HTTPS without embedded credentials, query, or fragment');
+    }
+}
+function validateMiniMaxBaseUrl(value) {
+    if (value !== undefined && (typeof value !== 'string' || !isValidMiniMaxBaseUrl(value))) {
+        throw new Error('MiniMax base URL must be the MiniMax HTTPS endpoint without embedded credentials');
+    }
+}
+function getProxyUrlCandidate(key, value) {
+    if (key === 'proxy.httpProxy') {
+        return value;
+    }
+    if (key === 'proxy' && isRecord(value)) {
+        return value.httpProxy;
+    }
+    return undefined;
+}
+function isProxyConfigPath(path) {
+    return path === 'proxy' || path.startsWith('proxy.');
+}
+function validateModelProviderConfig(providers) {
+    validateMiniMaxBaseUrl(providers.minimax?.baseUrl);
+    for (const [providerId, provider] of Object.entries(providers)) {
+        if (providerId !== 'minimax') {
+            validateProviderBaseUrl(provider?.baseUrl);
+        }
+    }
+}
+function validateProviderConfig(partial) {
+    validateModelProviderConfig(partial.providers ?? {});
+}
+function isValidProxyUrl(value) {
+    try {
+        const url = new URL(value);
+        return (url.protocol === 'http:' || url.protocol === 'https:') && url.username.length === 0 && url.password.length === 0 && url.pathname === '/' && url.search.length === 0 && url.hash.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function validateProxyUrl(value) {
+    if (value !== undefined && (typeof value !== 'string' || !isValidProxyUrl(value))) {
+        throw new Error('Proxy URL must be an HTTP or HTTPS URL without embedded credentials');
+    }
+}
+function validateProxyConfig(partial) {
+    validateProxyUrl(partial.proxy?.httpProxy);
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function toWorkspaceConfig(value) {
+    if (!isRecord(value))
+        return null;
+    const { workspaceId, name, rootPath, installedCapabilityIds } = value;
+    if (typeof workspaceId !== 'string' || typeof name !== 'string' || typeof rootPath !== 'string' || !Array.isArray(installedCapabilityIds) || !installedCapabilityIds.every((id) => typeof id === 'string')) {
+        return null;
+    }
+    let artifactRepo;
+    if (isRecord(value.artifactRepo) && (value.artifactRepo.provider === 'github' || value.artifactRepo.provider === 'gitlab') && typeof value.artifactRepo.owner === 'string' && typeof value.artifactRepo.name === 'string') {
+        artifactRepo = { provider: value.artifactRepo.provider, owner: value.artifactRepo.owner, name: value.artifactRepo.name };
+    }
+    return artifactRepo ? { workspaceId, name, rootPath, installedCapabilityIds, artifactRepo } : { workspaceId, name, rootPath, installedCapabilityIds };
+}
+function toWorkspaceConfigs(value) {
+    return Array.isArray(value) ? value.map(toWorkspaceConfig).filter((workspace) => workspace !== null) : [];
+}
+function toProviderModelConfig(value) {
+    if (!isRecord(value))
+        return {};
+    return {
+        ...(typeof value.model === 'string' && value.model.trim().length > 0 ? { model: value.model.trim() } : {}),
+        ...(typeof value.baseUrl === 'string' ? { baseUrl: value.baseUrl } : {}),
+        ...(typeof value.apiKey === 'string' ? { apiKey: value.apiKey } : {})
+    };
+}
+function toMiniMaxProviderConfig(value) {
+    return toProviderModelConfig(value);
+}
+const TOKEN_CONFIG_KEYS = new Set(['AnthropicApiKey', 'OpenAiApiKey', 'GitHubToken', 'GitLabToken']);
+function toTokenRef(value) {
+    if (!isRecord(value))
+        return null;
+    const env = typeof value.env === 'string' ? value.env.trim() : '';
+    const keychain = typeof value.keychain === 'string' ? value.keychain.trim() : '';
+    if (env.length > 0) {
+        return { env };
+    }
+    if (keychain.length > 0) {
+        return { keychain };
+    }
+    if (value.ghCli === true) {
+        return { ghCli: true };
+    }
+    return null;
+}
+function toTokenConfig(value) {
+    if (!isRecord(value))
+        return {};
+    const tokens = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (!TOKEN_CONFIG_KEYS.has(key))
+            continue;
+        const tokenRef = toTokenRef(entry);
+        if (tokenRef) {
+            tokens[key] = tokenRef;
+        }
+    }
+    return tokens;
+}
+function toModelProviderConfig(value) {
+    if (!isRecord(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).map(([providerId, providerConfig]) => [providerId, toProviderModelConfig(providerConfig)]));
+}
+function toProxyConfig(value) {
+    if (!isRecord(value))
+        return null;
+    return typeof value.httpProxy === 'string' && isValidProxyUrl(value.httpProxy) ? { httpProxy: value.httpProxy } : null;
+}
+function getProjectWritePath() {
+    const projectPath = getProjectConfigPath(findProjectRoot(process.cwd()));
+    if (!projectPath) {
+        throw new Error('Project config not found');
+    }
+    return projectPath;
+}
+export function containsSensitiveConfigValue(value) {
+    if (Array.isArray(value)) {
+        return value.some(containsSensitiveConfigValue);
+    }
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    return Object.entries(value).some(([key, entry]) => isSecretKey(key) || containsSensitiveConfigValue(entry));
+}
+export function redactConfigSecrets(value, path = '') {
+    if (Array.isArray(value)) {
+        return value.map((item, index) => redactConfigSecrets(item, `${path}[${index}]`));
+    }
+    if (value === null || typeof value !== 'object') {
+        if (isProviderBaseUrlPath(path) && typeof value === 'string') {
+            return sanitizeBaseUrlForDisplay(value);
+        }
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
+        const nextPath = path ? `${path}.${key}` : key;
+        if (isSecretKey(key)) {
+            return [key, '***'];
+        }
+        if (isProviderBaseUrlPath(nextPath) && typeof entry === 'string') {
+            return [key, sanitizeBaseUrlForDisplay(entry)];
+        }
+        return [key, redactConfigSecrets(entry, nextPath)];
+    }));
+}
+function createMiniMaxProviderStatus(config) {
+    const baseUrl = config.baseUrl?.trim();
+    const apiKey = config.apiKey?.trim();
+    const baseUrlConfigured = typeof baseUrl === 'string' && baseUrl.length > 0 && isValidMiniMaxBaseUrl(baseUrl);
+    const apiKeyConfigured = typeof apiKey === 'string' && apiKey.length > 0;
+    return {
+        provider: 'minimax',
+        configured: baseUrlConfigured && apiKeyConfigured,
+        baseUrlConfigured,
+        apiKeyConfigured,
+        storage: 'user-plaintext-v1',
+        nextActions: baseUrlConfigured && apiKeyConfigured ? [] : ['Export MINIMAX_API_KEY and rerun peaks config provider minimax set --base-url <url>']
+    };
+}
+export function getMiniMaxProviderConfig() {
+    return toMiniMaxProviderConfig(readJsonFile(getUserConfigPath())?.providers?.minimax);
+}
+export function getMiniMaxProviderStatus() {
+    return createMiniMaxProviderStatus(getMiniMaxProviderConfig());
+}
+export function setMiniMaxProviderConfig(input) {
+    validateMiniMaxBaseUrl(input.baseUrl);
+    const userConfig = readJsonFile(getUserConfigPath()) ?? {};
+    const existingProviders = toModelProviderConfig(userConfig.providers);
+    const providers = {
+        ...existingProviders,
+        minimax: {
+            ...existingProviders.minimax,
+            ...input
+        }
+    };
+    validateMiniMaxBaseUrl(providers.minimax?.baseUrl);
+    writeConfig({ providers }, 'user');
+    return createMiniMaxProviderStatus(providers.minimax ?? {});
+}
+function toPeaksConfig(value) {
+    if (!isRecord(value))
+        return {};
+    const proxy = toProxyConfig(value.proxy);
+    return {
+        ...(typeof value.version === 'string' ? { version: value.version } : {}),
+        ...(typeof value.currentWorkspace === 'string' ? { currentWorkspace: value.currentWorkspace } : {}),
+        ...(Array.isArray(value.workspaces) ? { workspaces: toWorkspaceConfigs(value.workspaces) } : {}),
+        ...(typeof value.language === 'string' ? { language: value.language } : {}),
+        ...(typeof value.model === 'string' && ['haiku', 'sonnet', 'opus', 'minimax'].includes(value.model) ? { model: value.model } : {}),
+        ...(typeof value.economyMode === 'boolean' ? { economyMode: value.economyMode } : {}),
+        ...(typeof value.swarmMode === 'boolean' ? { swarmMode: value.swarmMode } : {}),
+        ...(isRecord(value.tokens) ? { tokens: toTokenConfig(value.tokens) } : {}),
+        ...(isRecord(value.providers) ? { providers: toModelProviderConfig(value.providers) } : {}),
+        ...(proxy ? { proxy } : {})
+    };
+}
+export function readConfig(projectRoot) {
+    const detectedRoot = projectRoot ?? findProjectRoot(process.cwd());
+    const userPath = getUserConfigPath();
+    const projectPath = getProjectConfigPath(detectedRoot);
+    const userConfig = toPeaksConfig(readJsonFile(userPath));
+    const projectConfig = removeProjectProviderSecrets(toPeaksConfig(readJsonFile(projectPath)));
+    const { proxy: projectProxy, ...projectConfigWithoutProxy } = projectConfig;
+    return {
+        ...DEFAULT_CONFIG,
+        ...userConfig,
+        ...projectConfigWithoutProxy
+    };
+}
+export function writeConfig(partial, layer = 'user') {
+    if (!isConfigLayer(layer)) {
+        throw new Error('Invalid config layer');
+    }
+    if (layer === 'project' && (partial.providers !== undefined || partial.proxy !== undefined || containsSensitiveConfigValue(partial))) {
+        throw new Error('Sensitive config keys must be stored in the user config layer');
+    }
+    validateProviderConfig(partial);
+    validateProxyConfig(partial);
+    if (layer === 'project') {
+        const projectPath = getProjectWritePath();
+        ensureDir(dirname(projectPath));
+        const existing = readJsonFile(projectPath) ?? {};
+        const merged = { ...existing, ...partial };
+        writeFileSync(projectPath, JSON.stringify(merged, null, 2), 'utf-8');
+        return;
+    }
+    const userPath = getUserConfigPath();
+    ensureDir(dirname(userPath));
+    const userPathDir = dirname(userPath);
+    ensureDir(userPathDir);
+    const existing = readJsonFile(userPath) ?? {};
+    const merged = { ...existing, ...partial };
+    writeFileSync(userPath, JSON.stringify(merged, null, 2), 'utf-8');
+}
+export function getConfig(options = {}) {
+    const projectRoot = findProjectRoot(process.cwd());
+    const userConfig = readJsonFile(getUserConfigPath()) ?? {};
+    const projectConfig = removeProjectProviderSecrets(readJsonFile(getProjectConfigPath(projectRoot)) ?? {});
+    const { proxy: projectProxy, ...projectConfigWithoutProxy } = projectConfig;
+    const source = options.layer === 'user' ? userConfig : options.layer === 'project' ? projectConfig : { ...userConfig, ...projectConfigWithoutProxy };
+    const config = isRecord(source) ? { ...source, ...(source.tokens !== undefined ? { tokens: toTokenConfig(source.tokens) } : {}) } : source;
+    if (options.key !== undefined) {
+        return getNestedValue(config, options.key);
+    }
+    return config;
+}
+export function setConfig(options) {
+    const layer = options.layer ?? 'user';
+    if (!isConfigLayer(layer)) {
+        throw new Error('Invalid config layer');
+    }
+    if (layer === 'project' && (isProviderConfigPath(options.key) || isProxyConfigPath(options.key) || isSensitiveConfigPath(options.key) || containsSensitiveConfigValue(options.value))) {
+        throw new Error('Sensitive config keys must be stored in the user config layer');
+    }
+    validateMiniMaxBaseUrl(getMiniMaxBaseUrlCandidate(options.key, options.value));
+    if (options.key === 'providers') {
+        validateModelProviderConfig(toModelProviderConfig(options.value));
+    }
+    else if (options.key.startsWith('providers.') && !options.key.startsWith('providers.minimax.')) {
+        const providerId = getNestedPathParts(options.key)[1];
+        if (options.key === `providers.${providerId}`) {
+            validateModelProviderConfig({ [providerId]: toProviderModelConfig(options.value) });
+        }
+        else if (isProviderBaseUrlPath(options.key)) {
+            validateProviderBaseUrl(options.value);
+        }
+    }
+    validateProxyUrl(getProxyUrlCandidate(options.key, options.value));
+    const targetPath = layer === 'project' ? getProjectWritePath() : getUserConfigPath();
+    ensureDir(dirname(targetPath));
+    const existing = readJsonFile(targetPath) ?? {};
+    const updated = { ...existing };
+    setNestedValue(updated, options.key, options.value);
+    writeFileSync(targetPath, JSON.stringify(updated, null, 2), 'utf-8');
+}
+export function getWorkspaceConfig(workspaceId, projectRoot) {
+    const config = readConfig(projectRoot ?? findProjectRoot(process.cwd()));
+    return config.workspaces.find((w) => w.workspaceId === workspaceId) ?? null;
+}
+function readLayerConfig(layer) {
+    const config = getConfig({ layer });
+    return isRecord(config)
+        ? {
+            currentWorkspace: typeof config.currentWorkspace === 'string' ? config.currentWorkspace : null,
+            workspaces: toWorkspaceConfigs(config.workspaces)
+        }
+        : { currentWorkspace: null, workspaces: [] };
+}
+export function addWorkspace(workspace, layer = 'user') {
+    const config = readLayerConfig(layer);
+    const workspaces = config.workspaces;
+    const existing = workspaces.findIndex((w) => w.workspaceId === workspace.workspaceId);
+    const updatedWorkspaces = existing >= 0
+        ? workspaces.map((existingWorkspace) => existingWorkspace.workspaceId === workspace.workspaceId ? workspace : existingWorkspace)
+        : [...workspaces, workspace];
+    writeConfig({ workspaces: updatedWorkspaces }, layer);
+}
+export function removeWorkspace(workspaceId, layer = 'user') {
+    const config = readLayerConfig(layer);
+    const workspaces = config.workspaces;
+    const idx = workspaces.findIndex((w) => w.workspaceId === workspaceId);
+    if (idx < 0)
+        return false;
+    const updatedWorkspaces = workspaces.filter((w) => w.workspaceId !== workspaceId);
+    const currentWorkspace = config.currentWorkspace === workspaceId ? updatedWorkspaces[0]?.workspaceId ?? null : config.currentWorkspace ?? null;
+    writeConfig({ workspaces: updatedWorkspaces, currentWorkspace }, layer);
+    return true;
+}
+export function setCurrentWorkspace(workspaceId, layer = 'user') {
+    const config = readLayerConfig(layer);
+    const workspaces = config.workspaces;
+    const exists = workspaces.some((w) => w.workspaceId === workspaceId);
+    if (!exists)
+        return false;
+    writeConfig({ currentWorkspace: workspaceId }, layer);
+    return true;
+}
+export function getCurrentWorkspaceConfig() {
+    const config = readConfig();
+    if (!config.currentWorkspace)
+        return null;
+    return getWorkspaceConfig(config.currentWorkspace);
+}

package/dist/src/services/config/config-types.d.ts

@@ -0,0 +1,63 @@
+export type TokenRef = {
+    env: string;
+} | {
+    keychain: string;
+} | {
+    ghCli: true;
+};
+export type TokenConfig = {
+    AnthropicApiKey?: TokenRef;
+    OpenAiApiKey?: TokenRef;
+    GitHubToken?: TokenRef;
+    GitLabToken?: TokenRef;
+};
+export type ModelPreference = 'haiku' | 'sonnet' | 'opus' | 'minimax';
+export type ModelProviderId = 'minimax' | string;
+export type ExecutionModelId = string;
+export type ProviderModelConfig = {
+    model?: ExecutionModelId;
+    baseUrl?: string;
+    apiKey?: string;
+};
+export type MiniMaxProviderConfig = ProviderModelConfig;
+export type ModelProviderConfig = {
+    minimax?: MiniMaxProviderConfig;
+    [providerId: string]: ProviderModelConfig | undefined;
+};
+export type ProxyConfig = {
+    httpProxy?: string;
+};
+export type WorkspaceConfig = {
+    workspaceId: string;
+    name: string;
+    rootPath: string;
+    artifactRepo?: {
+        provider: 'github' | 'gitlab';
+        owner: string;
+        name: string;
+    };
+    installedCapabilityIds: string[];
+};
+export type PeaksConfig = {
+    version: string;
+    currentWorkspace: string | null;
+    workspaces: WorkspaceConfig[];
+    language: string;
+    model: ModelPreference;
+    economyMode: boolean;
+    swarmMode: boolean;
+    tokens: TokenConfig;
+    providers: ModelProviderConfig;
+    proxy: ProxyConfig;
+};
+export type ConfigLayer = 'user' | 'project';
+export type ConfigGetOptions = {
+    key?: string;
+    layer?: ConfigLayer;
+};
+export type ConfigSetOptions = {
+    key: string;
+    value: unknown;
+    layer?: ConfigLayer;
+};
+export declare const DEFAULT_CONFIG: PeaksConfig;

package/dist/src/services/config/config-types.js

@@ -0,0 +1,16 @@
+export const DEFAULT_CONFIG = {
+    version: '0.1.0',
+    currentWorkspace: null,
+    workspaces: [],
+    language: 'en',
+    model: 'sonnet',
+    economyMode: true,
+    swarmMode: true,
+    tokens: {},
+    providers: {
+        minimax: {
+            model: 'minimax-2.7'
+        }
+    },
+    proxy: {}
+};

package/dist/src/services/config/model-routing.d.ts

@@ -0,0 +1,4 @@
+import { type ModelProviderConfig, type PeaksConfig } from './config-types.js';
+export declare const STRONGEST_MODEL_ID: "claude-opus-4-7";
+export declare function getConfiguredExecutionModelId(providers: ModelProviderConfig | undefined): string;
+export declare function getEconomyAwareExecutionModelId(config: Pick<PeaksConfig, 'economyMode' | 'providers'>): string;

package/dist/src/services/config/model-routing.js

@@ -0,0 +1,15 @@
+import { DEFAULT_CONFIG } from './config-types.js';
+export const STRONGEST_MODEL_ID = 'claude-opus-4-7';
+export function getConfiguredExecutionModelId(providers) {
+    const providerConfigs = Object.values(providers ?? DEFAULT_CONFIG.providers);
+    const configuredModel = providerConfigs
+        .map((provider) => provider?.model?.trim())
+        .find((model) => typeof model === 'string' && model.length > 0);
+    if (!configuredModel) {
+        throw new Error('Execution model must be configured in providers');
+    }
+    return configuredModel;
+}
+export function getEconomyAwareExecutionModelId(config) {
+    return config.economyMode ? getConfiguredExecutionModelId(config.providers) : STRONGEST_MODEL_ID;
+}

package/dist/src/services/doctor/doctor-service.d.ts

@@ -0,0 +1,18 @@
+export type DoctorCheck = {
+    id: string;
+    ok: boolean;
+    message: string;
+};
+export type DoctorReport = {
+    checks: DoctorCheck[];
+    summary: {
+        ok: boolean;
+        passed: number;
+        failed: number;
+    };
+};
+export type DoctorOptions = {
+    schemasBaseDir?: string;
+    skillsBaseDir?: string;
+};
+export declare function runDoctor(options?: DoctorOptions): Promise<DoctorReport>;

package/dist/src/services/doctor/doctor-service.js

@@ -0,0 +1,68 @@
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { existsSync } from 'node:fs';
+import { readText } from '../../shared/fs.js';
+import { requiredSchemaFiles, requiredSkillNames, schemasDir } from '../../shared/paths.js';
+import { getErrorMessage } from '../../shared/result.js';
+import { loadSkillRegistry } from '../skills/skill-registry.js';
+export async function runDoctor(options = {}) {
+    const checks = [];
+    const registry = await loadSkillRegistry(options.skillsBaseDir);
+    const skills = registry.skills;
+    const skillNames = new Set(skills.map((skill) => skill.name));
+    for (const requiredSkill of requiredSkillNames) {
+        checks.push({
+            id: `skill:${requiredSkill}`,
+            ok: skillNames.has(requiredSkill),
+            message: skillNames.has(requiredSkill)
+                ? `Required skill ${requiredSkill} exists`
+                : `Missing required skill ${requiredSkill}`
+        });
+    }
+    for (const skill of skills) {
+        checks.push({
+            id: `skill-name:${skill.directory}`,
+            ok: skill.name === skill.directory,
+            message: skill.name === skill.directory
+                ? `Skill ${skill.name} matches its directory`
+                : `Skill ${skill.directory} declares mismatched name ${skill.name}`
+        });
+    }
+    for (const failure of registry.failures) {
+        checks.push({
+            id: `skill-parse:${failure.directory}`,
+            ok: false,
+            message: `Skill ${failure.directory} has invalid metadata: ${failure.message}`
+        });
+    }
+    const schemaRoot = options.schemasBaseDir ?? schemasDir;
+    for (const schemaFile of requiredSchemaFiles) {
+        try {
+            JSON.parse(await readText(join(schemaRoot, schemaFile)));
+            checks.push({ id: `schema:${schemaFile}`, ok: true, message: `Schema ${schemaFile} is valid JSON` });
+        }
+        catch (error) {
+            checks.push({
+                id: `schema:${schemaFile}`,
+                ok: false,
+                message: `Schema ${schemaFile} is missing or invalid: ${getErrorMessage(error)}`
+            });
+        }
+    }
+    const userConfigPath = join(homedir(), '.peaks', 'config.json');
+    const hasUserConfig = existsSync(userConfigPath);
+    checks.push({
+        id: 'config:user',
+        ok: hasUserConfig,
+        message: hasUserConfig ? 'User config exists at ~/.peaks/config.json' : 'User config not found at ~/.peaks/config.json'
+    });
+    const failed = checks.filter((check) => !check.ok).length;
+    return {
+        checks,
+        summary: {
+            ok: failed === 0,
+            passed: checks.length - failed,
+            failed
+        }
+    };
+}