pixelcrew 0.2.3 → 0.2.6

package/src/index.js

@@ -1,3 +1,19 @@
+/**
+ * PIXEL CREW — Universal Multi-Provider Multi-Agent Orchestration Platform
+ */
+
 export { initializeProject } from './scaffold/init.js';
 export { OrchestratorEngine, AGENT_STATES, AGENT_EXPRESSIONS, ORCHESTRATOR_EXPRESSIONS } from './orchestrator/engine.js';
 export { createServer } from './server/server.js';
+
+// Protocol
+export * from './protocol/index.js';
+
+// Core
+export * from './core/index.js';
+
+// Adapters & Providers
+export * from './adapters/index.js';
+
+// Commands & Parser
+export * from './commands/index.js';

package/src/orchestrator/artifact-graph.js

@@ -0,0 +1,104 @@
+/**
+ * PIXEL CREW — Artifact Graph & Dependency Matrix
+ * 
+ * Tracks generated software artifacts, version histories, producer tasks,
+ * dependency trees, consumer linkages, and requirement traceability.
+ */
+
+export class ArtifactGraph {
+  constructor() {
+    this.nodes = new Map(); // path -> ArtifactNode
+  }
+
+  /**
+   * Register or update an artifact node
+   */
+  registerArtifact({ path, producerTask, requirements = [], dependencies = [], content = "", version = 1, repairReason = null }) {
+    const existing = this.nodes.get(path);
+    const currentVersion = existing ? existing.version + 1 : version;
+    const history = existing ? [...existing.history] : [];
+
+    if (existing) {
+      history.push({
+        version: existing.version,
+        producerTask: existing.producerTask,
+        requirements: existing.requirements,
+        repairReason: existing.repairReason,
+        timestamp: existing.timestamp
+      });
+    }
+
+    const node = {
+      path,
+      producerTask: producerTask || 'generator',
+      requirements: Array.isArray(requirements) ? requirements : [requirements],
+      dependencies: Array.isArray(dependencies) ? dependencies : [],
+      consumers: [],
+      version: currentVersion,
+      repairReason,
+      timestamp: new Date().toISOString(),
+      sizeBytes: typeof content === 'string' ? content.length : 0,
+      status: 'active',
+      history
+    };
+
+    this.nodes.set(path, node);
+    this.rebuildConsumers();
+    return node;
+  }
+
+  /**
+   * Get an artifact by path
+   */
+  getArtifact(path) {
+    return this.nodes.get(path) || null;
+  }
+
+  /**
+   * List all registered artifacts
+   */
+  listArtifacts() {
+    return Array.from(this.nodes.values());
+  }
+
+  /**
+   * Find artifacts addressing a specific requirement ID
+   */
+  findByRequirement(reqId) {
+    return Array.from(this.nodes.values()).filter(node => node.requirements.includes(reqId));
+  }
+
+  /**
+   * Find artifacts produced by a specific task
+   */
+  findByTask(taskId) {
+    return Array.from(this.nodes.values()).filter(node => node.producerTask === taskId);
+  }
+
+  /**
+   * Rebuild consumer references across graph
+   */
+  rebuildConsumers() {
+    for (const node of this.nodes.values()) {
+      node.consumers = [];
+    }
+    for (const [consumerPath, node] of this.nodes.entries()) {
+      for (const depPath of node.dependencies) {
+        const depNode = this.nodes.get(depPath);
+        if (depNode && !depNode.consumers.includes(consumerPath)) {
+          depNode.consumers.push(consumerPath);
+        }
+      }
+    }
+  }
+
+  /**
+   * Serialize graph for diagnostics & reports
+   */
+  toJSON() {
+    return {
+      totalArtifacts: this.nodes.size,
+      artifacts: Array.from(this.nodes.values())
+    };
+  }
+}

package/src/orchestrator/ast-normalizer.js

@@ -0,0 +1,147 @@
+/**
+ * PIXEL CREW — AST Normalizer
+ * 
+ * Responsibilities:
+ * 1. Normalize casing, naming conventions, and identifiers.
+ * 2. Create deterministic, stable IDs for all software constructs.
+ * 3. Validate entity references across relationships, views, and operations.
+ * 4. Ensure requirement IDs are strictly unique and traceable.
+ * 5. Reject malformed ASTs without introducing any domain-specific heuristics.
+ */
+
+import { UniversalSoftwareOntology } from './ontology.js';
+
+export class ASTNormalizer {
+  /**
+   * Normalize an arbitrary Project AST.
+   */
+  static normalize(rawAST) {
+    if (!rawAST || typeof rawAST !== 'object') {
+      throw new Error('ASTNormalizer: input AST must be a non-null object.');
+    }
+
+    // 1. Normalize Project Metadata
+    const project = UniversalSoftwareOntology.validateProject(rawAST.project || {
+      name: rawAST.appName || rawAST.projectName || 'Synthesized Application',
+      description: rawAST.summary || rawAST.description || 'Open-World Synthesized Software Application',
+      domain: rawAST.domain || (rawAST.domainMeta ? rawAST.domainMeta.id : 'software-system'),
+      goals: Array.isArray(rawAST.goals) ? rawAST.goals : []
+    });
+
+    // 2. Normalize Entities & build reference set
+    const rawEntities = Array.isArray(rawAST.entities) ? rawAST.entities : [];
+    if (rawEntities.length === 0) {
+      throw new Error('ASTNormalizer: AST must contain at least one valid Entity.');
+    }
+
+    const seenEntityNames = new Set();
+    const entities = rawEntities.map((e, idx) => {
+      const validated = UniversalSoftwareOntology.validateEntity(e, idx);
+      if (seenEntityNames.has(validated.name)) {
+        // Disambiguate duplicate name
+        validated.name = `${validated.name}_${idx + 1}`;
+        validated.id = `entity-${validated.name.toLowerCase()}`;
+      }
+      seenEntityNames.add(validated.name);
+      return validated;
+    });
+
+    const entityNameMap = new Set(entities.map(e => e.name));
+
+    // Fix relationships target references
+    entities.forEach(ent => {
+      ent.relationships = ent.relationships.map(rel => {
+        if (!entityNameMap.has(rel.targetEntity)) {
+          // If referencing unknown entity, point to first available or keep clean
+          const match = Array.from(entityNameMap).find(n => n.toLowerCase() === rel.targetEntity.toLowerCase());
+          return {
+            ...rel,
+            targetEntity: match || Array.from(entityNameMap)[0]
+          };
+        }
+        return rel;
+      });
+    });
+
+    // 3. Normalize Actors
+    const rawActors = Array.isArray(rawAST.actors) && rawAST.actors.length > 0
+      ? rawAST.actors
+      : [{ name: 'User', role: 'Operator' }];
+    const actors = rawActors.map((a, idx) => UniversalSoftwareOntology.validateActor(a, idx));
+
+    // 4. Normalize Capabilities
+    const capabilities = Array.isArray(rawAST.capabilities) && rawAST.capabilities.length > 0
+      ? Array.from(new Set(rawAST.capabilities.map(String)))
+      : ['search', 'filter', 'view', 'create', 'edit'];
+
+    // 5. Normalize Workflows
+    const rawWorkflows = Array.isArray(rawAST.workflows) ? rawAST.workflows : [];
+    const workflows = rawWorkflows.map((w, idx) => UniversalSoftwareOntology.validateWorkflow(w, idx));
+
+    // 6. Normalize Views & target entities
+    const rawViews = Array.isArray(rawAST.views) ? rawAST.views : [];
+    const views = rawViews.map((v, idx) => {
+      const validated = UniversalSoftwareOntology.validateView(v, entities, idx);
+      // Ensure target entities exist
+      validated.targetEntities = validated.targetEntities.map(t => {
+        if (entityNameMap.has(t)) return t;
+        const match = Array.from(entityNameMap).find(n => n.toLowerCase() === t.toLowerCase());
+        return match || entities[0].name;
+      });
+      return validated;
+    });
+
+    // 7. Normalize Operations
+    const rawOps = Array.isArray(rawAST.operations) ? rawAST.operations : [];
+    const operations = rawOps.map((op, idx) => {
+      const validated = UniversalSoftwareOntology.validateOperation(op, entities, idx);
+      if (!entityNameMap.has(validated.targetEntity)) {
+        const match = Array.from(entityNameMap).find(n => n.toLowerCase() === validated.targetEntity.toLowerCase());
+        validated.targetEntity = match || entities[0].name;
+      }
+      return validated;
+    });
+
+    // 8. Normalize Requirements (Ensure unique REQ-001..N)
+    const rawReqs = Array.isArray(rawAST.requirements) ? rawAST.requirements : [];
+    const seenReqIds = new Set();
+    const requirements = rawReqs.map((req, idx) => {
+      const validated = UniversalSoftwareOntology.validateRequirement(req, idx);
+      let uniqueId = validated.id;
+      let counter = idx + 1;
+      while (seenReqIds.has(uniqueId)) {
+        uniqueId = `REQ-${String(counter++).padStart(3, '0')}`;
+      }
+      seenReqIds.add(uniqueId);
+      validated.id = uniqueId;
+      return validated;
+    });
+
+    // 9. Normalize Events
+    const rawEvents = Array.isArray(rawAST.events) ? rawAST.events : [];
+    const events = rawEvents.map((evt, idx) => UniversalSoftwareOntology.validateEvent(evt, idx));
+
+    return {
+      project,
+      appName: project.name,
+      projectName: project.name,
+      companyName: rawAST.companyName || project.name,
+      headline: rawAST.headline || `Engineered for ${project.name}`,
+      summary: rawAST.summary || project.description,
+      domain: project.domain,
+      domainMeta: rawAST.domainMeta || { id: project.domain, label: project.name, confidence: 0.95 },
+      appType: rawAST.appType || { id: project.domain, name: project.name, category: project.domain, confidence: 0.95 },
+      actors,
+      entities,
+      capabilities,
+      workflows,
+      views,
+      operations,
+      events,
+      requirements,
+      palette: rawAST.palette,
+      fonts: rawAST.fonts,
+      rawPrompt: rawAST.rawPrompt || ''
+    };
+  }
+}