genesis-ai-cli 7.4.5

package/dist/src/tools/index.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * Genesis Tools Module
+ *
+ * Local tool capabilities:
+ * - Bash: Secure command execution
+ * - Edit: Diff-based file editing
+ * - Git: Native git operations
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolRegistry = void 0;
+__exportStar(require("./bash.js"), exports);
+__exportStar(require("./edit.js"), exports);
+__exportStar(require("./git.js"), exports);
+// Will be populated as tools are added
+exports.toolRegistry = new Map();
+// Register bash tool
+const bash_js_1 = require("./bash.js");
+exports.toolRegistry.set('bash', {
+    name: 'bash',
+    description: 'Execute shell commands in a secure sandbox',
+    execute: async (params) => {
+        const command = params.command;
+        const options = params.options;
+        return (0, bash_js_1.getBashTool)().execute(command, options);
+    },
+    validate: (params) => {
+        const command = params.command;
+        if (!command) {
+            return { valid: false, reason: 'Missing command parameter' };
+        }
+        const result = (0, bash_js_1.getBashTool)().validate(command);
+        return { valid: result.valid, reason: result.reason };
+    },
+});
+// Register edit tool
+const edit_js_1 = require("./edit.js");
+exports.toolRegistry.set('edit', {
+    name: 'edit',
+    description: 'Edit files using diff-based replacement',
+    execute: async (params) => {
+        return (0, edit_js_1.getEditTool)().edit({
+            file_path: params.file_path,
+            old_string: params.old_string,
+            new_string: params.new_string,
+            replace_all: params.replace_all,
+        });
+    },
+    validate: (params) => {
+        const file_path = params.file_path;
+        const old_string = params.old_string;
+        const new_string = params.new_string;
+        if (!file_path)
+            return { valid: false, reason: 'Missing file_path parameter' };
+        if (!old_string)
+            return { valid: false, reason: 'Missing old_string parameter' };
+        if (new_string === undefined)
+            return { valid: false, reason: 'Missing new_string parameter' };
+        return (0, edit_js_1.getEditTool)().validatePath(file_path);
+    },
+});
+exports.toolRegistry.set('write', {
+    name: 'write',
+    description: 'Write content to a file',
+    execute: async (params) => {
+        const { file_path, content, backup } = params;
+        return (0, edit_js_1.getEditTool)().write({
+            file_path: file_path,
+            content: content,
+            backup: backup,
+        });
+    },
+    validate: (params) => {
+        const { file_path, content } = params;
+        if (!file_path)
+            return { valid: false, reason: 'Missing file_path parameter' };
+        if (content === undefined)
+            return { valid: false, reason: 'Missing content parameter' };
+        return (0, edit_js_1.getEditTool)().validatePath(file_path);
+    },
+});
+// Register git tools
+const git_js_1 = require("./git.js");
+exports.toolRegistry.set('git_status', {
+    name: 'git_status',
+    description: 'Get git repository status',
+    execute: async (params) => {
+        return (0, git_js_1.getGitTool)().status(params.cwd);
+    },
+});
+exports.toolRegistry.set('git_diff', {
+    name: 'git_diff',
+    description: 'Get diff of changes',
+    execute: async (params) => {
+        return (0, git_js_1.getGitTool)().diff({
+            staged: params.staged,
+            file: params.file,
+        }, params.cwd);
+    },
+});
+exports.toolRegistry.set('git_log', {
+    name: 'git_log',
+    description: 'Get commit history',
+    execute: async (params) => {
+        return (0, git_js_1.getGitTool)().log({
+            count: params.count,
+            oneline: params.oneline,
+        }, params.cwd);
+    },
+});
+exports.toolRegistry.set('git_add', {
+    name: 'git_add',
+    description: 'Stage files for commit',
+    execute: async (params) => {
+        const files = params.files;
+        if (!files || files.length === 0) {
+            return { success: false, error: 'No files specified' };
+        }
+        return (0, git_js_1.getGitTool)().add(files, params.cwd);
+    },
+});
+exports.toolRegistry.set('git_commit', {
+    name: 'git_commit',
+    description: 'Create a commit',
+    execute: async (params) => {
+        const message = params.message;
+        if (!message) {
+            return { success: false, error: 'Missing commit message' };
+        }
+        return (0, git_js_1.getGitTool)().commit({
+            message,
+            addSignature: params.addSignature,
+            files: params.files,
+        }, params.cwd);
+    },
+});
+exports.toolRegistry.set('git_push', {
+    name: 'git_push',
+    description: 'Push to remote (requires confirmation)',
+    execute: async (params) => {
+        return (0, git_js_1.getGitTool)().push({
+            remote: params.remote,
+            branch: params.branch,
+            setUpstream: params.setUpstream,
+            force: params.force,
+            confirmed: params.confirmed,
+        }, params.cwd);
+    },
+});

package/dist/src/types.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Genesis - System Creator Types
+ *
+ * Core type definitions for MCP orchestration
+ */
+/**
+ * Names of all 13 MCP servers available to Genesis.
+ * Renamed from MCPServer to avoid conflict with MCPServerState interface.
+ */
+export type MCPServerName = 'filesystem' | 'github' | 'openai' | 'memory' | 'gemini' | 'context7' | 'arxiv' | 'semantic-scholar' | 'wolfram' | 'firecrawl' | 'exa' | 'brave-search' | 'stability-ai';
+/** @deprecated Use MCPServerName instead */
+export type MCPServer = MCPServerName;
+export interface MCPCapability {
+    server: MCPServerName;
+    category: 'knowledge' | 'creation' | 'research' | 'visual' | 'storage';
+    tools: string[];
+    description: string;
+}
+export interface SystemSpec {
+    name: string;
+    description: string;
+    type: 'autopoietic' | 'agent' | 'multi-agent' | 'service' | 'custom';
+    features: string[];
+    constraints?: string[];
+    inspirations?: string[];
+}
+export interface GeneratedSystem {
+    spec: SystemSpec;
+    research: ResearchResult;
+    architecture: Architecture;
+    code: GeneratedCode;
+    visuals: Visual[];
+    repo?: string;
+}
+export interface ResearchResult {
+    papers: Paper[];
+    documentation: Documentation[];
+    codeExamples: CodeExample[];
+    webResults: WebResult[];
+    insights: string[];
+}
+export interface Paper {
+    title: string;
+    authors: string[];
+    year: number;
+    source: 'arxiv' | 'semantic-scholar';
+    url: string;
+    summary: string;
+    relevance: number;
+}
+export interface Documentation {
+    library: string;
+    source: 'context7';
+    content: string;
+    examples: string[];
+}
+export interface CodeExample {
+    source: 'exa' | 'github';
+    language: string;
+    code: string;
+    description: string;
+}
+export interface WebResult {
+    source: 'gemini' | 'brave-search' | 'firecrawl';
+    title: string;
+    url: string;
+    content: string;
+}
+export interface Architecture {
+    components: Component[];
+    relations: Relation[];
+    invariants: string[];
+    operations: Operation[];
+    events: EventType[];
+}
+export interface Component {
+    id: string;
+    name: string;
+    type: 'core' | 'service' | 'adapter' | 'util';
+    description: string;
+    dependencies: string[];
+}
+export interface Relation {
+    from: string;
+    to: string;
+    type: 'uses' | 'extends' | 'implements' | 'triggers';
+}
+export interface Operation {
+    id: string;
+    name: string;
+    description: string;
+    inputs: Parameter[];
+    outputs: Parameter[];
+    complexity: number;
+}
+export interface Parameter {
+    name: string;
+    type: string;
+    required: boolean;
+}
+export interface EventType {
+    name: string;
+    payload: Record<string, string>;
+}
+export interface GeneratedCode {
+    files: CodeFile[];
+    language: 'typescript' | 'python' | 'rust';
+    framework?: string;
+    tests: CodeFile[];
+}
+export interface CodeFile {
+    path: string;
+    content: string;
+    description: string;
+}
+export interface Visual {
+    type: 'architecture' | 'concept' | 'flow' | 'logo';
+    prompt: string;
+    path: string;
+}
+export interface KnowledgeEntity {
+    name: string;
+    type: string;
+    observations: string[];
+}
+export interface KnowledgeRelation {
+    from: string;
+    to: string;
+    relationType: string;
+}
+export type PipelineStage = 'research' | 'design' | 'generate' | 'visualize' | 'persist' | 'publish';
+export interface PipelineResult<T> {
+    stage: PipelineStage;
+    success: boolean;
+    data?: T;
+    error?: string;
+    duration: number;
+    mcpsUsed: MCPServerName[];
+}
+export interface PipelineConfig {
+    stages: PipelineStage[];
+    parallel: boolean;
+    verbose: boolean;
+    dryRun: boolean;
+}

package/dist/src/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Genesis - System Creator Types
+ *
+ * Core type definitions for MCP orchestration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/world-model/decoder.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Genesis 6.0 - Latent State Decoder
+ *
+ * Decodes latent states back to interpretable representations.
+ *
+ * Capabilities:
+ * - Decode to text descriptions
+ * - Decode to structured state
+ * - Decode to feature maps
+ * - Interpolate between states
+ *
+ * The decoder is the inverse of the encoder, allowing the system
+ * to generate human-readable outputs from internal representations.
+ *
+ * Architecture:
+ * - Modality-specific decoders
+ * - Feature extraction
+ * - Narrative generation
+ *
+ * References:
+ * - VAE Decoders (Kingma & Welling, 2014)
+ * - VQ-VAE (van den Oord et al., 2017)
+ *
+ * Usage:
+ * ```typescript
+ * import { createLatentDecoder } from './world-model/decoder.js';
+ *
+ * const decoder = createLatentDecoder();
+ *
+ * // Decode to text
+ * const description = decoder.decodeToText(latentState);
+ *
+ * // Decode to structured state
+ * const state = decoder.decodeToState(latentState);
+ *
+ * // Interpolate between states
+ * const interpolated = decoder.interpolate(stateA, stateB, 0.5);
+ * ```
+ */
+import { Modality, LatentState, LatentFeature } from './types.js';
+export interface DecodedOutput {
+    id: string;
+    sourceState: string;
+    modality: Modality;
+    output: unknown;
+    confidence: number;
+    timestamp: Date;
+}
+export interface TextDecoding extends DecodedOutput {
+    modality: 'text';
+    output: string;
+    keywords: string[];
+    sentiment: number;
+}
+export interface StateDecoding extends DecodedOutput {
+    modality: 'state';
+    output: Record<string, unknown>;
+    numericFields: string[];
+    categoricalFields: string[];
+}
+export interface FeatureDecoding extends DecodedOutput {
+    modality: 'state';
+    output: LatentFeature[];
+    topActivations: number[];
+}
+export interface DecoderConfig {
+    outputDim: number;
+    vocabularySize: number;
+    maxTextLength: number;
+    featureThreshold: number;
+    interpolationSteps: number;
+}
+export declare const DEFAULT_DECODER_CONFIG: DecoderConfig;
+export type DecoderEventType = 'decoded_text' | 'decoded_state' | 'decoded_features' | 'interpolated' | 'error';
+export type DecoderEventHandler = (event: {
+    type: DecoderEventType;
+    data?: unknown;
+}) => void;
+export declare class LatentDecoder {
+    private config;
+    private eventHandlers;
+    private decodingCount;
+    private interpolationCount;
+    constructor(config?: Partial<DecoderConfig>);
+    /**
+     * Decode latent state to text description
+     */
+    decodeToText(state: LatentState): TextDecoding;
+    /**
+     * Extract keywords from vector
+     */
+    private vectorToKeywords;
+    /**
+     * Calculate sentiment from vector
+     */
+    private calculateSentiment;
+    /**
+     * Generate natural language description
+     */
+    private generateDescription;
+    /**
+     * Decode latent state to structured state
+     */
+    decodeToState(state: LatentState): StateDecoding;
+    /**
+     * Convert sigmoid value to range
+     */
+    private sigmoidToRange;
+    /**
+     * Decode to feature representation
+     */
+    decodeToFeatures(state: LatentState): FeatureDecoding;
+    /**
+     * Group related features
+     */
+    private groupFeatures;
+    /**
+     * Interpolate between two latent states
+     */
+    interpolate(stateA: LatentState, stateB: LatentState, t: number): LatentState;
+    /**
+     * Generate interpolation sequence
+     */
+    interpolateSequence(stateA: LatentState, stateB: LatentState, steps?: number): LatentState[];
+    /**
+     * Spherical interpolation (SLERP) for better interpolation on unit sphere
+     */
+    slerp(stateA: LatentState, stateB: LatentState, t: number): LatentState;
+    /**
+     * Get indices of dominant (highest absolute) values
+     */
+    private getDominantIndices;
+    /**
+     * Normalize vector
+     */
+    private normalize;
+    /**
+     * Compare two latent states
+     */
+    compare(stateA: LatentState, stateB: LatentState): {
+        similarity: number;
+        distance: number;
+        divergentDimensions: number[];
+        commonFeatures: string[];
+    };
+    /**
+     * Analyze latent state structure
+     */
+    analyze(state: LatentState): {
+        sparsity: number;
+        dominantRegion: string;
+        clusterAssignment: number;
+        anomalyScore: number;
+    };
+    on(handler: DecoderEventHandler): () => void;
+    private emit;
+    stats(): {
+        decodingCount: number;
+        interpolationCount: number;
+    };
+    getConfig(): DecoderConfig;
+}
+export declare function createLatentDecoder(config?: Partial<DecoderConfig>): LatentDecoder;