@fink-andreas/pi-linear-tools 0.1.0

package/src/logger.js

@@ -0,0 +1,128 @@
+/**
+ * Structured logging module
+ */
+
+const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+let currentLevel = process.env.LOG_LEVEL || 'info';
+let quietMode = false;
+
+/**
+ * Enable quiet mode (suppress info/debug/warn, keep only errors)
+ */
+export function setQuietMode(quiet) {
+  quietMode = quiet;
+}
+
+/**
+ * Check if a log level should be displayed
+ */
+function shouldLog(level) {
+  if (quietMode && level !== 'error') return false;
+  const currentIndex = LOG_LEVELS.indexOf(currentLevel);
+  const levelIndex = LOG_LEVELS.indexOf(level);
+  return levelIndex >= currentIndex;
+}
+
+/**
+ * Format timestamp
+ */
+function getTimestamp() {
+  return new Date().toISOString();
+}
+
+/**
+ * Mask sensitive values in logs
+ */
+function maskValue(key, value) {
+  const sensitiveKeys = ['apiKey', 'token', 'password', 'secret', 'LINEAR_API_KEY'];
+  if (sensitiveKeys.some(sk => key.toLowerCase().includes(sk.toLowerCase()))) {
+    return '***masked***';
+  }
+  return value;
+}
+
+/**
+ * Format log entry
+ */
+function formatLog(level, message, data = {}) {
+  const timestamp = getTimestamp();
+  const entry = {
+    timestamp,
+    level: level.toUpperCase(),
+    message,
+    ...data
+  };
+  return JSON.stringify(entry);
+}
+
+/**
+ * Log at debug level
+ */
+export function debug(message, data = {}) {
+  if (shouldLog('debug')) {
+    console.log(formatLog('debug', message, data));
+  }
+}
+
+/**
+ * Log at info level
+ */
+export function info(message, data = {}) {
+  if (shouldLog('info')) {
+    console.log(formatLog('info', message, data));
+  }
+}
+
+/**
+ * Log at warn level
+ */
+export function warn(message, data = {}) {
+  if (shouldLog('warn')) {
+    console.log(formatLog('warn', message, data));
+  }
+}
+
+/**
+ * Log at error level
+ */
+export function error(message, data = {}) {
+  if (shouldLog('error')) {
+    console.error(formatLog('error', message, data));
+  }
+}
+
+/**
+ * Print startup banner
+ */
+export function printBanner() {
+  const banner = `
+╔════════════════════════════════════════════════════════════╗
+║               pi-linear-tools                             ║
+║     Pi extension tools for Linear SDK workflows           ║
+╚════════════════════════════════════════════════════════════╝
+`;
+  console.log(banner);
+}
+
+/**
+ * Log configuration summary (with secrets masked)
+ */
+export function logConfig(config) {
+  info('Configuration loaded', {
+    ...Object.fromEntries(
+      Object.entries(config).map(([key, value]) => [key, maskValue(key, value)])
+    )
+  });
+}
+
+/**
+ * Set log level
+ */
+export function setLogLevel(level) {
+  if (LOG_LEVELS.includes(level)) {
+    currentLevel = level;
+    info(`Log level set to: ${level}`);
+  } else {
+    warn(`Invalid log level: ${level}. Using: ${currentLevel}`);
+  }
+}

package/src/settings.js

@@ -0,0 +1,173 @@
+/**
+ * Settings loader for pi-linear-tools
+ * Reads configuration from ~/.pi/agent/extensions/pi-linear-tools/settings.json
+ */
+
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { debug, warn, error as logError } from './logger.js';
+
+export function getDefaultSettings() {
+  return {
+    schemaVersion: 1,
+    linearApiKey: null,
+    defaultTeam: null,
+    defaultWorkspace: null,
+    projects: {},
+  };
+}
+
+function migrateSettings(settings) {
+  const migrated = { ...(settings || {}) };
+
+  if (migrated.schemaVersion === undefined) {
+    migrated.schemaVersion = 1;
+  }
+
+  if (migrated.linearApiKey === undefined) {
+    migrated.linearApiKey = null;
+  }
+
+  if (migrated.defaultTeam === undefined) {
+    migrated.defaultTeam = null;
+  }
+
+  if (migrated.defaultWorkspace === undefined) {
+    migrated.defaultWorkspace = null;
+  }
+
+  if (!migrated.projects || typeof migrated.projects !== 'object' || Array.isArray(migrated.projects)) {
+    migrated.projects = {};
+  }
+
+  for (const [projectId, cfg] of Object.entries(migrated.projects)) {
+    if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) {
+      migrated.projects[projectId] = { scope: { team: null } };
+      continue;
+    }
+
+    if (!cfg.scope || typeof cfg.scope !== 'object' || Array.isArray(cfg.scope)) {
+      cfg.scope = { team: null };
+      continue;
+    }
+
+    if (cfg.scope.team === undefined) {
+      cfg.scope.team = null;
+    }
+  }
+
+  return migrated;
+}
+
+export function validateSettings(settings) {
+  const errors = [];
+
+  if (!settings || typeof settings !== 'object') {
+    return { valid: false, errors: ['Settings must be an object'] };
+  }
+
+  if (typeof settings.schemaVersion !== 'number' || settings.schemaVersion < 1) {
+    errors.push('settings.schemaVersion must be a positive number');
+  }
+
+  if (settings.linearApiKey !== null && settings.linearApiKey !== undefined && typeof settings.linearApiKey !== 'string') {
+    errors.push('settings.linearApiKey must be a string or null');
+  }
+
+  if (settings.defaultTeam !== null && settings.defaultTeam !== undefined && typeof settings.defaultTeam !== 'string') {
+    errors.push('settings.defaultTeam must be a string or null');
+  }
+
+  if (settings.defaultWorkspace !== null && settings.defaultWorkspace !== undefined) {
+    if (typeof settings.defaultWorkspace !== 'object' || Array.isArray(settings.defaultWorkspace)) {
+      errors.push('settings.defaultWorkspace must be an object or null');
+    } else {
+      if (typeof settings.defaultWorkspace.id !== 'string' || !settings.defaultWorkspace.id.trim()) {
+        errors.push('settings.defaultWorkspace.id must be a non-empty string');
+      }
+      if (typeof settings.defaultWorkspace.name !== 'string' || !settings.defaultWorkspace.name.trim()) {
+        errors.push('settings.defaultWorkspace.name must be a non-empty string');
+      }
+    }
+  }
+
+  if (settings.projects !== undefined) {
+    if (typeof settings.projects !== 'object' || settings.projects === null || Array.isArray(settings.projects)) {
+      errors.push('settings.projects must be an object map keyed by Linear project id');
+    } else {
+      for (const [projectId, cfg] of Object.entries(settings.projects)) {
+        if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) {
+          errors.push(`settings.projects.${projectId} must be an object`);
+          continue;
+        }
+
+        if (!cfg.scope || typeof cfg.scope !== 'object' || Array.isArray(cfg.scope)) {
+          errors.push(`settings.projects.${projectId}.scope must be an object`);
+          continue;
+        }
+
+        if (cfg.scope.team !== undefined && cfg.scope.team !== null && typeof cfg.scope.team !== 'string') {
+          errors.push(`settings.projects.${projectId}.scope.team must be a string or null`);
+        }
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+export function getSettingsPath() {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '.';
+  return join(homeDir, '.pi', 'agent', 'extensions', 'pi-linear-tools', 'settings.json');
+}
+
+export async function loadSettings() {
+  const settingsPath = getSettingsPath();
+  debug('Settings path', { path: settingsPath });
+
+  if (!existsSync(settingsPath)) {
+    debug('Settings file not found, using defaults', { path: settingsPath });
+    return getDefaultSettings();
+  }
+
+  try {
+    const content = await readFile(settingsPath, 'utf-8');
+    const parsed = JSON.parse(content);
+    const settings = migrateSettings(parsed);
+    const validation = validateSettings(settings);
+
+    if (!validation.valid) {
+      warn('Settings validation failed, using defaults', {
+        path: settingsPath,
+        errors: validation.errors,
+      });
+      return getDefaultSettings();
+    }
+
+    return settings;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      logError('Settings file contains invalid JSON', { path: settingsPath, error: err.message });
+    } else {
+      logError('Failed to load settings file', { path: settingsPath, error: err.message });
+    }
+
+    return getDefaultSettings();
+  }
+}
+
+export async function saveSettings(settings) {
+  const settingsPath = getSettingsPath();
+  const parentDir = dirname(settingsPath);
+
+  const migrated = migrateSettings(settings);
+  const validation = validateSettings(migrated);
+  if (!validation.valid) {
+    throw new Error(`Cannot save invalid settings: ${validation.errors.join('; ')}`);
+  }
+
+  await mkdir(parentDir, { recursive: true });
+  await writeFile(settingsPath, `${JSON.stringify(migrated, null, 2)}\n`, 'utf-8');
+  return settingsPath;
+}