@nimblebrain/mpak 0.0.1-beta.1

package/src/utils/config-manager.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ConfigManager } from './config-manager.js';
+import { existsSync, rmSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+describe('ConfigManager', () => {
+  const testConfigDir = join(homedir(), '.mpak');
+  const testConfigFile = join(testConfigDir, 'config.json');
+
+  beforeEach(() => {
+    // Clean up test config before each test
+    if (existsSync(testConfigFile)) {
+      rmSync(testConfigFile, { force: true });
+    }
+  });
+
+  afterEach(() => {
+    // Clean up test config after each test
+    if (existsSync(testConfigFile)) {
+      rmSync(testConfigFile, { force: true });
+    }
+  });
+
+  describe('loadConfig', () => {
+    it('should create a new config if none exists', () => {
+      const manager = new ConfigManager();
+      const config = manager.loadConfig();
+
+      expect(config).toBeDefined();
+      expect(config.version).toBe('1.0.0');
+      expect(config.lastUpdated).toBeTruthy();
+    });
+
+    it('should set registryUrl in config', () => {
+      const manager = new ConfigManager();
+      manager.setRegistryUrl('http://test.example.com');
+
+      // Get the config to verify it's set
+      expect(manager.getRegistryUrl()).toBe('http://test.example.com');
+    });
+  });
+
+  describe('getRegistryUrl', () => {
+    it('should return default registry URL', () => {
+      const manager = new ConfigManager();
+      const url = manager.getRegistryUrl();
+
+      expect(url).toBe('https://api.mpak.dev');
+    });
+
+    it('should return configured registry URL', () => {
+      const manager = new ConfigManager();
+      manager.setRegistryUrl('http://custom.example.com');
+
+      expect(manager.getRegistryUrl()).toBe('http://custom.example.com');
+    });
+  });
+
+});

package/src/utils/config-manager.ts

@@ -0,0 +1,81 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+/**
+ * Configuration structure
+ */
+export interface MpakConfig {
+  version: string;
+  lastUpdated: string;
+  registryUrl?: string;
+}
+
+/**
+ * Configuration manager for CLI settings in ~/.mpak/config.json
+ */
+export class ConfigManager {
+  private configDir: string;
+  private configFile: string;
+  private config: MpakConfig | null = null;
+
+  constructor() {
+    this.configDir = join(homedir(), '.mpak');
+    this.configFile = join(this.configDir, 'config.json');
+    this.ensureConfigDir();
+  }
+
+  private ensureConfigDir(): void {
+    if (!existsSync(this.configDir)) {
+      mkdirSync(this.configDir, { recursive: true, mode: 0o700 });
+    }
+  }
+
+  loadConfig(): MpakConfig {
+    if (this.config) {
+      return this.config;
+    }
+
+    if (!existsSync(this.configFile)) {
+      this.config = {
+        version: '1.0.0',
+        lastUpdated: new Date().toISOString(),
+      };
+      this.saveConfig();
+      return this.config;
+    }
+
+    try {
+      const configJson = readFileSync(this.configFile, 'utf8');
+      this.config = JSON.parse(configJson) as MpakConfig;
+      return this.config;
+    } catch {
+      this.config = {
+        version: '1.0.0',
+        lastUpdated: new Date().toISOString(),
+      };
+      this.saveConfig();
+      return this.config;
+    }
+  }
+
+  private saveConfig(): void {
+    if (!this.config) {
+      return;
+    }
+    this.config.lastUpdated = new Date().toISOString();
+    const configJson = JSON.stringify(this.config, null, 2);
+    writeFileSync(this.configFile, configJson, { mode: 0o600 });
+  }
+
+  setRegistryUrl(url: string): void {
+    const config = this.loadConfig();
+    config.registryUrl = url;
+    this.saveConfig();
+  }
+
+  getRegistryUrl(): string {
+    const config = this.loadConfig();
+    return config.registryUrl || process.env.MPAK_REGISTRY_URL || 'https://api.mpak.dev';
+  }
+}

package/src/utils/errors.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest';
+import { CLIError } from './errors.js';
+
+describe('CLIError', () => {
+  it('should create error with message', () => {
+    const error = new CLIError('Test error');
+    expect(error.message).toBe('Test error');
+    expect(error.name).toBe('CLIError');
+  });
+
+  it('should have default exit code of 1', () => {
+    const error = new CLIError('Test error');
+    expect(error.exitCode).toBe(1);
+  });
+
+  it('should allow custom exit code', () => {
+    const error = new CLIError('Test error', 2);
+    expect(error.exitCode).toBe(2);
+  });
+
+  it('should be instance of Error', () => {
+    const error = new CLIError('Test error');
+    expect(error).toBeInstanceOf(Error);
+  });
+});

package/src/utils/errors.ts

@@ -0,0 +1,33 @@
+/**
+ * Custom error class for CLI errors
+ */
+export class CLIError extends Error {
+  public readonly exitCode: number;
+
+  constructor(
+    message: string,
+    exitCode: number = 1
+  ) {
+    super(message);
+    this.name = 'CLIError';
+    this.exitCode = exitCode;
+  }
+}
+
+/**
+ * Handles errors gracefully and exits with appropriate code
+ */
+export function handleError(error: unknown): never {
+  if (error instanceof CLIError) {
+    console.error(`Error: ${error.message}`);
+    process.exit(error.exitCode);
+  }
+
+  if (error instanceof Error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+
+  console.error('An unexpected error occurred');
+  process.exit(1);
+}

package/src/utils/version.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import { getVersion } from './version.js';
+
+describe('getVersion', () => {
+  it('should return a valid version string', () => {
+    const version = getVersion();
+    expect(version).toBeTruthy();
+    expect(typeof version).toBe('string');
+  });
+
+  it('should match semver format or be "unknown"', () => {
+    const version = getVersion();
+    const semverRegex = /^\d+\.\d+\.\d+/;
+    expect(version === 'unknown' || semverRegex.test(version)).toBe(true);
+  });
+});

package/src/utils/version.ts

@@ -0,0 +1,18 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+/**
+ * Gets the current version from package.json
+ */
+export function getVersion(): string {
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const packageJsonPath = join(__dirname, '../../package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    return packageJson.version;
+  } catch (_error) {
+    return 'unknown';
+  }
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "lib": ["ES2022"],
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "allowJs": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: ['dist', 'node_modules', '**/*.test.ts', '**/*.config.ts'],
+    },
+  },
+});