open-index/open-npm huggingface dataset:
npm package: @flancer32/skill-teqfw-esm-validator
Description: Validate TeqFW-compatible ES modules with a JSON CLI and installable agent skill.
Latest version: 0.8.0

# skill-teqfw-esm-validator

Validate TeqFW-compatible ES modules with a deterministic JSON CLI.

Current package version: `0.8.0`.

## What It Does

The validator checks TeqFW source files against the profile/rule model documented in `ctx/`:

- the `base` profile for all modules
- the `type-regular` profile for regular TeqFW components
- the `type-config-runtime` profile for runtime configuration components
- atomic AST, JSDoc, and runtime rules owned by those profiles

The CLI accepts either:

- a single `.mjs` or `.js` file
- a directory, which is scanned recursively for matching `.mjs` and `.js` files

By default, the CLI runs the `base` profile. Use `--profile` to select a different documented profile.

## Install

```bash
npm install -g @flancer32/skill-teqfw-esm-validator
```

The package installs the agent skill automatically during `postinstall`.

## Update

Update the installed package the same way you installed it:

```bash
npm install -g @flancer32/skill-teqfw-esm-validator@latest
```

If you already have the package installed globally, this refreshes the CLI and reinstalls the bundled agent skill during `postinstall`.

## Usage

Validate one file:

```bash
teqfw-esm-validator path/to/module.mjs
```

Validate a directory recursively:

```bash
teqfw-esm-validator path/to/package
```

Validate with an explicit profile:

```bash
teqfw-esm-validator --profile type-config-runtime path/to/runtime-config.mjs
```

The CLI prints strict JSON and exits with:

- `0` when validation succeeds
- `1` when validation fails or the CLI encounters an error

## Output

Successful validation:

```json
{
  "valid": true,
  "violations": []
}
```

When validating a directory, violations include the affected `fileName` so you can see which file failed.

CLI errors are also reported as JSON violations, for example:

- `cli.missing-argument`
- `cli.missing-file`
- `cli.unknown-profile`
- `cli.runtime-error`

## Agent Skill

The packaged skill lives in [`skill/SKILL.md`](./skill/SKILL.md).
Use it as the canonical summary of the validator's profiles and rule set.

## Development

```bash
npm install
npm test
```

Release notes are tracked in [`CHANGELOG.md`](./CHANGELOG.md).
npm package: @flancer32/teq-cms
Description: Minimalistic file-based CMS for multilingual websites with AI-powered localization and Git-native content workflow.
Author: Alex Gusev
Latest version: 0.5.4

# @flancer32/teq-cms

TeqCMS is a minimalistic content management system for building and maintaining multilingual websites.  
It is file-based by design and treats content as code — stored, versioned, and deployed using standard development tools.

Localization is powered by AI and fully integrated into the content lifecycle. When a page is updated, translations are automatically synchronized using language models, without manual duplication or third-party interfaces.

This system eliminates the need for databases, admin panels, or headless infrastructure. Instead, it relies on structured directories, template rendering, and automation — providing full transparency and control over every stage of development and publishing.

TeqCMS is suitable for websites, landing pages, documentation, and developer-facing resources where clarity, consistency, and maintainability are critical. It integrates easily into existing Git workflows and can be deployed in any Node.js environment.

Learn more at: [https://cms.teqfw.com](https://cms.teqfw.com)

---

## Key Principles

- Content is managed as plain files in a structured layout.
- Translations are automated and kept in sync through AI.
- Pages are rendered server-side using standard templates.
- Deployment is simple and reproducible, with no hidden logic.

---

## Who It’s For

- Developers maintaining multilingual websites
- Teams building structured documentation or landing pages
- Projects that require versioned, file-based content with low infrastructure overhead

---

## Configuring TeqCMS in External Applications

TeqCMS lets host applications register their DI customizations during startup. Drop a `teqcms.config.mjs` file into the project root (or fall back to `teqcms.config.js` for CommonJS support) or add a `"teqcms"` entry to `package.json` that points to a configurator module. TeqCMS loads the module before running any CLI commands and invokes its default export with `{ resolver, replace }`, so the application can add namespace roots or swap implementations without touching the container directly.

```json
"teqcms": {
  "configure": "./src/cms/setup.js"
}
```

```js
export default async function configure({ resolver, replace }) {
  resolver.addNamespaceRoot('App_', './src');
  replace.add('Fl32_Cms_Back_Api_Adapter', 'App_Cms_Custom_Adapter');
}
```

---

## License

Apache-2.0 © Alex Gusev — [https://github.com/flancer64](https://github.com/flancer64)
npm package: @flancer32/teq-telegram-bot
Description: A TeqFW plugin to build Telegram bots.
Author: Alex Gusev
Latest version: 0.2.2


# @flancer32/teq-telegram-bot

A foundational npm package for building Telegram bots using [grammY](https://grammy.dev/)
and [@teqfw/di](https://github.com/teqfw/di).

## Overview

This package facilitates the creation of Telegram bots leveraging the grammY
library ([Habr post](https://habr.com/ru/articles/837610/) in Russian). Key features include:

- Loading bot configuration (e.g., token) from external sources like a JSON file.
- Supporting two operational modes:
    - **Bot mode**: Uses long polling.
    - **Webhook server mode**:
        - Operates over HTTP/HTTP2 behind a proxy.
        - Supports HTTPS as a standalone server.
- Common setup tasks (e.g., registering commands at startup, setting up webhooks).
- Extension points to add custom application logic.

![Use Cases](./doc/img/lib.uc.png)

## Installation

To integrate the bot library in an npm application:

```shell
npm i @flancer32/teq-telegram-bot
```

## Usage

The package includes several commands for managing bot modes and server operations:

```shell
./bin/tequila.mjs help
./bin/tequila.mjs tg-bot-start         # Start in long polling mode
./bin/tequila.mjs tg-bot-stop
./bin/tequila.mjs web-server-start     # Start in webhook mode
./bin/tequila.mjs web-server-stop
```

## Configuration

Configure the main application with a `local.json` file in the `./cfg` directory:

```json
{
  "@flancer32/teq-telegram-bot": {
    "apiKeyTelegram": "YOUR_TELEGRAM_API_KEY"
  }
}
```

## API

To implement custom bot logic, create a class that follows the `Telegram_Bot_Back_Api_Setup` interface. This class
should initialize the grammY bot, set up middleware, and define bot commands and handlers.

### Setup Replacement in `@teqfw/di`

Specify the custom setup class in the `./teqfw/json` configuration file to override the default bot setup:

```json
{
  "@teqfw/di": {
    "autoload": {},
    "replaces": {
      "back": {
        "Telegram_Bot_Back_Api_Setup": "YourApp_Back_Bot_Setup"
      }
    }
  }
}
```

Replace `"YourApp_Back_Bot_Setup"` with the fully qualified name of your custom setup class.
npm package: @flancer32/teq-tmpl
Description: Node.js package for multilingual template management and rendering with flexible overrides, supporting Mustache, Nunjucks, and other engines.
Author: Alex Gusev
Latest version: 0.3.0

# @flancer32/teq-tmpl

A universal package for managing and rendering text templates in Node.js applications with support for multilingualism and flexible overrides. Enables easy creation of localized content for web pages, email campaigns, and any other text-based formats.

---

## Key Features

* **Multilingual Support**  
  Automatic template selection considering user, application, and plugin locales with fallback logic.

* **Flexible Override System**  
  Allows overriding plugin templates at the application level without modifying the original code.

* **Template Engine Abstraction**  
  Supports various engines (Mustache, Nunjucks, etc.) through a unified interface, with an easily extensible architecture.

* **Versatility**  
  Suitable for generating HTML, JSON, XML, YAML, email, and other text formats.

* **Easy Integration**  
  Easily integrates with any Node.js application and can be used as a standalone module.

---

## How It Works (Briefly)

1. Defines the target template considering type (web, email, text), name, package, and locales.
2. Searches the template file in a strict order based on locales and overrides.
3. Loads the found template from disk.
4. Renders the template with data via the configured engine.
5. Returns the ready localized content.

---

## Integration Requirements

Applications must provide a template engine implementation that fulfills the `Fl32_Tmpl_Back_Api_Engine` interface. Use the DI container's `replace.add()` method to map `Fl32_Tmpl_Back_Api_Engine$` to the desired engine service:

```javascript
replace.add('Fl32_Tmpl_Back_Api_Engine$', 'Fl32_Tmpl_Back_Service_Engine_Mustache$');
```

Available engine implementations include:

- `Fl32_Tmpl_Back_Service_Engine_Mustache`
- `Fl32_Tmpl_Back_Service_Engine_Nunjucks`
- `Fl32_Tmpl_Back_Service_Engine_Simple`

Custom engines can also be supplied as long as they conform to `Fl32_Tmpl_Back_Api_Engine`.

---

## Who Benefits

* Developers building multilingual web applications and mailing services.
* Teams working with plugins and complex modular architectures.
* Projects needing a flexible and extensible template system without lock-in to a specific templating engine.

## Testing

Run unit tests with Node.js built-in runner:

```bash
npm test
```

---

## Status and Documentation

The package is actively developed and successfully used in projects with modular architecture. It is created following the **TeqFW philosophy**, ensuring clear separation of concerns, modularity, and extensibility. Documentation follows the **3DP methodology**, providing clear structure and separation between code, documentation, and iterations.

---

## License

Apache-2.0 © [Alex Gusev](https://github.com/flancer64)
npm package: @flancer64/demo-di-app
Description: @teqfw/di demo: main application (web & nodejs).
Author: Alex Gusev
Latest version: 0.2.1

# demo-di-app

This is an npm package with 2 applications (web & Node.js) to demonstrate the usage of the same JavaScript code in the
browser and Node.js without any transformations, just with dependency
injection ([@teqfw/di](https://github.com/teqfw/di)):

![packages](docs/teqfw_di_demo_pkg.png)

The code in this package ([@flancer64/demo-di-app](https://github.com/flancer64/demo-di-app)) has dependencies on
another package ([@flancer64/demo-di-lib](https://github.com/flancer64/demo-di-lib)).
To load the sources, you just need to configure the resolver for both Node.js and browser code. All other code remains
unchanged.

## nodejs

```javascript
// ./index.js
import {dirname, join} from 'node:path';
import Container from '@teqfw/di';

// Create the objects container
/** @type {TeqFw_Di_Api_Container} */
const container = new Container();

// Add path mapping for the sources (app itself and used library)
const root = dirname(import.meta.url);
const pathApp = join(root, 'src');
const pathLib = join(root, 'node_modules', '@flancer64', 'demo-di-lib', 'src');
const resolver = container.getResolver();
resolver.addNamespaceRoot('App_', pathApp);
resolver.addNamespaceRoot('Sample_Lib_', pathLib);

// Compose the application and run it
const app = await container.get('App_Main$');
app('Hello from the Node.js!');
```

## browser

```html
<!-- ./index.html -->
<script type="module">
    import Container from 'https://cdn.jsdelivr.net/npm/@teqfw/di@0.30.0/+esm';

    // Create the objects container
    /** @type {TeqFw_Di_Api_Container} */
    const container = new Container();

    // Add path mapping for the sources (app itself and used library)
    const url = new URL(location.href);
    const root = url.pathname.replace('index.html', '');
    const pathApp = url.origin + root + 'src';  // load app sources locally
    const pathLib = 'https://cdn.jsdelivr.net/npm/@flancer64/demo-di-lib@0.3.0/src'; // load lib sources from CDN
    const resolver = container.getResolver();
    resolver.addNamespaceRoot('App_', pathApp);
    resolver.addNamespaceRoot('Sample_Lib_', pathLib);

    // Get the application from the container (as singleton) and run it
    const app = await container.get('App_Main$');
    app('Hello from the Web!');
</script>
```
npm package: @flancer64/demo-di-if-plugin
Description: Npm-package with plugin code (interfaces are declared here).
Author: Alex Gusev
Latest version: 0.2.0

# demo-di-if-plugin

This is a part of demo for my articles about the interfaces usage in regular JS:

* [Habr](https://habr.com/ru/articles/834002/) (ru)

The apps that use this plugin:

* [flancer64/demo-di-if-app1](https://github.com/flancer64/demo-di-if-app1)
* [flancer64/demo-di-if-app2](https://github.com/flancer64/demo-di-if-app2)

## Links

Other links related to me:

* [@teqfw/di](https://www.npmjs.com/package/@teqfw/di)
* [Upwork](https://www.upwork.com/freelancers/~0181de0a64c6981497)
* [LinkedIn](https://www.linkedin.com/in/alex-gusev-011ba928/)
* [Medium blog](https://flancer32.com/)
npm package: @flancer64/demo-di-lib
Description: DI demo: shared library.
Author: Alex Gusev
Latest version: 0.3.0

# demo-di-lib

This is a library package that demonstrates JavaScript code that can be used from both Node.js and browser apps without
requiring additional transformation. This sample is compatible with the DI container from the `@teqfw/di` package.

The package contains 3 modules:

* [src/Config.js](./src/Config.js): Just an object that contains hardcoded configuration.
* [src/Logger.js](./src/Logger.js): A factory to create a new function with one dependency (config).
* [src/Service.js](./src/Service.js): A class to create new instances with 2 dependencies (config & logger).

See the [@flancer64/demo-di-app](https://github.com/flancer64/demo-di-app) package for an example of how to use this
library.
npm package: @flancer64/demo-wa-esm-openai
Description: The web app demonstrates ES modules usage from a CDN.
Author: Alex Gusev
Latest version: 0.1.2

# demo-wa-esm-openai

The web app demonstrates ES modules usage from a CDN ([read more](https://flancer32.com/launching-web-apps-without-own-servers-how-esm-and-cdns-are-changing-the-game-a68e6632999f)).