@contextos/core 0.1.0 → 0.2.0

package/dist/index.js

@@ -2049,11 +2049,11 @@ var ContextBuilder = class {
     const graphPath = join4(rootDir, CONTEXTOS_DIR2, GRAPH_FILE);
     const graphDir = join4(rootDir, CONTEXTOS_DIR2, "db");
     if (!existsSync4(graphDir)) {
-      const { mkdirSync: mkdirSync7 } = await import("fs");
-      mkdirSync7(graphDir, { recursive: true });
+      const { mkdirSync: mkdirSync9 } = await import("fs");
+      mkdirSync9(graphDir, { recursive: true });
     }
-    const { writeFileSync: writeFileSync7 } = await import("fs");
-    writeFileSync7(graphPath, JSON.stringify(this.graph.toJSON(), null, 2));
+    const { writeFileSync: writeFileSync9 } = await import("fs");
+    writeFileSync9(graphPath, JSON.stringify(this.graph.toJSON(), null, 2));
     return {
       filesIndexed,
       chunksCreated,
@@ -5534,6 +5534,1185 @@ var AuditLogger = class {
   }
 };
 
+// src/plugins/manager.ts
+import { existsSync as existsSync11, readdirSync, readFileSync as readFileSync11, mkdirSync as mkdirSync7, rmSync, writeFileSync as writeFileSync7 } from "fs";
+import { join as join10, resolve } from "path";
+var PluginManager = class {
+  plugins = /* @__PURE__ */ new Map();
+  pluginsDir;
+  projectRoot;
+  storage = /* @__PURE__ */ new Map();
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.pluginsDir = join10(projectRoot, ".contextos", "plugins");
+    if (!existsSync11(this.pluginsDir)) {
+      mkdirSync7(this.pluginsDir, { recursive: true });
+    }
+  }
+  /**
+   * Load all plugins from plugins directory
+   */
+  async loadAll() {
+    const loaded = [];
+    const errors = [];
+    if (!existsSync11(this.pluginsDir)) {
+      return { loaded, errors };
+    }
+    const entries = readdirSync(this.pluginsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const pluginPath = join10(this.pluginsDir, entry.name);
+      try {
+        await this.loadPlugin(pluginPath);
+        loaded.push(entry.name);
+      } catch (error) {
+        errors.push({
+          name: entry.name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return { loaded, errors };
+  }
+  /**
+   * Load a single plugin from path
+   */
+  async loadPlugin(pluginPath) {
+    const manifestPath = join10(pluginPath, "package.json");
+    if (!existsSync11(manifestPath)) {
+      throw new Error(`Plugin manifest not found: ${manifestPath}`);
+    }
+    const manifestContent = readFileSync11(manifestPath, "utf-8");
+    const manifest = JSON.parse(manifestContent);
+    if (!manifest.name || !manifest.version || !manifest.main) {
+      throw new Error(`Invalid plugin manifest: missing name, version, or main`);
+    }
+    const mainPath = join10(pluginPath, manifest.main);
+    if (!existsSync11(mainPath)) {
+      throw new Error(`Plugin main file not found: ${mainPath}`);
+    }
+    const pluginModule = await import(`file://${resolve(mainPath)}`);
+    const plugin = pluginModule.default || pluginModule;
+    if (!plugin.name || !plugin.version) {
+      throw new Error(`Invalid plugin: missing name or version`);
+    }
+    const state = {
+      manifest,
+      instance: plugin,
+      enabled: true,
+      path: pluginPath,
+      loadedAt: /* @__PURE__ */ new Date()
+    };
+    this.plugins.set(plugin.name, state);
+    if (plugin.activate) {
+      const context = this.createPluginContext(plugin.name);
+      await plugin.activate(context);
+    }
+    return plugin;
+  }
+  /**
+   * Unload a plugin
+   */
+  async unloadPlugin(name) {
+    const state = this.plugins.get(name);
+    if (!state) return false;
+    if (state.instance.deactivate) {
+      await state.instance.deactivate();
+    }
+    this.storage.delete(name);
+    this.plugins.delete(name);
+    return true;
+  }
+  /**
+   * Enable a disabled plugin
+   */
+  async enablePlugin(name) {
+    const state = this.plugins.get(name);
+    if (!state) return false;
+    if (state.enabled) return true;
+    state.enabled = true;
+    if (state.instance.activate) {
+      const context = this.createPluginContext(name);
+      await state.instance.activate(context);
+    }
+    return true;
+  }
+  /**
+   * Disable a plugin (keep loaded but inactive)
+   */
+  async disablePlugin(name) {
+    const state = this.plugins.get(name);
+    if (!state) return false;
+    if (!state.enabled) return true;
+    state.enabled = false;
+    if (state.instance.deactivate) {
+      await state.instance.deactivate();
+    }
+    return true;
+  }
+  /**
+   * Install a plugin
+   */
+  async install(source, options = {}) {
+    const targetDir = join10(this.pluginsDir, source.split("/").pop() || source);
+    if (existsSync11(targetDir) && !options.force) {
+      throw new Error(`Plugin already installed: ${source}`);
+    }
+    if (options.local) {
+      const sourcePath = resolve(source);
+      if (!existsSync11(sourcePath)) {
+        throw new Error(`Source path not found: ${sourcePath}`);
+      }
+      if (options.force && existsSync11(targetDir)) {
+        rmSync(targetDir, { recursive: true });
+      }
+      mkdirSync7(targetDir, { recursive: true });
+      const manifest = JSON.parse(readFileSync11(join10(sourcePath, "package.json"), "utf-8"));
+      writeFileSync7(join10(targetDir, "package.json"), JSON.stringify(manifest, null, 2));
+      const mainContent = readFileSync11(join10(sourcePath, manifest.main), "utf-8");
+      writeFileSync7(join10(targetDir, manifest.main), mainContent);
+    } else {
+      throw new Error("Remote plugin installation not yet implemented");
+    }
+    const plugin = await this.loadPlugin(targetDir);
+    if (options.skipActivate) {
+      await this.disablePlugin(plugin.name);
+    }
+    return plugin;
+  }
+  /**
+   * Uninstall a plugin
+   */
+  async uninstall(name) {
+    const state = this.plugins.get(name);
+    if (!state) return false;
+    await this.unloadPlugin(name);
+    if (existsSync11(state.path)) {
+      rmSync(state.path, { recursive: true });
+    }
+    return true;
+  }
+  /**
+   * Get all loaded plugins
+   */
+  list() {
+    return Array.from(this.plugins.values());
+  }
+  /**
+   * Get a specific plugin
+   */
+  get(name) {
+    return this.plugins.get(name);
+  }
+  /**
+   * Execute a hook across all enabled plugins
+   */
+  async executeHook(hookName, ...args) {
+    const result = {
+      modified: false,
+      value: args[0],
+      pluginsExecuted: [],
+      errors: []
+    };
+    for (const [name, state] of this.plugins) {
+      if (!state.enabled) continue;
+      const hook = state.instance.hooks?.[hookName];
+      if (!hook) continue;
+      try {
+        const hookFn = hook;
+        const hookResult = await hookFn(...args);
+        if (hookResult !== void 0) {
+          result.modified = true;
+          result.value = hookResult;
+          args[0] = hookResult;
+        }
+        result.pluginsExecuted.push(name);
+      } catch (error) {
+        result.errors.push({
+          plugin: name,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+    return result;
+  }
+  /**
+   * Create a scaffold for new plugin
+   */
+  createPluginScaffold(template) {
+    const pluginDir = join10(this.pluginsDir, template.name);
+    if (existsSync11(pluginDir)) {
+      throw new Error(`Plugin directory already exists: ${template.name}`);
+    }
+    mkdirSync7(pluginDir, { recursive: true });
+    const manifest = {
+      name: template.name,
+      version: "1.0.0",
+      description: template.description,
+      author: template.author,
+      main: "index.js",
+      engines: {
+        contextos: ">=2.0.0"
+      }
+    };
+    writeFileSync7(
+      join10(pluginDir, "package.json"),
+      JSON.stringify(manifest, null, 2)
+    );
+    const hookCode = template.hooks.map((h) => `        ${h}: async (value) => {
+            // TODO: Implement ${h}
+            return value;
+        },`).join("\n");
+    const commandsCode = template.withCommands ? `
+    commands: {
+        'my-command': {
+            description: 'Example command',
+            handler: async (args, context) => {
+                context.log.info('Command executed with args:', args);
+            },
+        },
+    },` : "";
+    const pluginCode = `/**
+ * ${template.name} - ContextOS Plugin
+ * ${template.description}
+ */
+
+module.exports = {
+    name: '${template.name}',
+    version: '1.0.0',
+    description: '${template.description}',
+
+    hooks: {
+${hookCode}
+    },
+${commandsCode}
+
+    activate: async (context) => {
+        context.log.info('${template.name} activated');
+    },
+
+    deactivate: async () => {
+        // Cleanup if needed
+    },
+};
+`;
+    writeFileSync7(join10(pluginDir, "index.js"), pluginCode);
+    return pluginDir;
+  }
+  /**
+   * Create plugin context for API access
+   */
+  createPluginContext(pluginName) {
+    if (!this.storage.has(pluginName)) {
+      this.storage.set(pluginName, /* @__PURE__ */ new Map());
+    }
+    const pluginStorage = this.storage.get(pluginName);
+    return {
+      projectRoot: this.projectRoot,
+      configDir: join10(this.projectRoot, ".contextos"),
+      log: {
+        debug: (msg, ...args) => console.debug(`[${pluginName}]`, msg, ...args),
+        info: (msg, ...args) => console.info(`[${pluginName}]`, msg, ...args),
+        warn: (msg, ...args) => console.warn(`[${pluginName}]`, msg, ...args),
+        error: (msg, ...args) => console.error(`[${pluginName}]`, msg, ...args)
+      },
+      query: async (_goal) => {
+        return { files: [], context: "" };
+      },
+      readFile: async (path) => {
+        const fullPath = join10(this.projectRoot, path);
+        return readFileSync11(fullPath, "utf-8");
+      },
+      getDependencies: async (_path, _depth = 2) => {
+        return [];
+      },
+      storage: {
+        get: (key) => pluginStorage.get(key),
+        set: (key, value) => {
+          pluginStorage.set(key, value);
+        },
+        delete: (key) => pluginStorage.delete(key)
+      }
+    };
+  }
+};
+function createPluginManager(projectRoot) {
+  return new PluginManager(projectRoot);
+}
+
+// src/plugins/registry.ts
+import { existsSync as existsSync12, readdirSync as readdirSync2, readFileSync as readFileSync12 } from "fs";
+import { join as join11 } from "path";
+var PluginRegistry = class {
+  config;
+  remoteCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * List all locally installed plugins
+   */
+  listLocal() {
+    const plugins = [];
+    if (!existsSync12(this.config.localDir)) {
+      return plugins;
+    }
+    const entries = readdirSync2(this.config.localDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const pluginPath = join11(this.config.localDir, entry.name);
+      const manifestPath = join11(pluginPath, "package.json");
+      if (!existsSync12(manifestPath)) continue;
+      try {
+        const manifest = JSON.parse(
+          readFileSync12(manifestPath, "utf-8")
+        );
+        const disabledPath = join11(pluginPath, ".disabled");
+        const enabled = !existsSync12(disabledPath);
+        plugins.push({
+          name: manifest.name,
+          version: manifest.version,
+          description: manifest.description,
+          path: pluginPath,
+          enabled
+        });
+      } catch {
+      }
+    }
+    return plugins;
+  }
+  /**
+   * Search remote registry for plugins
+   */
+  async searchRemote(query) {
+    if (!this.config.remoteUrl) {
+      return [];
+    }
+    const cacheKey = `search:${query}`;
+    if (this.remoteCache.has(cacheKey)) {
+      return this.remoteCache.get(cacheKey);
+    }
+    try {
+      const searchUrl = `${this.config.remoteUrl}/-/v1/search?text=${encodeURIComponent(query)}&scope=contextos-plugin`;
+      const response = await fetch(searchUrl);
+      if (!response.ok) {
+        throw new Error(`Registry search failed: ${response.statusText}`);
+      }
+      const data = await response.json();
+      const results = data.objects.map((obj) => obj.package);
+      this.remoteCache.set(cacheKey, results);
+      setTimeout(() => this.remoteCache.delete(cacheKey), 5 * 60 * 1e3);
+      return results;
+    } catch (error) {
+      console.error("Remote registry search failed:", error);
+      return [];
+    }
+  }
+  /**
+   * Get plugin info from remote registry
+   */
+  async getRemoteInfo(name, version) {
+    if (!this.config.remoteUrl) {
+      return null;
+    }
+    try {
+      const infoUrl = version ? `${this.config.remoteUrl}/${name}/${version}` : `${this.config.remoteUrl}/${name}/latest`;
+      const response = await fetch(infoUrl);
+      if (!response.ok) {
+        return null;
+      }
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if a plugin is installed locally
+   */
+  isInstalled(name) {
+    const plugins = this.listLocal();
+    return plugins.some((p) => p.name === name);
+  }
+  /**
+   * Get local plugin by name
+   */
+  getLocal(name) {
+    const plugins = this.listLocal();
+    return plugins.find((p) => p.name === name) || null;
+  }
+  /**
+   * Get featured/popular plugins from remote
+   */
+  async getFeatured() {
+    if (!this.config.remoteUrl) {
+      return [
+        {
+          name: "@contextos/plugin-docker",
+          version: "1.0.0",
+          description: "Docker context integration - scan Dockerfiles and compose files",
+          author: "ContextOS Team",
+          downloads: 1200,
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+          tarball: "",
+          keywords: ["docker", "container", "devops"]
+        },
+        {
+          name: "@contextos/plugin-kubernetes",
+          version: "1.0.0",
+          description: "Kubernetes context integration - scan K8s manifests",
+          author: "ContextOS Team",
+          downloads: 800,
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+          tarball: "",
+          keywords: ["kubernetes", "k8s", "devops"]
+        },
+        {
+          name: "@contextos/plugin-graphql",
+          version: "1.0.0",
+          description: "GraphQL schema and resolver context",
+          author: "ContextOS Team",
+          downloads: 650,
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+          tarball: "",
+          keywords: ["graphql", "api", "schema"]
+        },
+        {
+          name: "@contextos/plugin-prisma",
+          version: "1.0.0",
+          description: "Prisma ORM schema integration",
+          author: "ContextOS Team",
+          downloads: 500,
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+          tarball: "",
+          keywords: ["prisma", "database", "orm"]
+        }
+      ];
+    }
+    return this.searchRemote("contextos-plugin featured");
+  }
+  /**
+   * Clear remote cache
+   */
+  clearCache() {
+    this.remoteCache.clear();
+  }
+};
+function createPluginRegistry(projectRoot) {
+  return new PluginRegistry({
+    localDir: join11(projectRoot, ".contextos", "plugins"),
+    remoteUrl: process.env.CONTEXTOS_REGISTRY_URL || void 0,
+    cacheDir: join11(projectRoot, ".contextos", "cache", "plugins")
+  });
+}
+
+// src/finetuning/collector.ts
+import { existsSync as existsSync13, readFileSync as readFileSync13, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
+import { join as join12 } from "path";
+import { createHash as createHash4 } from "crypto";
+var TrainingDataCollector = class {
+  dataDir;
+  examples = [];
+  loaded = false;
+  constructor(projectRoot) {
+    this.dataDir = join12(projectRoot, ".contextos", "training");
+    if (!existsSync13(this.dataDir)) {
+      mkdirSync8(this.dataDir, { recursive: true });
+    }
+  }
+  /**
+   * Load existing training data
+   */
+  load() {
+    if (this.loaded) return;
+    const dataFile = join12(this.dataDir, "examples.json");
+    if (existsSync13(dataFile)) {
+      try {
+        const data = JSON.parse(readFileSync13(dataFile, "utf-8"));
+        this.examples = data.examples || [];
+      } catch {
+        this.examples = [];
+      }
+    }
+    this.loaded = true;
+  }
+  /**
+   * Save training data
+   */
+  save() {
+    const dataFile = join12(this.dataDir, "examples.json");
+    writeFileSync8(dataFile, JSON.stringify({
+      version: "1.0",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      examples: this.examples
+    }, null, 2));
+  }
+  /**
+   * Record a context build for training
+   */
+  record(goal, selectedFiles, context, tokenCount, meta) {
+    this.load();
+    const example = {
+      id: this.generateId(goal, meta.timestamp),
+      goal,
+      selectedFiles,
+      context,
+      tokenCount,
+      meta
+    };
+    this.examples.push(example);
+    this.save();
+    return example;
+  }
+  /**
+   * Add feedback to an existing example
+   */
+  addFeedback(exampleId, rating, comment) {
+    this.load();
+    const example = this.examples.find((e) => e.id === exampleId);
+    if (!example) return false;
+    example.feedback = { rating, comment };
+    this.save();
+    return true;
+  }
+  /**
+   * Get all examples
+   */
+  getAll() {
+    this.load();
+    return [...this.examples];
+  }
+  /**
+   * Get example by ID
+   */
+  get(id) {
+    this.load();
+    return this.examples.find((e) => e.id === id);
+  }
+  /**
+   * Get recent examples
+   */
+  getRecent(limit = 10) {
+    this.load();
+    return this.examples.sort(
+      (a, b) => new Date(b.meta.timestamp).getTime() - new Date(a.meta.timestamp).getTime()
+    ).slice(0, limit);
+  }
+  /**
+   * Filter examples
+   */
+  filter(predicate) {
+    this.load();
+    return this.examples.filter(predicate);
+  }
+  /**
+   * Get dataset statistics
+   */
+  getStats() {
+    this.load();
+    const stats = {
+      totalExamples: this.examples.length,
+      ratingDistribution: {
+        good: 0,
+        neutral: 0,
+        bad: 0,
+        unrated: 0
+      },
+      languageDistribution: {},
+      avgTokenCount: 0,
+      avgFilesPerExample: 0,
+      dateRange: {
+        earliest: /* @__PURE__ */ new Date(),
+        latest: /* @__PURE__ */ new Date(0)
+      }
+    };
+    if (this.examples.length === 0) {
+      return stats;
+    }
+    let totalTokens = 0;
+    let totalFiles = 0;
+    for (const example of this.examples) {
+      if (example.feedback) {
+        stats.ratingDistribution[example.feedback.rating]++;
+      } else {
+        stats.ratingDistribution.unrated++;
+      }
+      const lang = example.meta.language;
+      stats.languageDistribution[lang] = (stats.languageDistribution[lang] || 0) + 1;
+      totalTokens += example.tokenCount;
+      totalFiles += example.selectedFiles.length;
+      const date = new Date(example.meta.timestamp);
+      if (date < stats.dateRange.earliest) {
+        stats.dateRange.earliest = date;
+      }
+      if (date > stats.dateRange.latest) {
+        stats.dateRange.latest = date;
+      }
+    }
+    stats.avgTokenCount = Math.round(totalTokens / this.examples.length);
+    stats.avgFilesPerExample = Math.round(totalFiles / this.examples.length * 10) / 10;
+    return stats;
+  }
+  /**
+   * Delete an example
+   */
+  delete(id) {
+    this.load();
+    const index = this.examples.findIndex((e) => e.id === id);
+    if (index === -1) return false;
+    this.examples.splice(index, 1);
+    this.save();
+    return true;
+  }
+  /**
+   * Clear all examples
+   */
+  clear() {
+    this.examples = [];
+    this.save();
+  }
+  /**
+   * Generate unique ID
+   */
+  generateId(goal, timestamp) {
+    const hash = createHash4("sha256").update(goal + timestamp.toISOString()).digest("hex").substring(0, 12);
+    return `ex_${hash}`;
+  }
+};
+function createTrainingDataCollector(projectRoot) {
+  return new TrainingDataCollector(projectRoot);
+}
+
+// src/finetuning/formatter.ts
+import { createReadStream, createWriteStream, existsSync as existsSync14 } from "fs";
+import { createInterface } from "readline";
+var DatasetFormatter = class {
+  /**
+   * Export examples to file
+   */
+  async export(examples, outputPath, format, config = {}) {
+    let filtered = this.filterExamples(examples, config);
+    if (config.shuffle) {
+      filtered = this.shuffle(filtered);
+    }
+    if (config.maxExamples && filtered.length > config.maxExamples) {
+      filtered = filtered.slice(0, config.maxExamples);
+    }
+    const stream = createWriteStream(outputPath);
+    for (const example of filtered) {
+      const formatted = this.formatExample(example, format);
+      stream.write(formatted + "\n");
+    }
+    stream.end();
+    return { exported: filtered.length, path: outputPath };
+  }
+  /**
+   * Export with train/validation split
+   */
+  async exportWithSplit(examples, outputDir, format, config = {}) {
+    const split = config.validationSplit || 0.1;
+    let filtered = this.filterExamples(examples, config);
+    if (config.shuffle) {
+      filtered = this.shuffle(filtered);
+    }
+    const splitIndex = Math.floor(filtered.length * (1 - split));
+    const trainExamples = filtered.slice(0, splitIndex);
+    const validationExamples = filtered.slice(splitIndex);
+    await this.export(trainExamples, `${outputDir}/train.jsonl`, format, {});
+    await this.export(validationExamples, `${outputDir}/validation.jsonl`, format, {});
+    return {
+      train: trainExamples.length,
+      validation: validationExamples.length
+    };
+  }
+  /**
+   * Validate a dataset file
+   */
+  async validate(filePath) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: [],
+      stats: {
+        totalExamples: 0,
+        ratingDistribution: { good: 0, neutral: 0, bad: 0, unrated: 0 },
+        languageDistribution: {},
+        avgTokenCount: 0,
+        avgFilesPerExample: 0,
+        dateRange: { earliest: /* @__PURE__ */ new Date(), latest: /* @__PURE__ */ new Date(0) }
+      }
+    };
+    if (!existsSync14(filePath)) {
+      result.valid = false;
+      result.errors.push({
+        line: 0,
+        field: "file",
+        message: `File not found: ${filePath}`
+      });
+      return result;
+    }
+    const fileStream = createReadStream(filePath);
+    const rl = createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    let lineNumber = 0;
+    let totalTokens = 0;
+    let totalFiles = 0;
+    for await (const line of rl) {
+      lineNumber++;
+      if (!line.trim()) continue;
+      try {
+        const example = JSON.parse(line);
+        if (!example.goal) {
+          result.errors.push({
+            line: lineNumber,
+            field: "goal",
+            message: "Missing required field: goal"
+          });
+          result.valid = false;
+        }
+        if (!example.context) {
+          result.errors.push({
+            line: lineNumber,
+            field: "context",
+            message: "Missing required field: context"
+          });
+          result.valid = false;
+        }
+        result.stats.totalExamples++;
+        totalTokens += example.tokenCount || 0;
+        totalFiles += example.selectedFiles?.length || 0;
+        if (example.feedback) {
+          result.stats.ratingDistribution[example.feedback.rating]++;
+        } else {
+          result.stats.ratingDistribution.unrated++;
+        }
+        if (example.meta?.language) {
+          const lang = example.meta.language;
+          result.stats.languageDistribution[lang] = (result.stats.languageDistribution[lang] || 0) + 1;
+        }
+        if (example.meta?.timestamp) {
+          const date = new Date(example.meta.timestamp);
+          if (date < result.stats.dateRange.earliest) {
+            result.stats.dateRange.earliest = date;
+          }
+          if (date > result.stats.dateRange.latest) {
+            result.stats.dateRange.latest = date;
+          }
+        }
+      } catch (error) {
+        result.errors.push({
+          line: lineNumber,
+          field: "json",
+          message: `Invalid JSON: ${error instanceof Error ? error.message : "Parse error"}`
+        });
+        result.valid = false;
+      }
+    }
+    if (result.stats.totalExamples > 0) {
+      result.stats.avgTokenCount = Math.round(totalTokens / result.stats.totalExamples);
+      result.stats.avgFilesPerExample = Math.round(totalFiles / result.stats.totalExamples * 10) / 10;
+    }
+    if (result.stats.totalExamples < 100) {
+      result.warnings.push("Dataset has fewer than 100 examples. Consider collecting more data.");
+    }
+    if (result.stats.ratingDistribution.bad > result.stats.totalExamples * 0.2) {
+      result.warnings.push("More than 20% of examples have negative ratings.");
+    }
+    return result;
+  }
+  /**
+   * Filter examples based on config
+   */
+  filterExamples(examples, config) {
+    return examples.filter((example) => {
+      if (config.minRating) {
+        if (!example.feedback && !config.includeUnrated) {
+          return false;
+        }
+        if (example.feedback) {
+          const ratingOrder = { bad: 0, neutral: 1, good: 2 };
+          if (ratingOrder[example.feedback.rating] < ratingOrder[config.minRating]) {
+            return false;
+          }
+        }
+      }
+      if (config.projectFilter && example.meta.projectName !== config.projectFilter) {
+        return false;
+      }
+      if (config.languageFilter && example.meta.language !== config.languageFilter) {
+        return false;
+      }
+      return true;
+    });
+  }
+  /**
+   * Format a single example
+   */
+  formatExample(example, format) {
+    switch (format.format) {
+      case "openai":
+        return JSON.stringify({
+          messages: [
+            {
+              role: "system",
+              content: "You are a code context selection assistant. Given a goal, select the most relevant files from a codebase."
+            },
+            {
+              role: "user",
+              content: `Goal: ${example.goal}
+
+Project: ${example.meta.projectName} (${example.meta.language})`
+            },
+            {
+              role: "assistant",
+              content: `Selected files:
+${example.selectedFiles.map((f) => `- ${f}`).join("\n")}
+
+${example.context}`
+            }
+          ]
+        });
+      case "anthropic":
+        return JSON.stringify({
+          prompt: `
+
+Human: Goal: ${example.goal}
+
+Project: ${example.meta.projectName} (${example.meta.language})
+
+Assistant:`,
+          completion: ` Selected files:
+${example.selectedFiles.map((f) => `- ${f}`).join("\n")}
+
+${example.context}`
+        });
+      case "csv":
+        const escapeCsv = (s) => `"${s.replace(/"/g, '""')}"`;
+        return [
+          escapeCsv(example.id),
+          escapeCsv(example.goal),
+          escapeCsv(example.selectedFiles.join(";")),
+          example.tokenCount,
+          example.feedback?.rating || "",
+          escapeCsv(example.meta.language)
+        ].join(",");
+      case "jsonl":
+      default:
+        return JSON.stringify(example);
+    }
+  }
+  /**
+   * Shuffle array
+   */
+  shuffle(array) {
+    const shuffled = [...array];
+    for (let i = shuffled.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    return shuffled;
+  }
+};
+function createDatasetFormatter() {
+  return new DatasetFormatter();
+}
+
+// src/deployment/docker.ts
+function generateDockerCompose(config) {
+  const services = {
+    contextos: {
+      image: "contextos/server:latest",
+      container_name: config.name,
+      ports: [`${config.port}:${config.port}`],
+      environment: {
+        NODE_ENV: config.environment,
+        PORT: config.port.toString(),
+        HOST: config.host,
+        LOG_LEVEL: config.logging.level,
+        LOG_FORMAT: config.logging.format,
+        ...config.environment
+      },
+      volumes: config.volumes?.map(
+        (v) => `${v.source}:${v.target}${v.readonly ? ":ro" : ""}`
+      ) || [
+        "./data:/data",
+        "./.contextos:/app/.contextos"
+      ],
+      restart: "unless-stopped",
+      healthcheck: {
+        test: ["CMD", "curl", "-f", `http://localhost:${config.port}/health`],
+        interval: "30s",
+        timeout: "10s",
+        retries: 3,
+        start_period: "10s"
+      }
+    }
+  };
+  if (config.resources) {
+    services.contextos = {
+      ...services.contextos,
+      deploy: {
+        resources: {
+          limits: {
+            memory: config.resources.memory,
+            cpus: config.resources.cpus
+          }
+        }
+      }
+    };
+  }
+  if (config.redis) {
+    services.redis = {
+      image: "redis:7-alpine",
+      container_name: `${config.name}-redis`,
+      ports: [`${config.redis.port}:6379`],
+      volumes: ["redis-data:/data"],
+      restart: "unless-stopped"
+    };
+    services.contextos.depends_on = ["redis"];
+    const env = services.contextos.environment;
+    env.REDIS_HOST = "redis";
+    env.REDIS_PORT = "6379";
+  }
+  const compose = {
+    version: "3.8",
+    services,
+    volumes: {
+      "contextos-data": {},
+      ...config.redis ? { "redis-data": {} } : {}
+    }
+  };
+  return generateYaml(compose);
+}
+function generateDockerfile() {
+  return `# ContextOS Server Dockerfile
+FROM node:20-alpine AS base
+
+# Install dependencies only when needed
+FROM base AS deps
+WORKDIR /app
+COPY package*.json pnpm-lock.yaml ./
+RUN npm install -g pnpm && pnpm install --frozen-lockfile
+
+# Build the application
+FROM base AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+RUN npm run build
+
+# Production image
+FROM base AS runner
+WORKDIR /app
+
+ENV NODE_ENV=production
+
+RUN addgroup --system --gid 1001 nodejs
+RUN adduser --system --uid 1001 contextos
+
+COPY --from=builder --chown=contextos:nodejs /app/dist ./dist
+COPY --from=builder --chown=contextos:nodejs /app/node_modules ./node_modules
+COPY --from=builder --chown=contextos:nodejs /app/package.json ./
+
+USER contextos
+
+EXPOSE 3000
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \\
+    CMD curl -f http://localhost:3000/health || exit 1
+
+CMD ["node", "dist/server.js"]
+`;
+}
+function generateHelmValues(config) {
+  const values = {
+    replicaCount: config.replicas,
+    image: {
+      repository: "contextos/server",
+      tag: "latest",
+      pullPolicy: "IfNotPresent"
+    },
+    service: {
+      type: "ClusterIP",
+      port: config.port
+    },
+    ingress: {
+      enabled: config.ingress?.enabled || false,
+      className: "nginx",
+      annotations: config.ingress?.annotations || {},
+      hosts: config.ingress ? [{
+        host: config.ingress.host,
+        paths: [{ path: "/", pathType: "Prefix" }]
+      }] : [],
+      tls: config.ingress?.tls ? [{
+        secretName: `${config.name}-tls`,
+        hosts: [config.ingress.host]
+      }] : []
+    },
+    resources: config.resources,
+    env: {
+      NODE_ENV: config.environment,
+      LOG_LEVEL: config.logging.level
+    },
+    serviceAccount: {
+      create: !!config.serviceAccount,
+      name: config.serviceAccount || ""
+    },
+    podAnnotations: config.podAnnotations || {}
+  };
+  return generateYaml(values);
+}
+function generateK8sDeployment(config) {
+  const deployment = {
+    apiVersion: "apps/v1",
+    kind: "Deployment",
+    metadata: {
+      name: config.name,
+      namespace: config.namespace,
+      labels: {
+        "app.kubernetes.io/name": config.name,
+        "app.kubernetes.io/instance": config.name
+      }
+    },
+    spec: {
+      replicas: config.replicas,
+      selector: {
+        matchLabels: {
+          "app.kubernetes.io/name": config.name,
+          "app.kubernetes.io/instance": config.name
+        }
+      },
+      template: {
+        metadata: {
+          labels: {
+            "app.kubernetes.io/name": config.name,
+            "app.kubernetes.io/instance": config.name
+          },
+          annotations: config.podAnnotations || {}
+        },
+        spec: {
+          serviceAccountName: config.serviceAccount,
+          containers: [{
+            name: config.name,
+            image: "contextos/server:latest",
+            ports: [{ containerPort: config.port }],
+            env: [
+              { name: "NODE_ENV", value: config.environment },
+              { name: "PORT", value: config.port.toString() },
+              { name: "LOG_LEVEL", value: config.logging.level }
+            ],
+            resources: config.resources,
+            livenessProbe: {
+              httpGet: { path: "/health", port: config.port },
+              initialDelaySeconds: 10,
+              periodSeconds: 30
+            },
+            readinessProbe: {
+              httpGet: { path: "/health", port: config.port },
+              initialDelaySeconds: 5,
+              periodSeconds: 10
+            }
+          }]
+        }
+      }
+    }
+  };
+  return generateYaml(deployment);
+}
+function checkHealth(config) {
+  const checks = [];
+  let overallHealthy = true;
+  try {
+    checks.push({
+      name: "database",
+      status: "pass",
+      message: `${config.database.type} connection OK`
+    });
+  } catch (error) {
+    checks.push({
+      name: "database",
+      status: "fail",
+      message: error instanceof Error ? error.message : "Connection failed"
+    });
+    overallHealthy = false;
+  }
+  checks.push({
+    name: "filesystem",
+    status: "pass",
+    message: "Write access OK"
+  });
+  return {
+    status: overallHealthy ? "healthy" : "unhealthy",
+    timestamp: /* @__PURE__ */ new Date(),
+    version: "2.0.0",
+    uptime: process.uptime(),
+    checks
+  };
+}
+function validateLicense(key) {
+  if (!key || key.length < 10) {
+    return null;
+  }
+  const parts = key.split("-");
+  if (parts.length < 6 || parts[0] !== "CTXOS") {
+    return null;
+  }
+  const typeMap = {
+    "T": "trial",
+    "TM": "team",
+    "E": "enterprise"
+  };
+  return {
+    key,
+    type: typeMap[parts[1]] || "trial",
+    organization: parts[2],
+    maxSeats: parseInt(parts[3]) || 5,
+    expiresAt: new Date(parseInt(parts[4]) * 1e3),
+    features: ["core", "analytics", "sync"],
+    signature: parts.slice(5).join("-")
+  };
+}
+function generateYaml(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  if (obj === null || obj === void 0) {
+    return "null";
+  }
+  if (typeof obj === "string") {
+    return obj.includes(":") || obj.includes("#") ? `"${obj}"` : obj;
+  }
+  if (typeof obj === "number" || typeof obj === "boolean") {
+    return String(obj);
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    return obj.map((item) => {
+      if (typeof item === "object" && item !== null) {
+        const yaml = generateYaml(item, indent + 1);
+        return `${spaces}- ${yaml.trim().replace(/\n/g, `
+${spaces}  `)}`;
+      }
+      return `${spaces}- ${generateYaml(item, indent)}`;
+    }).join("\n");
+  }
+  if (typeof obj === "object") {
+    const entries = Object.entries(obj);
+    if (entries.length === 0) return "{}";
+    return entries.map(([key, value]) => {
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return `${spaces}${key}:
+${generateYaml(value, indent + 1)}`;
+      }
+      if (Array.isArray(value)) {
+        return `${spaces}${key}:
+${generateYaml(value, indent + 1)}`;
+      }
+      return `${spaces}${key}: ${generateYaml(value, indent)}`;
+    }).join("\n");
+  }
+  return String(obj);
+}
+
 // src/errors.ts
 var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
   ErrorCode2["CONFIG_NOT_FOUND"] = "E1001";
@@ -5880,6 +7059,7 @@ export {
   ContextYamlSchema,
   DEFAULT_RLM_CONFIG,
   DEFAULT_SYNC_CONFIG,
+  DatasetFormatter,
   DependencyGraph,
   DriftDetector,
   E2EEncryption,
@@ -5896,6 +7076,8 @@ export {
   MODEL_SPECIFIC_ADDENDUM,
   MetaSchema,
   OpenAIAdapter,
+  PluginManager,
+  PluginRegistry,
   ProjectConfigSchema,
   ProposalManager,
   RBACManager,
@@ -5907,24 +7089,30 @@ export {
   TeamSync,
   TemplateManager,
   TokenBudget,
+  TrainingDataCollector,
   VectorStore,
   Watchdog,
   calculateCost,
+  checkHealth,
   chunkCode,
   createAnthropicAdapter,
   createBlackboard,
   createContextAPI,
+  createDatasetFormatter,
   createGeminiClient,
   createInitialUserMessage,
   createLogger,
   createObservationMessage,
   createOpenAIAdapter,
+  createPluginManager,
+  createPluginRegistry,
   createProposalManager,
   createRLMEngine,
   createSandbox,
   createSandboxContext,
   createScopeManager,
   createSubAgentResultMessage,
+  createTrainingDataCollector,
   createWatchdog,
   detectDrift,
   detectProjectType,
@@ -5934,6 +7122,10 @@ export {
   extractFunctionsRegex,
   extractImportsRegex,
   findContextosRoot,
+  generateDockerCompose,
+  generateDockerfile,
+  generateHelmValues,
+  generateK8sDeployment,
   generateSystemPrompt,
   getContextBuilder,
   getGlobalBlackboard,
@@ -5961,5 +7153,6 @@ export {
   saveContextYaml,
   setGlobalLogger,
   splitContextToFiles,
-  validateCode
+  validateCode,
+  validateLicense
 };

package/package.json

@@ -1,48 +1,48 @@
 {
-    "name": "@contextos/core",
-    "version": "0.1.0",
-    "description": "Core engine for ContextOS - context management, parsing, and ranking",
-    "type": "module",
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "exports": {
-        ".": {
-            "import": "./dist/index.js",
-            "types": "./dist/index.d.ts"
-        }
-    },
-    "scripts": {
-        "build": "tsup src/index.ts --format esm --clean",
-        "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
-        "test": "vitest run",
-        "test:watch": "vitest",
-        "test:coverage": "vitest run --coverage",
-        "lint": "eslint src/",
-        "clean": "rimraf dist"
-    },
-    "dependencies": {
-        "@xenova/transformers": "^2.17.0",
-        "better-sqlite3": "^11.0.0",
-        "chokidar": "^3.6.0",
-        "glob": "^10.3.0",
-        "tiktoken": "^1.0.15",
-        "web-tree-sitter": "^0.22.0",
-        "yaml": "^2.4.0",
-        "zod": "^3.23.0"
-    },
-    "devDependencies": {
-        "@types/better-sqlite3": "^7.6.9",
-        "eslint": "^8.57.0",
-        "rimraf": "^5.0.5",
-        "tsup": "^8.0.2",
-        "typescript": "^5.4.0",
-        "vitest": "^1.4.0"
-    },
-    "peerDependencies": {
-        "typescript": "^5.0.0"
-    },
-    "files": [
-        "dist"
-    ],
-    "license": "MIT"
+  "name": "@contextos/core",
+  "version": "0.2.0",
+  "description": "Core engine for ContextOS - context management, parsing, and ranking",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@xenova/transformers": "^2.17.0",
+    "better-sqlite3": "^11.0.0",
+    "chokidar": "^3.6.0",
+    "glob": "^10.3.0",
+    "tiktoken": "^1.0.15",
+    "web-tree-sitter": "^0.22.0",
+    "yaml": "^2.4.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.9",
+    "eslint": "^8.57.0",
+    "rimraf": "^5.0.5",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.0",
+    "vitest": "^1.4.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src/",
+    "clean": "rimraf dist"
+  }
 }