@fnet/cli 0.2.0

package/readme.md

@@ -0,0 +1,251 @@
+# @fnet/cli: Flownet CLI
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/fnetai/cli/main/assets/flownet-logo.png" alt="Flownet Logo" width="200"/>
+</p>
+
+<p align="center">
+  <b>Focus on functional code, let Flownet handle the rest</b>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@fnet/cli"><img src="https://img.shields.io/npm/v/@fnet/cli.svg" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/@fnet/cli"><img src="https://img.shields.io/npm/dm/@fnet/cli.svg" alt="npm downloads"></a>
+  <a href="https://github.com/fnetai/cli/blob/main/LICENSE"><img src="https://img.shields.io/github/license/fnetai/cli.svg" alt="license"></a>
+</p>
+
+## Overview
+
+Flownet is a revolutionary development framework that isolates non-functional components, allowing developers to focus solely on functional code. The `@fnet/cli` package provides command-line tools to create, build, and manage Flownet projects.
+
+### Key Features
+
+- **Language Agnostic**: Support for multiple programming languages (JavaScript, Python) in the same project
+- **Runtime Flexibility**: Choose the best runtime for each task (Node.js, Python, Bun)
+- **Unified Interface**: Consistent commands across different project types
+- **Tag-Based Configuration**: Powerful conditional configuration with `--ftag` parameter
+- **Isolated Workspace**: All build artifacts and dependencies are kept in `.workspace` directory
+- **Binary System**: Compile, install, and manage CLI tools with the integrated binary system
+- **Project File Configuration**: Configure CLI features directly in your project files
+- **Fast Startup**: Pre-compiled binaries start much faster than interpreted scripts
+
+## Installation
+
+```bash
+# Using npm
+npm install -g @fnet/cli
+
+# Using yarn
+yarn global add @fnet/cli
+
+# Using bun
+bun install -g @fnet/cli
+```
+
+## Quick Start
+
+### Create a New Project
+
+```bash
+# Create a Node.js project
+fnode create my-node-project
+
+# Create a Python project
+fnode create my-python-project --runtime python
+
+# Create a Bun project
+fnode create my-bun-project --runtime bun
+
+# Create a workflow project
+fnet create my-workflow-project
+```
+
+### Build and Run
+
+```bash
+# Build the project
+frun build
+
+# Run the project
+fnode cli
+
+# Execute a command group from project file
+frun <command-group> [--ftag <tags>]
+```
+
+### Compile and Install
+
+```bash
+# Compile a JavaScript file to a binary
+fbin compile script.js -o my-tool
+
+# Install a compiled binary
+fbin install ./my-tool --name awesome-tool
+
+# Install a CLI-enabled project
+cd my-project
+fnode install --yes
+
+# Or use npm scripts in your project
+npm run compile
+npm run install-bin
+
+# List installed binaries
+fbin list
+
+# Uninstall a binary
+fbin uninstall awesome-tool --yes
+```
+
+## Project Types
+
+Flownet supports two main project types:
+
+### fnode Project
+
+An **fnode project** (Flow Node Project) is a classic/node-style project that focuses on creating reusable components or standalone applications. These projects:
+
+- Use `fnode.yaml` as their configuration file
+- Typically contain a single code file in the `src` directory
+- Can be built with different runtimes (Node.js, Python, Bun)
+- Support multiple programming languages simultaneously
+
+### fnet Project
+
+An **fnet project** (Flow Project) is a workflow-oriented project that focuses on orchestrating multiple components. These projects:
+
+- Use `fnet.yaml` as their configuration file
+- Define workflows that connect multiple components
+- Support complex data flows and transformations
+
+## CLI Tools
+
+Flownet provides four main CLI tools:
+
+- **`fnode`**: For Node/classic projects (uses `fnode.yaml`)
+- **`fnet`**: For Workflow projects (uses `fnet.yaml`)
+- **`frun`**: Unified interface that works with both project types (auto-detects project file)
+- **`fbin`**: Binary management system for installing, compiling, and managing CLI tools
+
+## Multi-Language Support
+
+Flownet supports multiple programming languages simultaneously within the same project:
+
+```text
+my-project/
+├── src/
+│   ├── index.js          # JavaScript implementation (used by both Node.js and Bun)
+│   └── index.py          # Python implementation
+├── fnode.yaml            # Project configuration file
+└── .workspace/           # Build infrastructure (managed by CLI)
+```
+
+This allows you to:
+
+- Write your core logic once and migrate it to other languages as needed
+- Choose the best language for each specific use case
+- Use JavaScript with Node.js for quick development, Python for data processing, and JavaScript with Bun for improved performance
+
+## Tag-Based Configuration
+
+Both CLI tools support the `--ftag` parameter for powerful conditional configuration:
+
+```bash
+frun build --ftag dev --ftag local
+```
+
+This activates sections in your project file marked with `t::dev::` or `t::local::` tags:
+
+```yaml
+# Base configuration
+name: my-project
+
+# Development environment configuration
+t::dev::database:
+  url: "mongodb://localhost:27017"
+
+# Production environment configuration
+t::prod::database:
+  url: "mongodb://production-server:27017"
+```
+
+## Binary System
+
+Flownet includes a powerful binary system that makes it easy to create, distribute, and manage CLI tools:
+
+### Binary System Features
+
+- **Fast Startup**: Pre-compiled binaries start much faster than interpreted scripts
+- **Cross-Platform Support**: Works on macOS, Linux, and Windows
+- **Multiple Shell Support**: Compatible with Bash, Zsh, Fish, PowerShell, and more
+- **Version Management**: Keeps track of binary versions and metadata
+- **Project Integration**: Easily compile and install CLI-enabled projects
+- **Automation Support**: All commands support the `--yes` flag for scripting
+
+### Setup and Usage
+
+```bash
+# Initialize the bin system
+fbin setup
+
+# Add bin directory to PATH
+fbin path
+
+# Compile a JavaScript file to a binary
+fbin compile script.js -o my-tool
+
+# Install a binary to the bin directory
+fbin install ./my-tool --name awesome-tool
+
+# List installed binaries
+fbin list
+
+# Uninstall a binary
+fbin uninstall awesome-tool
+```
+
+### Project Integration
+
+The binary system integrates seamlessly with Flownet projects:
+
+```bash
+# Compile and install a CLI-enabled fnode project
+fnode compile
+fnode install
+
+# Compile and install a CLI-enabled fnet project
+fnet compile
+fnet install
+
+# Using npm scripts in your project
+npm run compile
+npm run install-bin
+```
+
+This makes it easy to distribute your Flownet projects as standalone CLI tools.
+
+### CLI Configuration in Project Files
+
+You can configure CLI features directly in your project files:
+
+```yaml
+# In fnode.yaml or fnet.yaml
+name: my-project
+
+features:
+  # For fnode projects
+  s::runtime.type: node  # or python, bun
+
+  # CLI configuration
+  cli:
+    enabled: true
+    bin: custom-bin-name  # Name of the binary (defaults to project name)
+    installable: true     # Enable 'fnode install' or 'fnet install' command
+```
+
+This configuration will:
+
+1. Enable CLI functionality for your project
+2. Set the binary name to `custom-bin-name`
+3. Add `compile` and `install-bin` scripts to your package.json
+4. Allow you to install the binary with `fnode install` or `npm run install-bin`

package/template/fnet/core/assert.js

@@ -0,0 +1,6 @@
+export default (args) => {
+    const [condition, message] = Array.isArray(args) ? args : [args];
+    if (!condition) {
+        throw new Error(message || "Assertion failed");
+    }
+}

package/template/fnet/core/message.js

@@ -0,0 +1,3 @@
+export default {
+    USE_CONSTRUCTOR: "Please call it as constructor!"
+}

package/template/fnet/core/object.js

@@ -0,0 +1,47 @@
+import getValue from "get-value";
+import setValue from "set-value";
+import print from "./print.js";
+
+export default class Object {
+  #property;
+  #context;
+  #module;
+
+  constructor(context) {
+
+    this.#property = {}
+    this.#module = {};
+    this.#context = context;
+
+    this.get = (path, options) => {
+      return getValue(this.#property, path, options);
+    }
+
+    this.set = (path, value, options) => {
+      return setValue(this.#property, path, value, options);
+    }
+
+    this.print = print;
+  }
+
+  get module() {
+    return this.#module;
+  }
+
+  getModule(path) {
+    return getValue(this.#module, path);
+  }
+
+  setModule(path, module) {
+    if (typeof module !== "function") throw new Error("Module must be a function");
+    return setValue(this.#module, path, module);
+  }
+
+  get getValue() {
+    return getValue;
+  }
+
+  get setValue() {
+    return setValue;
+  }
+}

package/template/fnet/core/print.js

@@ -0,0 +1 @@
+export default console.log;

package/template/fnet/core/sleep.js

@@ -0,0 +1,5 @@
+export default (delay) => {
+    return new Promise(function (resolve) {
+        setTimeout(resolve, delay);
+    });
+}

package/template/fnet/node/.gitignore.njk

@@ -0,0 +1,9 @@
+node_modules
+.DS_Store
+.fnet
+.out
+.package
+.vscode
+.output
+.npmrc
+.bin

package/template/fnet/node/build.js.njk

@@ -0,0 +1,153 @@
+#!/usr/bin/env bun
+/**
+ * Build script for Bun projects
+ * This script uses Bun's built-in bundler instead of Rollup
+ */
+
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import fs from 'node:fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+async function ensureDir(dir) {
+  try {
+    await mkdir(dir, { recursive: true });
+  } catch (err) {
+    if (err.code !== 'EEXIST') throw err;
+  }
+}
+
+async function buildOutput(name, config) {
+  console.log(`Building ${name}...`);
+
+  const outdir = config.outdir || join(__dirname, `dist/${name}`);
+  await ensureDir(outdir);
+
+  {% if atom.doc.features.app.enabled !== false %}
+  // Copy HTML file if it exists and this is an app build
+  if (name === 'app') {
+    try {
+      const htmlPath = './src/app/index.html';
+      if (fs.existsSync(htmlPath)) {
+        const htmlContent = await Bun.file(htmlPath).text();
+        await writeFile(join(outdir, 'index.html'), htmlContent);
+      }
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        console.warn('Warning: Could not copy HTML file:', err.message);
+      }
+    }
+  }
+  {% endif %}
+
+  const buildConfig = {
+    entrypoints: config.entrypoints || [`./src/${name}/index.js`],
+    outdir: outdir,
+    format: config.format || 'esm',
+    {% if atom.doc.features.runtime.target === 'bun' %}
+      target: "bun",
+    {% else %}
+      target: config.target || "browser",
+    {% endif %}
+    minify: config.minify !== undefined ? config.minify : false,
+    sourcemap: config.sourcemap || 'external',
+    splitting: true,
+    // Add environment variables to help with module resolution
+    define: {
+      'process.env.NODE_PATH': JSON.stringify('./node_modules')
+    },
+
+    plugins: [
+      ...(config.plugins || [])
+    ]
+  };
+
+  if(config.external) buildConfig.external = config.external;
+  if(config.packages) buildConfig.packages = config.packages;
+  if(config.banner) buildConfig.banner = config.banner;
+  if(config.footer) buildConfig.footer = config.footer;
+
+  // Build with Bun.build
+  const result = await Bun.build(buildConfig);
+
+  if (!result.success) {
+    console.error(`${name} build failed:`, result.logs);
+    process.exit(1);
+  }
+
+  return result;
+}
+
+async function main() {
+  try {
+    {% if atom.doc.features.project.format === 'esm' or atom.doc.features.project.format === undefined %}
+      // Build default ESM
+      await buildOutput('default', {
+        format: "esm",
+        target: "browser",
+        minify: false,
+        sourcemap: "external",
+        entrypoints: ["./src/default/index.js"],
+        outdir: "./dist/default/esm",
+        packages: "external"
+    });
+    {% endif %}
+
+    {% if atom.doc.features.project.format !== 'esm' %}
+      // Build default CJS
+      await buildOutput('defaultCjs', {
+        format: "cjs",
+        target: "browser",
+        minify: false,
+        sourcemap: "external",
+        entrypoints: ["./src/default/index.js"],
+        outdir: "./dist/default/cjs",
+        packages: "external"
+      });
+    {% endif %}
+
+    {% if atom.doc.features.cli.enabled !== false %}
+      // Build CLI if exists
+      if (fs.existsSync('./src/cli/index.js')) {
+        await buildOutput('cli', {
+          format: "esm",
+          target: "browser",
+          minify: false,
+          sourcemap: "external",
+          entrypoints: ["./src/cli/index.js"],
+          outdir: "{{ atom.doc.features.cli.dir | default('./dist/cli/esm') }}",
+          packages: "external",
+          banner: "#!/usr/bin/env bun"
+        });
+      } else {
+        console.log('CLI not found, skipping CLI build');
+      }
+    {% endif %}
+
+    {% if atom.doc.features.app.enabled !== false %}
+      // Build App if exists
+      if (fs.existsSync('./src/app/index.js')) {
+        await buildOutput('app', {
+          format: "esm",
+          target: "browser",
+          minify: false,
+          sourcemap: "external",
+          entrypoints: ["./src/app/index.js"],
+          outdir: "{{ atom.doc.features.app.dir | default('./dist/app/esm') }}",
+          packages: "bundle"
+        });
+      } else {
+        console.log('App not found, skipping App build');
+      }
+    {% endif %}
+
+    console.log('Build completed successfully!');
+  } catch (err) {
+    console.error('Build failed:', err);
+    process.exit(1);
+  }
+}
+
+main();

package/template/fnet/node/package.json.njk

@@ -0,0 +1,118 @@
+{
+  "name": "{{atom.doc['npm::name'] or atom.doc['name'] or atom['id']}}",
+  "version": "{{atom.doc['npm::version'] or '0.1.0'}}",
+  "files": [
+    "dist/*",
+    "fnet/input.yaml",
+    "fnet/output.yaml"
+  ],
+  {# "sideEffects": false, #}
+  {% if atom.doc['npm::author'] %}
+    "author": "{{atom.doc['npm::author'] | safe}}",
+  {% endif %}
+
+  {% if atom.doc['npm::description'] %}
+    "description": "{{atom.doc['npm::description'] | safe}}",
+  {% endif %}
+
+  {% if atom.doc.features.project.format ==='cjs' %}
+    {% if atom.doc.features.rollup_output.esm.enabled === true%}
+      "main": "dist/default/esm/index.js",
+      "type":"module",
+    {% else %}
+      "main": "dist/default/cjs/index.cjs",
+    {% endif %}
+
+    {% if atom.doc.features.dts_enabled ===true %}
+    "types": "dist/default/types/index.d.ts",
+    {% endif %}
+
+    "exports":{
+      ".":{
+        "import":"./dist/default/esm/index.js",
+        "require":"./dist/default/cjs/index.cjs"
+      }
+  },
+  {% else %}
+    "main": "dist/default/esm/index.js",
+    {% if atom.doc.features.dts_enabled ===true %}
+      "types": "dist/default/types/index.d.ts",
+    {% endif %}
+    "type":"module",
+    "exports":{
+      ".":{
+        "import":"./dist/default/esm/index.js",
+        "require":"./dist/default/cjs/index.cjs"
+      }
+  },
+  {% endif %}
+  "flownet": {
+    "type": "flow",
+  },
+  {% if atom.doc.repo.url %}
+    "repository": {
+        "type": "{{atom.doc.repo.type or 'git'}}",
+        "url": "{{atom.doc.repo.url}}"
+    },
+  {% endif %}
+  "license": "{{atom.doc.license or 'MIT'}}",
+  "scripts": {
+    {% if atom.doc.features.runtime.type === 'bun' %}
+      "build": "bun ./build.js",
+      "build:dev": "bun ./build.js --dev",
+      "watch": "bun --watch --watch-mode=poll --watch-ignore-dirs=node_modules,dist --watch-paths=./src ./build.js --dev",
+      "serve": "bunx serve ./"
+    {% else %}
+      "build": "rollup --config",
+      "build:dev": "rollup --config --sourcemap --environment DEVELOPMENT",
+      "watch": "rollup --config --watch --sourcemap --environment DEVELOPMENT --environment FLOWNET_WATCH",
+      "serve": "bunx serve ./"
+    {% endif %}
+
+    {% if atom.doc.features.cli.enabled %}
+      {% if atom.doc.features.project.format ==='cjs' %}
+        ,"cli": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.dir}}/index.cjs"
+        {% if atom.doc.features.cli.mcp.enabled===true %}
+          ,"mcp": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.dir}}/index.cjs --cli-mode=mcp"
+          ,"mcp-inspect": "bunx @modelcontextprotocol/inspector bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.dir}}/index.cjs --cli-mode=mcp"
+        {% endif %}
+      {% else %}
+        ,"cli": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.output.file}}"
+        ,"cli:dev": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.input.file}}"
+        {% if atom.doc.features.cli.mcp.enabled===true %}
+          ,"cli:mcp": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.output.file}} --cli-mode=mcp"
+          ,"cli:mcp:inspect": "bunx @modelcontextprotocol/inspector bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.output.file}} --cli-mode=mcp"
+          ,"cli:mcp:dev": "bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.input.file}} --cli-mode=mcp"
+          ,"cli:mcp:inspect:dev": "bunx @modelcontextprotocol/inspector bun {{atom.doc.features.cli.node_options}} {{atom.doc.features.cli.input.file}} --cli-mode=mcp"
+        {% endif %}
+      {% endif %}
+      ,"cli:compile": "fbin compile {{atom.doc.features.cli.output.file}} -o .bin/{{atom.doc['npm::bin'] or atom.doc['name'] or atom['id']}} --yes"
+      ,"cli:compile:dev": "fbin compile {{atom.doc.features.cli.input.file}} -o .bin/{{atom.doc['npm::bin'] or atom.doc['name'] or atom['id']}} --yes"    
+      ,"cli:install": "fbin install ./.bin/{{atom.doc['npm::bin'] or atom.doc['name'] or atom['id']}} --yes"
+    {% endif %}
+
+    {% if atom.doc.features.app.enabled %}
+      ,"app": "bunx serve {{atom.doc.features.app.dir}}/"
+    {% endif %}
+  },
+  "devDependencies": {
+    {% for dep in packageDevDependencies %}
+      "{{dep.package}}":"{{dep.version}}" {% if not loop.last%},{%endif%}
+    {% endfor%}
+  },
+  "dependencies": {
+    {% for dep in packageDependencies %}
+      "{{dep.package}}":"{{dep.version}}" {% if not loop.last%},{%endif%}
+    {% endfor%}
+  }
+  
+  {% if atom.doc.features.cli.enabled and atom.doc['npm::bin'] %}
+    ,"bin":{
+      {% if atom.doc.features.project.format ==='cjs' %}
+        "{{atom.doc['npm::bin']}}":"{{atom.doc.features.cli.dir}}/index.cjs"
+      {% else %}
+        "{{atom.doc['npm::bin']}}":"{{atom.doc.features.cli.output.file}}"
+      {% endif %}
+    }
+  {% endif %}
+}

package/template/fnet/node/readme.md.njk

@@ -0,0 +1,21 @@
+{{content | safe}}
+
+{% if howto %}
+{{howto | safe}}
+{% endif %}
+
+{% if input %}
+# Input Schema
+
+```yaml
+{{ input | safe}}
+```
+{% endif %}
+
+{% if output %}
+# Output Schema
+
+```yaml
+{{ output | safe}}
+```
+{% endif %}