@thing-king

The @thing-king ecosystem is a modular framework for designing, managing, and executing data processing units called Things. It emphasizes flexibility, type safety, and dynamic execution across distributed systems.

What follows is a detailed breakdown of each repository...

Work

Frontend

Extract and Finalize Components

Extract components from thingking into components, and finalize the framework.

Formalize Thing Web

Serve Things with components.

Create Thing Store

Create a Thing Store via reusable components, hosted in it's own ThingStoreHost context.

Backend

Solve DNS Subdomains

When ThingContexts are created, they should be near instantly accessible via a custom subdomain.

Create starting ThingContexts

Create initial ThingContexts for use as default libraries

• CDP
• Browser
• Discord
• Request

Code Node Tree Solution

Find an elegant way to convert code to a pseudo node tree, and back.

Finalize Default ThingContext

Finalize all default things allowed in syntax. (e.g., Math#add, Statement#if, Date#now)

@thing-king/metaform

The core framework for creating and managing Things.

• Purpose: Defines and runs modular functions and type definitions.
• Key Features:
  • Thing Definition: Handles both functional logic (handlers) and custom type definitions.
  • ThingContext: Manages and executes Things in isolated environments.
  • Runtime Type Safety: Ensures inputs/outputs conform to defined types.
  • Dynamic Functionality: Allows real-time updates and management of Things.
  • WebSocket Integration: Enables distributed execution of Things across different services via WebSocket communication.

@thing-king/thingking

A Next.js web application that allows users to create, manage, and execute Things within the @thing-king ecosystem. It supports branded environments for organizations, enabling user access management, and provides multiple ways to interact with Things through both code and visual tools.

Purpose

• Provides a platform for creating and managing Things in real time.
• Enables organizations to create branded environments and manage user access.

Key Features

• Branding for Organizations: Create custom environments with branded interfaces for managing Things and user access.

• Thing Creation Tools:

  • IDE (Monaco Editor): Write and edit Things using a code-based editor.
  • Visual Scripting (React Flow): Create Things using a graphical flow-based interface for easier visual development.

• Ways to Interact with Things:

  • Chat: Interact with Things through a text-based chat interface.
  • Console: A terminal for executing Things in a command-line format.
  • Editor: Modify and create Things directly using the Monaco-based editor.
  • Feed: View a simplified, stream-like display of the latest interactions or messages.
  • Graph: Use visual scripting to design and connect Things with React Flow.
  • Live: Share live video streams for collaboration.
  • Logs: View live logs from Metaform to monitor system activities.
  • Trace: Debug execution by viewing the Metaform execution trace.

@thing-king/components

A modular library of reusable UI components built specifically for the @thing-king ecosystem. This library stands out due to its reliance on custom node tags for defining layouts, offering a streamlined and declarative approach to building user interfaces.

Purpose

• Provides a flexible, reusable set of components tailored for use within the @thing-king platform.
• Simplifies layout management through custom-defined tags, removing the need for complex class-based layouts or CSS attributes.

Key Features

• Custom Node Tags for Layout:

  • Instead of traditional class names or attributes, components rely on custom node tags to define structure and layout behavior, leading to a cleaner and more declarative development experience.
  • These custom tags encapsulate layout logic, making components more intuitive and ensuring uniformity across the platform.

• Theming Support:

  • Simple and Flexible: The library supports both predefined and custom themes, allowing developers to easily adapt the appearance to match branding or user preferences.
  • Minimalist Color Palette: The color palette is intentionally kept short and simple, focusing on a few core colors to maintain visual coherence while offering flexibility for customization.
  • Compact Sizing Variables: Sizing variables are also kept simple and minimal, ensuring easy and consistent spacing and scaling across components.
  • Custom Theming: Users can extend or override the default theme by defining their own color schemes and sizing rules, enabling full customization of the platform’s look and feel.

• Consistency and Reusability: Each component is designed for modularity, ensuring that elements can be reused across different parts of the @thing-king platform while maintaining a cohesive design system.

@thing-king/browser (Deprecated)

A deprecated browser automation library.

@thing-king/service

A generic Docker-based service designed for dynamic hosting of ThingContexts.

• Purpose: Hosts a ThingContext dynamically using Docker.
• Key Features:
  • THING_KING_CONTEXT_ID: The container accepts this environment variable to load and execute a specific ThingContext.
  • Google Cloud Auto Run Integration: Designed for seamless deployment and scaling on Google Cloud’s Auto Run service.
  • Dynamic Deployment: Allows flexible, containerized execution of any ThingContext in a cloud environment.
  • Scalable: Can be scaled across cloud platforms for distributed execution of Things in different contexts.