@ultrst-armada/krnl 1.0.1 → 1.0.3

package/packages/cli/dist/chunk-PPOF3DJW.js

@@ -1,471 +0,0 @@
-// ../validate/dist/index.js
-import * as fs from "fs";
-import * as path from "path";
-import { Project, SyntaxKind } from "ts-morph";
-var KrnlValidatorEngine = class {
-  project;
-  projectRoot;
-  maxFileLineLimit;
-  maxMainLogicLimit;
-  maxHelperLineLimit;
-  constructor(options) {
-    this.projectRoot = path.resolve(options.projectRoot);
-    this.maxFileLineLimit = options.maxFileLineLimit ?? 200;
-    this.maxMainLogicLimit = options.maxMainLogicLimit ?? 20;
-    this.maxHelperLineLimit = options.maxHelperLineLimit ?? 30;
-    const tsConfigPath = path.join(this.projectRoot, "tsconfig.json");
-    if (fs.existsSync(tsConfigPath)) {
-      this.project = new Project({ tsConfigFilePath: tsConfigPath, skipAddingFilesFromTsConfig: true });
-    } else {
-      this.project = new Project({ compilerOptions: {
-        target: 99
-        /* ESNext */
-      } });
-    }
-  }
-  /**
-   * Scans and validates all source files in the project.
-   */
-  validateAll() {
-    const files = this.collectSourceFiles(this.projectRoot);
-    const errors = [];
-    const warnings = [];
-    for (const f of files) {
-      const sf = this.project.addSourceFileAtPath(f);
-      const fileReport = this.validateSourceFile(sf);
-      errors.push(...fileReport.errors);
-      warnings.push(...fileReport.warnings);
-    }
-    return {
-      valid: errors.length === 0,
-      totalFiles: files.length,
-      errors,
-      warnings
-    };
-  }
-  /**
-   * Validates a single SourceFile.
-   */
-  validateSourceFile(sf) {
-    const errors = [];
-    const warnings = [];
-    const filePath = sf.getFilePath();
-    const sourceText = sf.getText();
-    const baseName = path.basename(filePath);
-    if (baseName.includes("_pb.") || baseName.endsWith(".d.ts")) {
-      return { errors, warnings };
-    }
-    const lines = sourceText.split("\n");
-    if (lines.length > this.maxFileLineLimit) {
-      errors.push({
-        ruleId: "krnl/file-line-limit",
-        filePath,
-        message: `File exceeds maximum length of ${this.maxFileLineLimit} lines (currently ${lines.length} lines).`,
-        severity: "error"
-      });
-    }
-    for (const decl of sf.getImportDeclarations()) {
-      const moduleSpec = decl.getModuleSpecifierValue();
-      if (moduleSpec.startsWith(".") && !moduleSpec.endsWith(".js") && !moduleSpec.endsWith(".json")) {
-        const line = decl.getStartLineNumber();
-        errors.push({
-          ruleId: "krnl/import-suffix",
-          filePath,
-          line,
-          message: `Relative import '${moduleSpec}' must end with '.js' for NodeNext module resolution.`,
-          severity: "error"
-        });
-      }
-    }
-    const isHelper = filePath.includes("helper_functions") || filePath.includes("/helpers/") || filePath.includes("\\helpers\\");
-    const isMainLogic = filePath.endsWith("logic.ts") || filePath.endsWith("logic.js");
-    const isRootConcept = filePath.includes("libraries/") || filePath.includes("Concepts.ts");
-    if (isHelper) {
-      for (const decl of sf.getImportDeclarations()) {
-        const spec = decl.getModuleSpecifierValue();
-        if (["fs", "node:fs", "http", "node:http", "ws"].includes(spec)) {
-          errors.push({
-            ruleId: "krnl/helper-purity",
-            filePath,
-            line: decl.getStartLineNumber(),
-            message: `Helper functions (Layer 1) cannot directly import I/O modules ('${spec}'). Delegate to Layer 0 libraries or Entity context.`,
-            severity: "error"
-          });
-        }
-      }
-      for (const fn of sf.getFunctions()) {
-        const fnLines = fn.getText().split("\n").length;
-        if (fnLines > this.maxHelperLineLimit && !sourceText.includes("Concepts.")) {
-          errors.push({
-            ruleId: "krnl/helper-line-limit",
-            filePath,
-            line: fn.getStartLineNumber(),
-            message: `Helper function '${fn.getName() || "anonymous"}' exceeds ${this.maxHelperLineLimit} lines (${fnLines} lines). Must delegate to a root libraries/{Domain}Concepts.ts library.`,
-            severity: "error"
-          });
-        }
-      }
-    }
-    if (isMainLogic) {
-      const substantiveLines = lines.filter((l) => {
-        const trimmed = l.trim();
-        return trimmed.length > 0 && !trimmed.startsWith("//") && !trimmed.startsWith("/*") && !trimmed.startsWith("*");
-      });
-      if (substantiveLines.length > this.maxMainLogicLimit && !sourceText.includes("helpers") && !sourceText.includes("Concepts") && !sourceText.includes("state")) {
-        errors.push({
-          ruleId: "krnl/main-delegation",
-          filePath,
-          message: `Main logic function has ${substantiveLines.length} substantive lines without delegating to Layer 1 helper functions or Layer 0 libraries.`,
-          severity: "error"
-        });
-      }
-    }
-    if (sourceText.includes("main = async") || sourceText.includes("export const main = async")) {
-      const match = sourceText.match(/main\s*=\s*async\s*\([^,]+,\s*\{([^}]*)\}\s*\)/);
-      if (match) {
-        const destructured = match[1];
-        if (/\bsystem\b/.test(destructured) && !/\bentity\b/.test(destructured)) {
-          errors.push({
-            ruleId: "krnl/context-destructuring",
-            filePath,
-            message: `Functionality context parameter destructures 'system'. Functionality passes { state, entity }. Always destructure 'entity'.`,
-            severity: "error"
-          });
-        }
-      }
-    }
-    const calls = sf.getDescendantsOfKind(SyntaxKind.CallExpression);
-    for (const call of calls) {
-      const exprText = call.getExpression().getText();
-      if (exprText === "setInterval" || exprText === "window.setInterval") {
-        errors.push({
-          ruleId: "krnl/no-polling",
-          filePath,
-          line: call.getStartLineNumber(),
-          message: `Prohibited use of 'setInterval'. Krnl applications must use reactive event streams (entity.emitEvent / entity.on).`,
-          severity: "error"
-        });
-      }
-    }
-    const isEntityClass = sf.getClasses().some((c) => {
-      const ext = c.getExtends();
-      return ext && (ext.getText().includes("Entity") || ext.getText().includes("krnlEntityBase"));
-    });
-    if (isEntityClass) {
-      let loadAllLine = -1;
-      const addLocalLines = [];
-      for (const call of calls) {
-        const txt = call.getText();
-        if (txt.includes("MagneticLoader.loadAll") || txt.includes("KrnlMagneticLoader.loadAll")) {
-          loadAllLine = call.getStartLineNumber();
-        } else if (txt.startsWith("this.addLocal(")) {
-          const hasUiSpec = txt.includes("uiSpec");
-          const idMatch = txt.match(/id\s*:\s*["']([^"']+)["']/);
-          addLocalLines.push({
-            line: call.getStartLineNumber(),
-            hasUiSpec,
-            id: idMatch ? idMatch[1] : "unknown"
-          });
-        }
-      }
-      if (loadAllLine !== -1) {
-        for (const al of addLocalLines) {
-          if (al.hasUiSpec && al.line > loadAllLine) {
-            errors.push({
-              ruleId: "krnl/boot-order",
-              filePath,
-              line: al.line,
-              message: `addLocal('${al.id}') with uiSpec at line ${al.line} appears AFTER loadAll() at line ${loadAllLine}. All addLocal() with UI must precede loadAll().`,
-              severity: "error"
-            });
-          }
-        }
-      }
-    }
-    return { errors, warnings };
-  }
-  collectSourceFiles(dir, collected = []) {
-    if (!fs.existsSync(dir)) return collected;
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
-      const full = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        this.collectSourceFiles(full, collected);
-      } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
-        collected.push(full);
-      }
-    }
-    return collected;
-  }
-};
-
-// src/commands/validate.ts
-async function runValidate(projectRoot = process.cwd()) {
-  console.log(`
-\u{1F50D} [Krnl Validate] Scanning project at: ${projectRoot}
-`);
-  const validator = new KrnlValidatorEngine({ projectRoot });
-  const report = validator.validateAll();
-  if (report.warnings.length > 0) {
-    console.warn(`\u26A0\uFE0F  [WARNINGS] Found ${report.warnings.length} warning(s):`);
-    for (const w of report.warnings) {
-      console.warn(`  - [${w.ruleId}] ${w.filePath}${w.line ? `:${w.line}` : ""}: ${w.message}`);
-    }
-  }
-  if (!report.valid) {
-    console.error(`
-\u274C [VALIDATION FAILED] Found ${report.errors.length} error(s):
-`);
-    for (const err of report.errors) {
-      console.error(`  \u274C [${err.ruleId}] ${err.filePath}${err.line ? `:${err.line}` : ""}`);
-      console.error(`     ${err.message}
-`);
-    }
-    return false;
-  }
-  console.log(`\u2705 [VALIDATION PASSED] ${report.totalFiles} source files verified clean against Krnl paradigms.
-`);
-  return true;
-}
-
-// src/commands/generate.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-async function runGenerate(type, name, parentEntity, projectRoot = process.cwd()) {
-  if (!name) {
-    console.error("\u274C Error: Resource name is required. Usage: krnl generate <entity|functionality|library|subapp> <Name> [ParentEntity]");
-    process.exit(1);
-  }
-  switch (type.toLowerCase()) {
-    case "entity":
-      generateEntity(name, projectRoot);
-      break;
-    case "functionality":
-      if (!parentEntity) {
-        console.error("\u274C Error: Parent entity name is required for functionality. Usage: krnl generate functionality <Name> <ParentEntity>");
-        process.exit(1);
-      }
-      generateFunctionality(name, parentEntity, projectRoot);
-      break;
-    case "library":
-      generateLibrary(name, projectRoot);
-      break;
-    case "subapp":
-      generateSubApp(name, projectRoot);
-      break;
-    default:
-      console.error(`\u274C Unknown resource type '${type}'. Valid types: entity, functionality, library, subapp`);
-      process.exit(1);
-  }
-}
-function generateEntity(name, projectRoot) {
-  const entityDir = path2.join(projectRoot, "src", "entities", name);
-  fs2.mkdirSync(entityDir, { recursive: true });
-  fs2.mkdirSync(path2.join(entityDir, "functionalities"), { recursive: true });
-  const entityFile = path2.join(entityDir, `${name}.ts`);
-  const content = `import { Entity, KrnlMagneticLoader } from '@dinilmusick/krnl-core';
-
-export class ${name} extends Entity {
-  constructor() {
-    super({
-      id: '${name}',
-      version: '1.0.0',
-      description: '${name} root entity'
-    });
-  }
-
-  async boot(): Promise<void> {
-    // 1. Local functionalities with UI must precede loadAll
-    
-    // 2. Discover magnetic functionalities, child entities, and subapps
-    await KrnlMagneticLoader.loadAll(this, import.meta.url);
-  }
-}
-
-export default ${name};
-`;
-  fs2.writeFileSync(entityFile, content);
-  console.log(`\u2705 Created Entity: src/entities/${name}/${name}.ts`);
-}
-function generateFunctionality(name, entityName, projectRoot) {
-  const funcDir = path2.join(projectRoot, "src", "entities", entityName, "functionalities", name);
-  fs2.mkdirSync(path2.join(funcDir, "main_function"), { recursive: true });
-  fs2.mkdirSync(path2.join(funcDir, "state_data"), { recursive: true });
-  fs2.mkdirSync(path2.join(funcDir, "helper_functions"), { recursive: true });
-  fs2.mkdirSync(path2.join(funcDir, "events"), { recursive: true });
-  fs2.writeFileSync(path2.join(funcDir, `${name}Atom.ts`), `export interface ${name}Input {
-  message?: string;
-}
-
-export interface ${name}Output {
-  success: boolean;
-  timestamp: number;
-}
-`);
-  fs2.writeFileSync(path2.join(funcDir, "main_function", "logic.ts"), `import { ${name}Input, ${name}Output } from '../${name}Atom.js';
-import { formatTimestamp } from '../helper_functions/formatTimestamp.js';
-
-export const main = async (input: ${name}Input, { state, entity }: any): Promise<${name}Output> => {
-  const timestamp = formatTimestamp();
-  return {
-    success: true,
-    timestamp
-  };
-};
-`);
-  fs2.writeFileSync(path2.join(funcDir, "state_data", "state.ts"), `export interface ${name}State {
-  executionCount: number;
-}
-
-export const initialState: ${name}State = {
-  executionCount: 0
-};
-`);
-  fs2.writeFileSync(path2.join(funcDir, "helper_functions", "formatTimestamp.ts"), `export function formatTimestamp(): number {
-  return Date.now();
-}
-`);
-  console.log(`\u2705 Created Quad-Unit Functionality: src/entities/${entityName}/functionalities/${name}/`);
-}
-function generateLibrary(name, projectRoot) {
-  const libDir = path2.join(projectRoot, "src", "libraries");
-  fs2.mkdirSync(libDir, { recursive: true });
-  const fileName = `${name}Concepts.ts`;
-  fs2.writeFileSync(path2.join(libDir, fileName), `/**
- * @file ${fileName}
- * @role component
- * @description Layer 0 pure domain concept library for ${name}.
- */
-
-export class ${name}Concepts {
-  static pureTransform<T>(data: T): T {
-    return data;
-  }
-}
-`);
-  console.log(`\u2705 Created Domain Concept Library: src/libraries/${fileName}`);
-}
-function generateSubApp(name, projectRoot) {
-  const subappDir = path2.join(projectRoot, "src", "subapps", name);
-  fs2.mkdirSync(subappDir, { recursive: true });
-  fs2.writeFileSync(path2.join(subappDir, "subapp.json"), JSON.stringify({
-    name,
-    version: "1.0.0",
-    description: `${name} self-contained sub-app`,
-    registrationEntry: "./register.js"
-  }, null, 2));
-  fs2.writeFileSync(path2.join(subappDir, "register.ts"), `export function register(context: any) {
-  context.logger.log('Registering ${name} sub-app');
-  return {
-    name: '${name}',
-    operations: []
-  };
-}
-export default register;
-`);
-  console.log(`\u2705 Created Sub-App: src/subapps/${name}/`);
-}
-
-// src/commands/watch.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-function generateMagneticDeclarations(projectRoot = process.cwd()) {
-  const functionalities = scanDirectory(projectRoot);
-  let dtsContent = `// Automatically generated by Krnl Magnetic Watcher. Do not edit manually.
-
-`;
-  dtsContent += `import { Entity } from '@dinilmusick/krnl-core';
-
-`;
-  const globalDeclarations = [];
-  for (const func of functionalities) {
-    const helpersDir = path3.join(func.funcPath, "helper_functions");
-    if (fs3.existsSync(helpersDir)) {
-      const files = fs3.readdirSync(helpersDir);
-      for (const file of files) {
-        if (file.endsWith(".js") || file.endsWith(".ts")) {
-          const filePath = path3.join(helpersDir, file);
-          const baseName = path3.basename(file, path3.extname(file));
-          const importPath = `./${path3.relative(projectRoot, filePath).replace(/\\/g, "/")}`;
-          const { named, hasDefault } = parseExports(filePath, baseName);
-          if (hasDefault) {
-            globalDeclarations.push(`  const ${baseName}: typeof import('${importPath}')['default'];`);
-          }
-          for (const name of named) {
-            globalDeclarations.push(`  const ${name}: typeof import('${importPath}')['${name}'];`);
-          }
-        }
-      }
-    }
-    const eventsDir = path3.join(func.funcPath, "events");
-    if (fs3.existsSync(eventsDir)) {
-      const files = fs3.readdirSync(eventsDir);
-      for (const file of files) {
-        if (file.endsWith(".js") || file.endsWith(".ts")) {
-          const filePath = path3.join(eventsDir, file);
-          const baseName = path3.basename(file, path3.extname(file));
-          const importPath = `./${path3.relative(projectRoot, filePath).replace(/\\/g, "/")}`;
-          const { named, hasDefault } = parseExports(filePath, baseName);
-          if (hasDefault) {
-            globalDeclarations.push(`  const ${baseName}: typeof import('${importPath}')['default'];`);
-          }
-          for (const name of named) {
-            globalDeclarations.push(`  const ${name}: typeof import('${importPath}')['${name}'];`);
-          }
-        }
-      }
-    }
-  }
-  if (globalDeclarations.length > 0) {
-    dtsContent += `declare global {
-${Array.from(new Set(globalDeclarations)).join("\n")}
-}
-`;
-  }
-  const outPath = path3.join(projectRoot, "krnl-magnetic.d.ts");
-  fs3.writeFileSync(outPath, dtsContent);
-  console.log(`[Krnl Watch] Updated ambient declarations: ${outPath}`);
-}
-function scanDirectory(dir, results = []) {
-  if (!fs3.existsSync(dir)) return results;
-  const list = fs3.readdirSync(dir, { withFileTypes: true });
-  for (const entry of list) {
-    if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
-      const fullPath = path3.join(dir, entry.name);
-      if (entry.name === "functionalities") {
-        const funcs = fs3.readdirSync(fullPath, { withFileTypes: true });
-        for (const f of funcs) {
-          if (f.isDirectory()) {
-            results.push({ funcPath: path3.join(fullPath, f.name), funcName: f.name });
-          }
-        }
-      } else {
-        scanDirectory(fullPath, results);
-      }
-    }
-  }
-  return results;
-}
-function parseExports(filePath, defaultName) {
-  const content = fs3.readFileSync(filePath, "utf8");
-  const named = [];
-  let hasDefault = false;
-  const namedRegex = /export\s+(?:const|let|var|function|class|async\s+function)\s+([a-zA-Z0-9_$]+)/g;
-  let match;
-  while ((match = namedRegex.exec(content)) !== null) {
-    if (match[1]) named.push(match[1]);
-  }
-  if (content.includes("export default")) {
-    hasDefault = true;
-  }
-  return { named, hasDefault };
-}
-
-export {
-  KrnlValidatorEngine,
-  runValidate,
-  runGenerate,
-  generateMagneticDeclarations
-};

package/packages/cli/dist/chunk-Q45257P6.js

@@ -1,173 +0,0 @@
-// ../core/dist/chunk-DI27MOR7.js
-var KrnlTelemetry = class {
-  metrics;
-  callLogs;
-  libraryUsage;
-  dataUsage;
-  enabled;
-  ringBufferSize;
-  aiTraces;
-  totalAiCalls;
-  totalAiRetries;
-  avgAiLatencyMs;
-  runtimeStore = null;
-  constructor() {
-    this.metrics = /* @__PURE__ */ new Map();
-    this.callLogs = /* @__PURE__ */ new Map();
-    this.libraryUsage = /* @__PURE__ */ new Map();
-    this.dataUsage = /* @__PURE__ */ new Map();
-    this.enabled = false;
-    this.ringBufferSize = 100;
-    this.aiTraces = [];
-    this.totalAiCalls = 0;
-    this.totalAiRetries = 0;
-    this.avgAiLatencyMs = 0;
-  }
-  setRuntimeStore(store) {
-    this.runtimeStore = store;
-  }
-  recordAiTrace(trace) {
-    if (this.aiTraces.length >= this.ringBufferSize) {
-      this.aiTraces.shift();
-    }
-    this.aiTraces.push(trace);
-    this.totalAiCalls++;
-    this.totalAiRetries += trace.retryCount || 0;
-    this.avgAiLatencyMs = (this.avgAiLatencyMs * (this.totalAiCalls - 1) + trace.latencyMs) / this.totalAiCalls;
-    if (this.runtimeStore) {
-      this.runtimeStore.appendTelemetry({
-        type: "ai_trace",
-        endpointId: trace.endpointId,
-        timestamp: trace.timestamp,
-        latencyMs: trace.latencyMs,
-        retryCount: trace.retryCount,
-        success: !trace.failureReason,
-        failures: trace.validationFailures
-      }).catch(() => {
-      });
-    }
-  }
-  /**
-   * Starts a telemetry trace for a specific functionality.
-   * @param fid 
-   * @returns Trace data
-   */
-  startTrace(fid) {
-    return {
-      startTime: process.hrtime.bigint(),
-      startMemory: process.memoryUsage ? process.memoryUsage().heapUsed : 0
-    };
-  }
-  /**
-   * Ends a telemetry trace and updates aggregated metrics.
-   * @param fid 
-   * @param trace 
-   */
-  endTrace(fid, trace, success = true) {
-    const endTime = process.hrtime.bigint();
-    const endMemory = process.memoryUsage ? process.memoryUsage().heapUsed : 0;
-    const latencyNs = Number(endTime - trace.startTime);
-    const memoryDelta = endMemory - trace.startMemory;
-    const latencyMs = latencyNs / 1e6;
-    let stats = this.metrics.get(fid);
-    if (!stats) {
-      stats = {
-        calls: 0,
-        errors: 0,
-        totalLatencyNs: 0,
-        avgLatencyMs: 0,
-        peakLatencyMs: 0,
-        totalMemoryDelta: 0,
-        avgMemoryDelta: 0,
-        lastUpdated: 0
-      };
-      this.metrics.set(fid, stats);
-    }
-    stats.calls++;
-    if (!success) stats.errors++;
-    stats.totalLatencyNs += latencyNs;
-    stats.totalMemoryDelta += memoryDelta;
-    stats.avgLatencyMs = stats.totalLatencyNs / stats.calls / 1e6;
-    stats.avgMemoryDelta = stats.totalMemoryDelta / stats.calls;
-    if (latencyMs > stats.peakLatencyMs) stats.peakLatencyMs = latencyMs;
-    stats.lastUpdated = Date.now();
-    if (this.enabled) {
-      let logs = this.callLogs.get(fid);
-      if (!logs) {
-        logs = [];
-        this.callLogs.set(fid, logs);
-      }
-      logs.push({
-        timestamp: Date.now(),
-        durationMs: latencyMs,
-        success
-      });
-      if (logs.length > this.ringBufferSize) {
-        logs.shift();
-      }
-    }
-    if (this.runtimeStore) {
-      this.runtimeStore.appendTelemetry({
-        type: "standard_call",
-        endpointId: fid,
-        timestamp: Date.now(),
-        durationMs: latencyMs,
-        success
-      }).catch(() => {
-      });
-    }
-  }
-  /**
-   * Record library usage (functions/helpers).
-   */
-  recordLibraryCall(libraryId, durationMs) {
-    if (!this.enabled) return;
-    let stats = this.libraryUsage.get(libraryId);
-    if (!stats) {
-      stats = { calls: 0, totalDurationMs: 0, avgDurationMs: 0 };
-      this.libraryUsage.set(libraryId, stats);
-    }
-    stats.calls++;
-    stats.totalDurationMs += durationMs;
-    stats.avgDurationMs = stats.totalDurationMs / stats.calls;
-  }
-  /**
-   * Record library data access.
-   */
-  recordDataAccess(dataKey, type = "read") {
-    if (!this.enabled) return;
-    let stats = this.dataUsage.get(dataKey);
-    if (!stats) {
-      stats = { reads: 0, writes: 0 };
-      this.dataUsage.set(dataKey, stats);
-    }
-    if (type === "read") stats.reads++;
-    else stats.writes++;
-  }
-  /**
-   * Returns a snapshot of all metrics.
-   */
-  getSummary() {
-    return {
-      metrics: Object.fromEntries(this.metrics),
-      callLogs: Object.fromEntries(this.callLogs),
-      libraryUsage: Object.fromEntries(this.libraryUsage),
-      dataUsage: Object.fromEntries(this.dataUsage)
-    };
-  }
-  /**
-   * Clears all collected metrics.
-   */
-  reset() {
-    this.metrics.clear();
-    this.callLogs.clear();
-    this.libraryUsage.clear();
-    this.dataUsage.clear();
-  }
-};
-var telemetry = new KrnlTelemetry();
-
-export {
-  KrnlTelemetry,
-  telemetry
-};