@props-labs/mesh-os 0.1.7

package/dist/core/taxonomy.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Taxonomy and classification models for MeshOS.
+ */
+import { z } from 'zod';
+/**
+ * Primary data type classification.
+ */
+export declare enum DataType {
+    ACTIVITY = "activity",// Agent & system actions
+    KNOWLEDGE = "knowledge",// Structured information
+    DECISION = "decision",// Strategic & operational choices
+    MEDIA = "media"
+}
+/**
+ * Subtypes for activity data.
+ */
+export declare enum ActivitySubtype {
+    AGENT_CONVERSATION = "agent-conversation",// Structured record of agent interactions
+    AGENT_LOG = "agent-log",// System-level agent actions
+    EXECUTION_LOG = "execution-log",// Action execution records
+    EVENT_LOG = "event-log",// System events and notifications
+    WORKFLOW_STEP = "workflow-step"
+}
+/**
+ * Subtypes for knowledge data.
+ */
+export declare enum KnowledgeSubtype {
+    COMPANY_METADATA = "company-metadata",// Core company information
+    COMPANY_MISSION = "company-mission",// Company's core purpose
+    COMPANY_VISION = "company-vision",// Strategic direction
+    AGENT_MISSION = "agent-mission",// Agent's specific role
+    AGENT_VISION = "agent-vision",// Agent's long-term goals
+    RESEARCH_REPORT = "research-report",// Analysis and findings
+    FAQ_ENTRY = "faq-entry",// Common QA entries
+    DATASET = "dataset",// Structured data collections
+    OKRS = "okrs"
+}
+/**
+ * Subtypes for decision data.
+ */
+export declare enum DecisionSubtype {
+    POLICY_UPDATE = "policy-update",// Policy changes
+    COMPANY_STRATEGY = "company-strategy",// Strategic initiatives
+    SYSTEM_DECISION = "system-decision",// System-level choices
+    USER_FEEDBACK_DECISION = "user-feedback-decision"
+}
+/**
+ * Subtypes for media data.
+ */
+export declare enum MediaSubtype {
+    IMAGE = "image",// Image files
+    VIDEO = "video",// Video content
+    TEXT_DOCUMENT = "text-document",// Text-based documents
+    GENERATED_CONTENT = "generated-content"
+}
+/**
+ * Standard relationship types for memory edges.
+ */
+export declare enum EdgeType {
+    RELATED_TO = "related_to",// Generic association
+    VERSION_OF = "version_of",// Updated version
+    FOLLOWS_UP = "follows_up",// Sequential relationship
+    CONTRADICTS = "contradicts",// Conflicting information
+    DEPENDS_ON = "depends_on",// Prerequisite relationship
+    SUMMARIZES = "summarizes",// Condensed version
+    INFLUENCES = "influences"
+}
+/**
+ * Relevance classification tags.
+ */
+export declare enum RelevanceTag {
+    HIGH_RELEVANCE = "high-relevance",
+    TIME_SENSITIVE = "time-sensitive",
+    ARCHIVAL = "archival",
+    VOLATILE = "volatile",
+    EXPERIMENTAL = "experimental"
+}
+/**
+ * Version history entry.
+ */
+export interface VersionInfo {
+    version: number;
+    modifiedAt: Date;
+    modifiedBy: string;
+}
+/**
+ * Standardized metadata structure for memories.
+ */
+export declare const memoryMetadataSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    type: z.ZodNativeEnum<typeof DataType>;
+    subtype: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    relevance: z.ZodOptional<z.ZodNativeEnum<typeof RelevanceTag>>;
+    validUntil: z.ZodOptional<z.ZodDate>;
+    version: z.ZodDefault<z.ZodNumber>;
+    history: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        version: z.ZodNumber;
+        modifiedAt: z.ZodDate;
+        modifiedBy: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        version: number;
+        modifiedAt: Date;
+        modifiedBy: string;
+    }, {
+        version: number;
+        modifiedAt: Date;
+        modifiedBy: string;
+    }>, "many">>;
+    previousVersion: z.ZodOptional<z.ZodString>;
+    additional: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: DataType;
+    subtype: string;
+    tags: string[];
+    version: number;
+    history: {
+        version: number;
+        modifiedAt: Date;
+        modifiedBy: string;
+    }[];
+    additional: Record<string, unknown>;
+    relevance?: RelevanceTag | undefined;
+    validUntil?: Date | undefined;
+    previousVersion?: string | undefined;
+}, {
+    type: DataType;
+    subtype: string;
+    tags?: string[] | undefined;
+    relevance?: RelevanceTag | undefined;
+    validUntil?: Date | undefined;
+    version?: number | undefined;
+    history?: {
+        version: number;
+        modifiedAt: Date;
+        modifiedBy: string;
+    }[] | undefined;
+    previousVersion?: string | undefined;
+    additional?: Record<string, unknown> | undefined;
+}>, {
+    type: DataType;
+    subtype: string;
+    tags: string[];
+    version: number;
+    history: {
+        version: number;
+        modifiedAt: Date;
+        modifiedBy: string;
+    }[];
+    additional: Record<string, unknown>;
+    relevance?: RelevanceTag | undefined;
+    validUntil?: Date | undefined;
+    previousVersion?: string | undefined;
+}, {
+    type: DataType;
+    subtype: string;
+    tags?: string[] | undefined;
+    relevance?: RelevanceTag | undefined;
+    validUntil?: Date | undefined;
+    version?: number | undefined;
+    history?: {
+        version: number;
+        modifiedAt: Date;
+        modifiedBy: string;
+    }[] | undefined;
+    previousVersion?: string | undefined;
+    additional?: Record<string, unknown> | undefined;
+}>, {
+    type: DataType;
+    subtype: string;
+    tags: string[];
+    version: number;
+    history: {
+        version: number;
+        modifiedAt: Date;
+        modifiedBy: string;
+    }[];
+    additional: Record<string, unknown>;
+    relevance?: RelevanceTag | undefined;
+    validUntil?: Date | undefined;
+    previousVersion?: string | undefined;
+}, {
+    type: DataType;
+    subtype: string;
+    tags?: string[] | undefined;
+    relevance?: RelevanceTag | undefined;
+    validUntil?: Date | undefined;
+    version?: number | undefined;
+    history?: {
+        version: number;
+        modifiedAt: Date;
+        modifiedBy: string;
+    }[] | undefined;
+    previousVersion?: string | undefined;
+    additional?: Record<string, unknown> | undefined;
+}>;
+export type MemoryMetadata = z.infer<typeof memoryMetadataSchema>;
+/**
+ * Metadata structure for memory edges.
+ */
+export declare const edgeMetadataSchema: z.ZodObject<{
+    relationship: z.ZodNativeEnum<typeof EdgeType>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    validUntil: z.ZodOptional<z.ZodDate>;
+    bidirectional: z.ZodDefault<z.ZodBoolean>;
+    additional: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    additional: Record<string, unknown>;
+    relationship: EdgeType;
+    weight: number;
+    bidirectional: boolean;
+    validUntil?: Date | undefined;
+}, {
+    relationship: EdgeType;
+    validUntil?: Date | undefined;
+    additional?: Record<string, unknown> | undefined;
+    weight?: number | undefined;
+    bidirectional?: boolean | undefined;
+}>;
+export type EdgeMetadata = z.infer<typeof edgeMetadataSchema>;

package/dist/core/taxonomy.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.edgeMetadataSchema = exports.memoryMetadataSchema = exports.RelevanceTag = exports.EdgeType = exports.MediaSubtype = exports.DecisionSubtype = exports.KnowledgeSubtype = exports.ActivitySubtype = exports.DataType = void 0;
+/**
+ * Taxonomy and classification models for MeshOS.
+ */
+const zod_1 = require("zod");
+/**
+ * Primary data type classification.
+ */
+var DataType;
+(function (DataType) {
+    DataType["ACTIVITY"] = "activity";
+    DataType["KNOWLEDGE"] = "knowledge";
+    DataType["DECISION"] = "decision";
+    DataType["MEDIA"] = "media";
+})(DataType || (exports.DataType = DataType = {}));
+/**
+ * Subtypes for activity data.
+ */
+var ActivitySubtype;
+(function (ActivitySubtype) {
+    ActivitySubtype["AGENT_CONVERSATION"] = "agent-conversation";
+    ActivitySubtype["AGENT_LOG"] = "agent-log";
+    ActivitySubtype["EXECUTION_LOG"] = "execution-log";
+    ActivitySubtype["EVENT_LOG"] = "event-log";
+    ActivitySubtype["WORKFLOW_STEP"] = "workflow-step";
+})(ActivitySubtype || (exports.ActivitySubtype = ActivitySubtype = {}));
+/**
+ * Subtypes for knowledge data.
+ */
+var KnowledgeSubtype;
+(function (KnowledgeSubtype) {
+    KnowledgeSubtype["COMPANY_METADATA"] = "company-metadata";
+    KnowledgeSubtype["COMPANY_MISSION"] = "company-mission";
+    KnowledgeSubtype["COMPANY_VISION"] = "company-vision";
+    KnowledgeSubtype["AGENT_MISSION"] = "agent-mission";
+    KnowledgeSubtype["AGENT_VISION"] = "agent-vision";
+    KnowledgeSubtype["RESEARCH_REPORT"] = "research-report";
+    KnowledgeSubtype["FAQ_ENTRY"] = "faq-entry";
+    KnowledgeSubtype["DATASET"] = "dataset";
+    KnowledgeSubtype["OKRS"] = "okrs";
+})(KnowledgeSubtype || (exports.KnowledgeSubtype = KnowledgeSubtype = {}));
+/**
+ * Subtypes for decision data.
+ */
+var DecisionSubtype;
+(function (DecisionSubtype) {
+    DecisionSubtype["POLICY_UPDATE"] = "policy-update";
+    DecisionSubtype["COMPANY_STRATEGY"] = "company-strategy";
+    DecisionSubtype["SYSTEM_DECISION"] = "system-decision";
+    DecisionSubtype["USER_FEEDBACK_DECISION"] = "user-feedback-decision";
+})(DecisionSubtype || (exports.DecisionSubtype = DecisionSubtype = {}));
+/**
+ * Subtypes for media data.
+ */
+var MediaSubtype;
+(function (MediaSubtype) {
+    MediaSubtype["IMAGE"] = "image";
+    MediaSubtype["VIDEO"] = "video";
+    MediaSubtype["TEXT_DOCUMENT"] = "text-document";
+    MediaSubtype["GENERATED_CONTENT"] = "generated-content";
+})(MediaSubtype || (exports.MediaSubtype = MediaSubtype = {}));
+/**
+ * Standard relationship types for memory edges.
+ */
+var EdgeType;
+(function (EdgeType) {
+    EdgeType["RELATED_TO"] = "related_to";
+    EdgeType["VERSION_OF"] = "version_of";
+    EdgeType["FOLLOWS_UP"] = "follows_up";
+    EdgeType["CONTRADICTS"] = "contradicts";
+    EdgeType["DEPENDS_ON"] = "depends_on";
+    EdgeType["SUMMARIZES"] = "summarizes";
+    EdgeType["INFLUENCES"] = "influences";
+})(EdgeType || (exports.EdgeType = EdgeType = {}));
+/**
+ * Relevance classification tags.
+ */
+var RelevanceTag;
+(function (RelevanceTag) {
+    RelevanceTag["HIGH_RELEVANCE"] = "high-relevance";
+    RelevanceTag["TIME_SENSITIVE"] = "time-sensitive";
+    RelevanceTag["ARCHIVAL"] = "archival";
+    RelevanceTag["VOLATILE"] = "volatile";
+    RelevanceTag["EXPERIMENTAL"] = "experimental";
+})(RelevanceTag || (exports.RelevanceTag = RelevanceTag = {}));
+/**
+ * Standardized metadata structure for memories.
+ */
+exports.memoryMetadataSchema = zod_1.z.object({
+    type: zod_1.z.nativeEnum(DataType),
+    subtype: zod_1.z.string(),
+    tags: zod_1.z.array(zod_1.z.string()).default([]),
+    relevance: zod_1.z.nativeEnum(RelevanceTag).optional(),
+    validUntil: zod_1.z.date().optional(),
+    version: zod_1.z.number().default(1),
+    history: zod_1.z.array(zod_1.z.object({
+        version: zod_1.z.number(),
+        modifiedAt: zod_1.z.date(),
+        modifiedBy: zod_1.z.string(),
+    })).default([]),
+    previousVersion: zod_1.z.string().optional(),
+    additional: zod_1.z.record(zod_1.z.unknown()).default({}),
+}).refine((data) => {
+    // Validate subtype based on the primary type
+    const typeSubtypes = {
+        [DataType.ACTIVITY]: Object.values(ActivitySubtype),
+        [DataType.KNOWLEDGE]: Object.values(KnowledgeSubtype),
+        [DataType.DECISION]: Object.values(DecisionSubtype),
+        [DataType.MEDIA]: Object.values(MediaSubtype),
+    };
+    return typeSubtypes[data.type].includes(data.subtype);
+}, {
+    message: 'Invalid subtype for the given type',
+}).refine((data) => {
+    // Validate tag format
+    return data.tags.every(tag => tag === tag.toLowerCase() && !tag.includes(' '));
+}, {
+    message: 'Tags must be lowercase and use hyphens instead of spaces',
+});
+/**
+ * Metadata structure for memory edges.
+ */
+exports.edgeMetadataSchema = zod_1.z.object({
+    relationship: zod_1.z.nativeEnum(EdgeType),
+    weight: zod_1.z.number().min(0).max(1).default(1.0),
+    validUntil: zod_1.z.date().optional(),
+    bidirectional: zod_1.z.boolean().default(false),
+    additional: zod_1.z.record(zod_1.z.unknown()).default({}),
+});

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MeshOS - A lightweight multi-agent memory system with semantic search.
+ */
+export { Agent, Memory, MemoryEdge, MeshOS, GraphQLError, InvalidSlugError, type MeshOSConfig } from './core/client';
+export { DataType, ActivitySubtype, KnowledgeSubtype, DecisionSubtype, MediaSubtype, EdgeType, RelevanceTag, type VersionInfo, type MemoryMetadata, type EdgeMetadata, } from './core/taxonomy';
+export declare const VERSION = "0.1.6";

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * MeshOS - A lightweight multi-agent memory system with semantic search.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.RelevanceTag = exports.EdgeType = exports.MediaSubtype = exports.DecisionSubtype = exports.KnowledgeSubtype = exports.ActivitySubtype = exports.DataType = exports.InvalidSlugError = exports.GraphQLError = exports.MeshOS = void 0;
+var client_1 = require("./core/client");
+Object.defineProperty(exports, "MeshOS", { enumerable: true, get: function () { return client_1.MeshOS; } });
+Object.defineProperty(exports, "GraphQLError", { enumerable: true, get: function () { return client_1.GraphQLError; } });
+Object.defineProperty(exports, "InvalidSlugError", { enumerable: true, get: function () { return client_1.InvalidSlugError; } });
+var taxonomy_1 = require("./core/taxonomy");
+// Data types
+Object.defineProperty(exports, "DataType", { enumerable: true, get: function () { return taxonomy_1.DataType; } });
+Object.defineProperty(exports, "ActivitySubtype", { enumerable: true, get: function () { return taxonomy_1.ActivitySubtype; } });
+Object.defineProperty(exports, "KnowledgeSubtype", { enumerable: true, get: function () { return taxonomy_1.KnowledgeSubtype; } });
+Object.defineProperty(exports, "DecisionSubtype", { enumerable: true, get: function () { return taxonomy_1.DecisionSubtype; } });
+Object.defineProperty(exports, "MediaSubtype", { enumerable: true, get: function () { return taxonomy_1.MediaSubtype; } });
+Object.defineProperty(exports, "EdgeType", { enumerable: true, get: function () { return taxonomy_1.EdgeType; } });
+Object.defineProperty(exports, "RelevanceTag", { enumerable: true, get: function () { return taxonomy_1.RelevanceTag; } });
+exports.VERSION = '0.1.6';

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const program = new commander_1.Command();
+program
+    .name('mesh-os')
+    .description('CLI to manage MeshOS Docker setup and examples')
+    .version('0.1.0');
+program
+    .command('init')
+    .description('Initialize a new MeshOS project')
+    .argument('<project-name>', 'Name of the project')
+    .action(async (projectName) => {
+    const targetDir = path.join(process.cwd(), projectName);
+    if (fs.existsSync(targetDir)) {
+        console.error(chalk_1.default.red(`Error: Directory ${projectName} already exists`));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.blue(`Creating new project: ${projectName}`));
+    try {
+        // Create project directory
+        fs.mkdirSync(targetDir);
+        // Copy templates
+        const templatesDir = path.join(__dirname, 'templates');
+        await fs.copy(path.join(templatesDir, 'docker-compose.yml'), path.join(targetDir, 'docker-compose.yml'));
+        await fs.copy(path.join(templatesDir, 'hasura'), path.join(targetDir, 'hasura'));
+        // Create examples directory
+        const examplesDir = path.join(targetDir, 'examples');
+        fs.mkdirSync(examplesDir);
+        await fs.copy(path.join(templatesDir, 'examples'), examplesDir);
+        console.log(chalk_1.default.green('✓ Project files created'));
+        console.log(chalk_1.default.blue('\nNext steps:'));
+        console.log(`1. cd ${projectName}`);
+        console.log('2. mesh-os up');
+        console.log('3. Set your OPENAI_API_KEY in .env');
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Error creating project:'), error);
+        process.exit(1);
+    }
+});
+program
+    .command('up')
+    .description('Start MeshOS services')
+    .action(async () => {
+    if (!fs.existsSync('docker-compose.yml')) {
+        console.error(chalk_1.default.red('Error: docker-compose.yml not found. Are you in a MeshOS project directory?'));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.blue('Starting MeshOS services...'));
+    try {
+        // Stop any existing containers and remove volumes
+        await runCommand('docker', ['compose', 'down', '-v']);
+        // Start services
+        const up = (0, child_process_1.spawn)('docker', ['compose', 'up', '-d'], { stdio: 'inherit' });
+        up.on('close', (code) => {
+            if (code === 0) {
+                console.log(chalk_1.default.green('\n✓ Services started successfully!'));
+                console.log(chalk_1.default.blue('\nServices available at:'));
+                console.log('• GraphQL API: http://localhost:8080/v1/graphql');
+                console.log('• Hasura Console: http://localhost:8080/console');
+            }
+            else {
+                console.error(chalk_1.default.red('\nError starting services'));
+                process.exit(1);
+            }
+        });
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Error:'), error);
+        process.exit(1);
+    }
+});
+program
+    .command('down')
+    .description('Stop MeshOS services')
+    .action(async () => {
+    if (!fs.existsSync('docker-compose.yml')) {
+        console.error(chalk_1.default.red('Error: docker-compose.yml not found. Are you in a MeshOS project directory?'));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.blue('Stopping MeshOS services...'));
+    try {
+        await runCommand('docker', ['compose', 'down']);
+        console.log(chalk_1.default.green('✓ Services stopped successfully'));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Error:'), error);
+        process.exit(1);
+    }
+});
+async function runCommand(command, args) {
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(command, args, { stdio: 'inherit' });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Command failed with code ${code}`));
+            }
+        });
+    });
+}
+program.parse();

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@props-labs/mesh-os",
+  "version": "0.1.7",
+  "description": "MeshOS - A memory system for AI agents",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "mesh-os": "./dist/main.js"
+  },
+  "files": [
+    "dist",
+    "src/templates"
+  ],
+  "keywords": [
+    "ai",
+    "memory",
+    "agents",
+    "hasura",
+    "pgvector",
+    "openai"
+  ],
+  "author": "Props Labs",
+  "license": "MIT",
+  "dependencies": {
+    "boxen": "^7.1.1",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "dotenv": "^16.3.1",
+    "fs-extra": "^11.2.0",
+    "openai": "^4.28.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.10.5",
+    "@typescript-eslint/eslint-plugin": "^6.15.0",
+    "@typescript-eslint/parser": "^6.15.0",
+    "eslint": "^8.56.0",
+    "vitest": "^1.2.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "pnpm@9.15.4+sha512.b2dc20e2fc72b3e18848459b37359a32064663e5627a51e4c74b2c29dd8e8e0491483c3abb40789cfd578bf362fb6ba8261b05f0387d76792ed6e23ea3b1b6a0",
+  "scripts": {
+    "build": "tsc",
+    "start": "ts-node src/main.ts",
+    "lint": "eslint . --ext .ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}

package/src/templates/.env.example

@@ -0,0 +1,18 @@
+# PostgreSQL Configuration
+POSTGRES_PASSWORD=mysecretpassword
+POSTGRES_DB=mesh_os
+POSTGRES_PORT=5432
+
+# Hasura Configuration
+HASURA_URL=http://localhost:8080/v1/graphql
+HASURA_ADMIN_SECRET=meshos
+HASURA_PORT=8080
+HASURA_ENABLE_CONSOLE=true
+
+# OpenAI Configuration (Required)
+# Get your API key at: https://platform.openai.com/api-keys
+OPENAI_API_KEY=your-api-key-here
+
+# Vector Search Configuration
+SIMILARITY_THRESHOLD=0.7
+MAX_RESULTS=10 

package/src/templates/docker-compose.yml

@@ -0,0 +1,55 @@
+services:
+  postgres:
+    image: pgvector/pgvector:pg15
+    container_name: mesh_os_postgres
+    environment:
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-mysecretpassword}
+      POSTGRES_DB: mesh_os
+      POSTGRES_INITDB_ARGS: "--data-checksums"
+    command: >
+      bash -c "
+        echo 'Creating extensions...' &&
+        docker-entrypoint.sh postgres &
+        until pg_isready -U postgres; do sleep 1; done &&
+        psql -U postgres -d mesh_os -c 'CREATE EXTENSION IF NOT EXISTS \"uuid-ossp\"; CREATE EXTENSION IF NOT EXISTS vector;' &&
+        wait
+      "
+    ports:
+      - "${POSTGRES_PORT:-5432}:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+      start_period: 30s
+    restart: unless-stopped
+
+  hasura:
+    image: hasura/graphql-engine:v2.33.4
+    container_name: mesh_os_hasura
+    ports:
+      - "${HASURA_PORT:-8080}:8080"
+    depends_on:
+      postgres:
+        condition: service_healthy
+    environment:
+      HASURA_GRAPHQL_DATABASE_URL: postgres://postgres:${POSTGRES_PASSWORD:-mysecretpassword}@postgres:5432/mesh_os
+      HASURA_GRAPHQL_ADMIN_SECRET: ${HASURA_ADMIN_SECRET:-meshos}
+      HASURA_GRAPHQL_ENABLE_CONSOLE: ${HASURA_ENABLE_CONSOLE:-true}
+      HASURA_GRAPHQL_CONSOLE_ASSETS_DIR: /srv/console-assets
+      HASURA_GRAPHQL_DEV_MODE: "true"
+      HASURA_GRAPHQL_ENABLED_LOG_TYPES: startup, http-log, webhook-log, websocket-log, query-log
+      HASURA_GRAPHQL_CORS_DOMAIN: "*"
+      HASURA_GRAPHQL_METADATA_DATABASE_URL: postgres://postgres:${POSTGRES_PASSWORD:-mysecretpassword}@postgres:5432/mesh_os
+    healthcheck:
+      test: ["CMD", "wget", "--spider", "http://localhost:8080/healthz"]
+      interval: 15s
+      timeout: 10s
+      retries: 10
+      start_period: 40s
+    restart: unless-stopped
+
+volumes:
+  postgres_data: 

package/src/templates/hasura/config.yaml

@@ -0,0 +1,9 @@
+version: 3
+endpoint: http://hasura:8080
+admin_secret: meshos
+metadata_directory: metadata
+migrations_directory: migrations
+seeds_directory: seeds
+actions:
+  kind: synchronous
+  handler_webhook_baseurl: http://localhost:3000 

package/src/templates/hasura/metadata/config.yaml

@@ -0,0 +1 @@
+