µGulp™ (microGulp)

Rock your Gulp!

µGulp™, the interactive near-zero-latency task orchestrator with rich visuals, webview controls, and audio feedback.

Version 0.5.20 · Proprietary License

English

Rock your Gulp!

µGulp™, the interactive near-zero-latency task orchestrator with rich visuals, webview controls, and audio feedback — shipped as an IDE extension (VS Code / Cursor AI, PhpStorm test build) with a Carbon/Neon webview dashboard.

Highlights

i18n-ready gulp tasks — .i18xRegister() phrases with embedded context tags on display names, descriptions, tooltips and groups; standard placeholders (version, project, …) via µI18xContext
Hierarchical task tree — nest tasks with µGroup path syntax (Build/Production), collapsible groups, multi-gulpfile grouping by source
Preloaded workers — warm Node processes with the gulpfile already imported; near-zero click-to-run latency (avoids cold-start scans from AV software)
Live gulpfile watch — workspace watcher rescans on save and swaps stale workers automatically
Web dashboard — live ANSI-colored logs, filtered output, determinate progress bars, rich forms for user input (text, color, font, select, multiselect, …)
Structured log output — tasks emit JSON payloads rendered inline in the run log (tables, trees, image galleries, callouts, key/value metrics, status badges, code blocks, inline-SVG bar charts) — Content-Security-Policy safe, no plugin or iframe required
Persistent task history & file logging — every run is written to .microgulp/logs (raw .log + structured .ndjson), a history.ndjson index survives reconnects/IDE restarts; a dashboard history panel opens each transcript (logToFile, logRetention)
Plain-gulp compatible — µ-prefixed metadata is invisible to the classic gulp CLI; scripts run unchanged without µGulp
Optional acoustic control — completion sounds, error alarms and speech output (dashboard settings)
Optional form reminder — when a task waits for dashboard input, remind the user after a configurable delay via sound and/or speech; repeats until the form is answered
Parallel task grid — multiple isolated run sectors side by side, each with its own log stream
Concurrency matrix — per-task exclusive runs and allow/deny rules (µExecutionConcurrency, µExecutionRestrictions)
Diagnosis engine — import errors and stack traces become actionable suggestions in the dashboard
Legacy prompt bridge — inquirer / gulp-prompt / prompts redirected to dashboard forms without editing gulpfiles
gulp-mu-gulp-api — npm module for progress, sound, speech and interactive inputs from inside tasks

Snapshot


Hosts	VS Code, Cursor AI, PhpStorm (test ZIP), any browser on `127.0.0.1` via `microgulp-serve --http`
Runtime	Node.js 22+ (ESM)
Gulpfiles	Single `gulpfile.mjs` or regex discovery across the workspace
Config	Extension settings (VS Code/Cursor) or `microgulp.config.json` (PhpStorm / CLI)
Engine	IDE-independent — same `src/engine` in every host
Task order	`µOrder` (ascending integer); groups by minimum order in subtree; unordered tasks last (alphabetical)

Click a task → a warm worker runs it immediately. Edit the gulpfile → the task list updates on its own. Several tasks can run in parallel; each gets its own dashboard sector with a neon progress bar when the task calls ReportProgress from gulp-mu-gulp-api.

Installation

µGulp™ is not published to a marketplace yet. Two ways to get it:

Prebuilt VSIX: the current release is always available as [packages/microgulp_latest.vsix](packages/microgulp_latest.vsix) (plus versioned builds like microgulp_V0.5.0.vsix next to it). Install it with:

code --install-extension packages/microgulp_latest.vsix     # VS Code
cursor --install-extension packages/microgulp_latest.vsix   # Cursor AI

Build from source: npm install, then npm run build — the fresh .vsix lands in packages/.

Afterwards run µGulp: Open Dashboard from the command palette (or click the µGulp™ rocket in the status bar).

PhpStorm (test build)

A PhpStorm plugin is available as [packages/microgulp-phpstorm_latest.zip](packages/microgulp-phpstorm_latest.zip): install it via Settings → Plugins → ⚙ → Install Plugin from Disk… and open the µGulp tool window. The plugin is a thin JCEF adapter — the entire engine runs in a bundled Node.js sidecar, so Node.js 22+ must be installed (on the PATH, or set the MICROGULP_NODE environment variable to the binary). Rebuild with npm run phpstorm (compiles against an installed JetBrains IDE, no Gradle required).

The same dashboard also runs in any plain browser: npm run serve -- --cwd <project> --http 9310 --preload, then open http://127.0.0.1:9310/.

Configuration file `microgulp.config.json` (PhpStorm & CLI)

In VS Code / Cursor the engine is configured through the extension settings (microgulp.gulpfilePattern etc.). Hosts without their own settings surface — the PhpStorm plugin and plain CLI/browser usage via microgulp-serve — read an optional **microgulp.config.json** in the project root instead:

{
	"gulpfilePattern": "gulpfile.*\\.mjs$",
	"poolSize": 2,
	"maxParallel": 6,
	"preload": true,
	"watchGulpfiles": true
}

Key	Type	Default	Meaning
`gulpfile`	string	`"gulpfile.mjs"`	Single gulpfile, relative to the project root
`gulpfilePattern`	string	—	Case-insensitive regex against workspace-relative POSIX paths; discovers all matching gulpfiles (wins over `gulpfile`)
`poolSize`	int ≥ 0	`2`	Warm workers per gulpfile
`maxParallel`	int ≥ 1	`6`	Maximum concurrent task runs
`preload`	bool	`false`	Warm up the worker pools right after startup (the PhpStorm plugin always enables this)
`watchGulpfiles`	bool	`true`	Auto-rescan on gulpfile changes
`logToFile`	bool	`true`	Persist run transcripts (`.log` + `.ndjson`) and the task history to disk
`logDirectory`	string	`.microgulp/logs`	Directory for transcripts and the history index, relative to the project root
`logRetention`	int ≥ 0	`200`	Max runs kept in the history (0 = unlimited); older runs and their log files are pruned

Precedence: command line arguments > microgulp.config.json > built-in defaults. Invalid values and unknown keys are ignored with a warning on stderr; the file is versionable and applies to the whole team. After editing the file, reopen the PhpStorm tool window (respawns the sidecar) or restart microgulp-serve.

Project structure

gulpfile.mjs             Project build: tests, theme CSS (µCSS), package + deploy
RELEASES.json            Version source (main/minor/revision, i18xe-ready info texts)
gulp-mu-gulp-api/        Standalone npm module: public task API
  src/index.mjs          Progress, text/color/font/select inputs, forms
  tests/                 The module's own node:test suite
skins/                   One directory per skin (neon-carbon is the default)
  neon-carbon/
    neon-carbon.µcss.mjs µCSS skin manifest (Carbon/Neon variables)
    neon-carbon.µ.css    Skin source → compiled into src/webview/skins/neon-carbon/
  ice-light/             Light frosted-glass skin (cool blue outward glow)
    ice-light.µcss.mjs   µCSS skin manifest (ice palette)
    ice-light.µ.css      Skin source → compiled into src/webview/skins/ice-light/
src/
  engine/                IDE-independent core (no VS Code APIs!)
    TaskEngine.mjs       Orchestrator: scan, preload, queue, events
    TaskWorkerPool.mjs   Pool of prewarmed worker processes
    ConcurrencyGuard.mjs Evaluates executionConcurrency/-Restrictions
    Diagnostics.mjs      Diagnosis engine (stack traces → concrete suggestions)
    PluginHost.mjs       Lifecycle hooks for plugins
    GulpfileDiscovery.mjs  Regex-based gulpfile discovery in the workspace
    ReleaseInfo.mjs      Release management: RELEASES.json, version strings, history
  worker/
    TaskWorker.mjs       Child process: imports the gulpfile, runs tasks
  bridge/
    gulp-ugulp-bridge.mjs  Public bridge: npm packages ↔ webview forms
  host/
    HostProtocol.mjs     Event/command names (the single host boundary)
    Daemon.mjs           Engine owner for sidecar hosts
    microgulp-serve.mjs  stdio NDJSON CLI (PhpStorm preparation)
  extension/
    extension.cjs        Thin VS Code / Cursor adapter (the only CJS module)
  webview/
    dashboard.css        Fallback stylesheet for fresh checkouts
    dashboard.js         TaskGrid, log streaming, forms, audio engine
    skins/<name>/dashboard.css  µCSS-generated skins (webview default: neon-carbon)
tests/                   node:test suites (unit + engine integration)
demo/
  gulpfile.mjs           Example gulpfile with every µGulp™ metadata tag
  run-demo.mjs           Headless engine smoke test (no IDE)
dev/
  prompts/               AI migration prompts (existing gulpfile → µGulp + i18x)
    OptimizeGulpfileForMicroGulp.md
    OptimizeGulpfileForMicroGulp.params.example.json

Architecture principles

The engine layer is IDE-free. src/engine and src/worker know no VS Code APIs. Communication runs through events (engine → host) and plain-JSON commands (host → engine). Porting to PhpStorm (phase 2) is therefore a pure adapter swap — the minimal sidecar npm run serve (src/host/microgulp-serve.mjs, NDJSON on stdio) is already in place.
Task preloading. The TaskWorkerPool keeps prewarmed Node processes around in which the gulpfile has already been imported. Starting a task hands over a warm worker and refills the pool in the background. After a run the process is discarded (fresh module state).
Dynamic imports. Heavy npm packages (mssql, docx-templates, makensis, …) must only be loaded inside the task body via await import() — static top-level imports are reserved for the orchestrator core logic.
Languages. GUI texts are American English and go through String.i18xTrans() (i18xe wiring to follow); code comments English; manuals/documentation German.

Gulpfile discovery (regex-configurable)

µGulp™ notices gulpfile changes on disk by itself: a workspace watcher (microgulp.watchGulpfiles, on by default) rescans automatically after every change and swaps the warm workers for fresh ones running the current code. While a scan runs, the task list shows an animated progress indicator; the dashboard therefore has no rescan button anymore — the µGulp: Rescan Tasks command (command palette) remains as a manual force refresh. If a gulpfile fails to load (syntax error, missing module), a dismissible error banner with diagnosis and stack trace appears right in the dashboard.

µGulp™ finds gulpfiles either through a single path or through a regex pattern that searches the entire workspace:

microgulp.gulpfilePattern — a JavaScript regex (case-insensitive) tested against the workspace-relative path (POSIX notation with /). When set, every matching file is scanned; tasks are grouped by their source in the dashboard. Example: (^|/)gulpfile\.(m|c)?js$ finds gulpfile.mjs/.js/.cjs at the root and in every subfolder.
microgulp.gulpfilePath — the classic single path (default gulpfile.mjs). Only used while gulpfilePattern is empty.

node_modules, .git and hidden folders (.*) are never descended into. Every discovered gulpfile gets its own warm worker pool with the gulpfile's folder as working directory, so nested subprojects with relative paths run correctly. The discovery logic lives IDE-independently in src/engine/GulpfileDiscovery.mjs and is therefore available to the CLI and the future PhpStorm adapter as well.

µGulp™ metadata on a Gulp task

The recommended form is µ-prefixed tags in CamelCase (µDisplayName, µIcon, …) — they are invisible to the classic gulp CLI, so gulpfiles stay fully compatible on systems without µGulp™ (the gulp CLI addresses tasks via function.displayName; a pretty name with spaces would break task addressing there):

export async function BUILD_STYLES() { /* ... */ }
BUILD_STYLES.µDisplayName = 'Build Styles';
BUILD_STYLES.µDescription = 'Compiles the µCSS skin into deploy-ready stylesheets.';
BUILD_STYLES.µTooltip = 'Runs the µCSS pipeline (sprites, fonts, sounds included).';
BUILD_STYLES.µIcon = '\u25A3';   // font symbol — or an image data URI:
// BUILD_STYLES.µIcon = 'data:image/svg+xml,%3Csvg ...';  (png/webp too)
BUILD_STYLES.µGroup = 'Build/Assets';                 // nested group (path syntax)
BUILD_STYLES.µOrder = 10;                             // sort position in the dashboard (ascending)
BUILD_STYLES.µExecutionConcurrency = true;            // false = exclusive
BUILD_STYLES.µExecutionRestrictions = { deny: ['CLEAN'] }; // parallel matrix

µGroup assigns the task to a nested group in the task overview. The definition follows a directory-like path syntax: µGroup = 'Build/Production' creates the group Build with subgroup Production. Groups are collapsible in the dashboard; tasks without µGroup stay at the top level. The assignment is optional and purely visual — it has no effect on execution or concurrency.

µOrder sets the sort position in the left column (ascending integer). Sibling tasks and groups are ordered by µOrder; tasks without it appear after all ordered tasks (tie-breaker: display name). Groups sort by the lowest µOrder in their subtree.

Modifier keys on a group header:

Action	Effect
Click	toggle the group
Ctrl+Click (Cmd+Click)	toggle every group on the same level
Alt+Click	toggle all groups

Per-property fallback cascade: µDisplayName → ugulp.displayName (namespace object) → displayName (Gulp's own field) → export name. executionRestrictions supports deny (always wins) and allow (whitelist: everything unlisted is forbidden).

Task metadata strings use i18x with the context tag inside the phrase and .i18xRegister() (required for i18xe-sync and dashboard translation):

BUILD_STYLES.µDisplayName = 'Build Styles<context="µDisplayName"/>'.i18xRegister();
BUILD_STYLES.µDescription = 'Compiles the µCSS skin into deploy-ready stylesheets.<context="µDescription"/>'.i18xRegister();
BUILD_STYLES.µGroup = 'Build/Assets<context="µGroup"/>'.i18xRegister();

AI-assisted gulpfile migration

To migrate an existing large gulpfile (console output, task metadata, i18x/gulp dictionaries) use the maintained prompt in the repository:

File	Purpose
`dev/prompts/OptimizeGulpfileForMicroGulp.md`	Copy-paste prompt for Cursor, Claude, ChatGPT, …
`dev/prompts/OptimizeGulpfileForMicroGulp.params.example.json`	Parameter template (project path, gulpfile name, supported languages, `gulp-mu-gulp-api` version)

Workflow

Copy the params example to your project root as microgulp-optimize.params.json and fill in projectRoot, gulpfilePath, supportedLanguages (e.g. en-US, de-DE, zh-CN), gulpMuGulpApiVersion (^0.3.0 or newer), and githubRepoUrl / githubRef (default: https://github.com/mamekudz/microGulp, main).
Open the prompt markdown, replace the {{PLACEHOLDER}} table with your values (or attach the params file and gulpfile in Cursor).
Let the AI run the migration. Step 0 in the prompt is mandatory: a timestamped backup of the gulpfile (e.g. gulpfile.mjs.20260703-142559.bak) before any edit.
Verify with node --check gulpfile.mjs, test tasks in the µGulp dashboard, then commit gulpfile.mjs, i18x/gulp/*.json, and package.json.

Consumer projects need only i18x/gulp/<lid>.json — no i18x/prod. The prompt is updated with µGulp releases; check this repo for the latest version before migrating. The prompt includes a detailed i18x rules section (register vs. translate, correct/wrong examples, i18xe-sync scanning, no µMeta) — read Step 3 before running the AI.

Public task API (gulp-mu-gulp-api)

Third-party gulpfiles and npm packages inside the stream use the extended dashboard features through the standalone npm module **gulp-mu-gulp-api** (lives as its own project under gulp-mu-gulp-api/, published to npm separately):

import { ReportProgress, RequestTextInput, RequestColorInput, RequestForm } from 'gulp-mu-gulp-api';

export async function BUILD_THEME() {
    let accent = await RequestColorInput({ label: 'Accent color', default: '#00e5ff' });
    let title = await RequestTextInput({ label: 'Product title', validate: { required: true, minLength: 3 } });
    for (let step = 1; step <= 10; step++) {
        // ... work ...
        ReportProgress(step / 10, 'compiling theme');   // determinate neon progress bar in the sector
    }
}

The module is dependency-free and talks to the engine directly over the µGulp™ worker's IPC channel (detection via IsMicroGulp() / IsµGulp()). Without µGulp™ everything degrades cleanly: progress goes to the terminal, inputs via readline (TTY) or default values (CI). Details in gulp-mu-gulp-api/README.md. The internal module src/bridge/gulp-ugulp-bridge.mjs remains as the low-level transport; new consumers should use gulp-mu-gulp-api.

µGulp ready certification

npm modules whose root gulpfile is fully integrated with the µGulp dashboard may display the µGulp ready badge on their npm README and project pages.

Requirement	Detail
Gulpfile	Exported tasks carry µGulp metadata (`µDisplayName`, `µDescription`, `µGroup`, …)
API	Uses `gulp-mu-gulp-api` for logging, progress and optional dashboard features
CLI fallback	Tasks remain runnable with plain `gulp` / `npx gulp` when µGulp is not installed
Badge asset	Canonical PNG: `media/microgulp-ready.png` in the µGulp repo. npm README: absolute raw URL (npm rewrites relative paths to `microCSS/HEAD/...` even inside HTML). Example: `<a href="https://github.com/mamekudz/microGulp"><img src="https://raw.githubusercontent.com/mamekudz/microGulp/main/media/microgulp-ready.png" alt="µGulp ready" width="150"></a>`
package.json	Optional `"microgulp": { "ready": true, "certifiedSince": "<semver>" }` for machine-readable discovery

Certified modules

npm package	Since	Notes
`gulp-mu-gulp-api`	0.3.2	Official task API — `Log`, `ReportProgress`, i18x console layer, dashboard forms; npm README badge since 0.3.3
`gulp-mu-css` (µCSS™)	2.5.15	Monorepo root `gulpfile.mjs` with full task metadata, `i18x/gulp/` (en-US, de-DE) and `LogBuildDebugReport` on demo builds; npm README badge via absolute raw URL since 2.5.14
`gulp-mu-ps` (µPS)	1.3.5	Test/render tasks in the shared root gulpfile (`TEST_MICROPS`, `RENDER_EXAMPLES`, …)
`gulp-mu-ft` (µFT)	0.1.5	Test task `TEST_MICROFT` in the shared root gulpfile
`gulp-mu-au` (µAU)	0.1.6	Test task `TEST_MICROAU` in the shared root gulpfile

To apply for certification, migrate your gulpfile with dev/prompts/OptimizeGulpfileForMicroGulp.md and open an issue or PR in the µGulp or module repository.

Versioning (RELEASES.json)

µGulp™ versions through **RELEASES.json** at the project root as the single source of truth. Every release entry carries main/minor/revision, a timestamp, a beta flag and a list of info texts. The info texts carry the i18x context tag <context="release info"/> and are registered via String.i18xRegister(), so the i18xe engine can translate them automatically.

{
    "releases": [
        {
            "main": 0, "minor": 2, "revision": 0, "date": "2026-07-02 15:30", "beta": false,
            "info": [ "Release management added<context=\"release info\"/>" ]
        }
    ]
}

The module src/engine/ReleaseInfo.mjs provides:

GetVersionString() / GetFullVersionString() — "0.2.0" or "0.1.4ß" (ß suffix for beta builds).
GetVersionHistoryText({ maxReleases, includeBeta }) — the complete history as a formatted string for the console (task SHOW_VERSION_HISTORY or npm run history).
BUILD_PACKAGE syncs the package.json version and the version line at the top of this README from RELEASES.json automatically and stamps it into the artifact name (microgulp_V0.2.0.vsix, betas with a _beta suffix). A new release only needs a new entry at the top of RELEASES.json.

Project build (gulpfile.mjs)

The project builds itself through its own gulpfile (dogfooding: it runs in the µGulp™ dashboard, through the gulp CLI, through classic Gulp IDE extensions and headless):

Invocation	Task	Purpose
`npm test`	`RUN_TESTS`	node:test suites in `tests/` (unit + engine integration with real worker processes)
`npm run theme`	`CREATE_THEME_DATA`	Compiles every `skins/<name>/<name>.µ.css` via µCSS (`gulp-mu-css` `BuildSkin`) into `src/webview/skins/<name>/dashboard.css` (default: `neon-carbon`)
`npm run package`	`BUILD_PACKAGE`	Stages the extension into `tmp/package/` and creates the `.vsix` in `packages/` (also refreshed as `microgulp_latest.vsix`)
`npm run deploy`	`DEPLOY_EXTENSION`	Automated update cycle: build the `.vsix` and install it via `cursor --install-extension` (reload the window afterwards)
`npm run build`	`BUILD_ALL`	Full pipeline: clean → tests → theme → package
`npm run history`	`SHOW_VERSION_HISTORY`	Prints the formatted version history from `RELEASES.json` to the console
—	`PUBLISH_API`	Publishes `gulp-mu-gulp-api` to npm (runs its tests first; `npm login` required)
—	`CLEAN`	Removes `tmp/` and `packages/` (exclusive, write lock)

Notes:

gulp-mu-css is wired in as a local file: dependency on C:\Projects\microCSS\gulp-mu-css and — like every heavy package — is only loaded inside the task body via await import().
BUILD_PACKAGE produces a real .vsix once @vscode/vsce is installed (npm i -D @vscode/vsce); without vsce the task falls back to a zip of the staging folder.
Skins are self-contained: one directory per skin under skins/ (e.g. skins/neon-carbon/, skins/ice-light/), each with a <name>.µcss.mjs manifest and a same-named <name>.µ.css source. CREATE_THEME_DATA discovers and builds every skin; neon-carbon (dark) is the default and ice-light ships a bright frosted-glass companion. Additional/user skins can be dropped in as sibling directories. The dashboard skin picker (Settings → Appearance) offers an Automatic mode that follows the IDE/OS light or dark theme.
The webview automatically prefers the generated default skin (src/webview/skins/neon-carbon/dashboard.css); the hand-written dashboard.css remains as a fallback for fresh checkouts.
The dashboard header shows the yellow microscope mark (baselogo.svg) via µCSS data-URI inlining next to the neon µGulp™ title (background-image: µ(DataUri("imgs/baselogo.svg"))). The single source of truth for finished art assets is dev/media/final/; the build syncs media/logo.png (extension icon), media/logo_readme.png (README), src/webview/skins/<name>/imgs/baselogo.svg (dashboard) and phpstorm/resources/icons/baseoutlinelogo.svg (PhpStorm tool window + plugin list) from there.

Try it

Headless (no IDE):

npm run demo

Scans demo/gulpfile.mjs, warms up the pool, starts two parallel tasks, one exclusive task (waits in the queue) and one intentionally failing task (diagnosis engine).

As an extension: press F5 in VS Code/Cursor (launch configuration "Run µGulp Extension"), then run µGulp: Open Dashboard in the development host.

License

µGulp™ (extension, engine, dashboard, PhpStorm adapter) is proprietary software — see LICENSE. You may use the distributed binaries free of charge; copying, modifying, or redistributing the source code is not permitted.

The companion npm package gulp-mu-gulp-api remains under the MIT License so Gulp tasks can adopt it without restrictions.

Roadmap / open points of this draft

Shipped in V0.5.0

Still open

Explicit task sort order in the dashboard (µOrder metadata)
Document µLib (microLib), then adopt it as the utility layer in µGulp (i18x today is a local webview subset)
Direct i18xe-server connection: live translation sync instead of the bundled de-DE/zh-CN dictionaries
Extend µLib's GUI.mjs with additional special controls for the dashboard forms
Visual polish of the webview dashboard
Extend the µCSS skin: add the symbol font, sprites and sounds to the manifest
Audio engine: high-quality sounds + speech output via i18xe instead of WebAudio beeps / Web Speech API
PhpStorm plugin: polish beyond the test build (settings UI optional, marketplace distribution)
Publish the VS Code/Cursor extension to a marketplace

Deutsch

Rock your Gulp!

µGulp™ — der interaktive Task-Orchestrator mit nahezu null Latenz, stylischer Dashboard-Ausgabe, Webview-Steuerung und akustischem Feedback — als IDE-Erweiterung (VS Code / Cursor AI, PhpStorm-Testversion) mit einem Carbon/Neon-Webview-Dashboard.

Highlights

Automatisch internationalisierbare Gulp-Tasks — .i18xRegister()-Phrasen mit eingebetteten Kontext-Tags an Anzeigenamen, Beschreibungen, Tooltips und Gruppen; Standard-Platzhalter (version, project, …) über µI18xContext
Hierarchische Task-Sortierung — Tasks per µGroup-Pfad verschachteln (Build/Production), einklappbare Gruppen, bei mehreren Gulpfiles Gruppierung nach Quelle
Preload von Tasks — warme Node-Worker mit bereits importiertem Gulpfile; nahezu kein Kaltstart beim Klick (umgeht Echtzeit-Virenscanner-Latenzen)
Watch für die Task-Übersicht — Workspace-Watcher scannt bei Speichern neu und tauscht veraltete Worker aus
Web-basierte Ausgabe und Formulare — Live-Logs mit ANSI-Farben, Filter, determinierte Progressbars, Formulare für Benutzereingaben (Text, Farbe, Schrift, Auswahl, Mehrfachauswahl, …)
Strukturierte Log-Ausgabe — Tasks senden JSON-Payloads, die inline im Run-Log gerendert werden (Tabellen, Bäume, Bildgalerien, Callouts, Key/Value-Metriken, Status-Badges, Codeblöcke, Inline-SVG-Balkendiagramme) — Content-Security-Policy-sicher, ohne Plugin oder iframe
Persistente Task-Historie & Log-Umlenkung in Dateien — jeder Run wird nach .microgulp/logs geschrieben (roh .log + strukturiert .ndjson), ein history.ndjson-Index übersteht Reconnects/IDE-Neustarts; ein Historie-Panel im Dashboard öffnet jedes Transkript (logToFile, logRetention)
Kompatible Gulp-Skripte auch ohne µGulp — µ-Metadaten sind für die klassische gulp-CLI unsichtbar; Skripte laufen unverändert weiter
Optionale akustische Kontrolle — Ende-Sounds, Fehleralarm und Sprachausgabe (Dashboard-Einstellungen)
Optionale Formular-Erinnerung — wenn ein Task auf eine Dashboard-Eingabe wartet, nach einstellbarer Verzögerung per Sound und/oder Sprache erinnern; wiederholt bis das Formular beantwortet ist
Paralleles Task-Grid — mehrere isolierte Lauf-Sektoren nebeneinander, jeweils mit eigenem Log-Stream
Concurrency-Matrix — exklusive Tasks und Allow/Deny-Regeln (µExecutionConcurrency, µExecutionRestrictions)
Diagnose-Engine — Importfehler und Stack-Traces werden zu konkreten Lösungsvorschlägen im Dashboard
Legacy-Prompt-Brücke — inquirer / gulp-prompt / prompts auf Dashboard-Formulare umgeleitet, ohne Gulpfile-Anpassung
gulp-mu-gulp-api — npm-Modul für Fortschritt, Sound, Sprache und interaktive Eingaben aus Tasks heraus

Snapshot


Hosts	VS Code, Cursor AI, PhpStorm (Test-ZIP), jeder Browser auf `127.0.0.1` via `microgulp-serve --http`
Laufzeit	Node.js 22+ (ESM)
Gulpfiles	Einzelnes `gulpfile.mjs` oder Regex-Discovery im Workspace
Konfiguration	Erweiterungseinstellungen (VS Code/Cursor) oder `microgulp.config.json` (PhpStorm / CLI)
Engine	IDE-unabhängig — dieselbe `src/engine` in jedem Host
Task-Reihenfolge	`µOrder` (aufsteigende Ganzzahl); Gruppen nach kleinstem Order-Wert im Unterbaum; Tasks ohne Order zuletzt (alphabetisch)

Klick auf einen Task → warmer Worker startet sofort. Gulpfile speichern → Task-Liste aktualisiert sich von selbst. Mehrere Tasks parallel; jeder bekommt eine eigene Dashboard-Sektion mit Neon-Progressbar, sobald der Task ReportProgress aus gulp-mu-gulp-api meldet.

Installation (DE)

µGulp™ ist noch nicht in einem Marketplace veröffentlicht. Zwei Wege zur Installation:

Fertiges VSIX: Das aktuelle Release liegt immer als [packages/microgulp_latest.vsix](packages/microgulp_latest.vsix) bereit (daneben versionierte Builds wie microgulp_V0.5.0.vsix). Installation per:

code --install-extension packages/microgulp_latest.vsix     # VS Code
cursor --install-extension packages/microgulp_latest.vsix   # Cursor AI

Aus den Quellen bauen: npm install, dann npm run build — das frische .vsix landet in packages/.

Danach in der Befehlspalette µGulp: Open Dashboard ausführen (oder auf die µGulp™-Rakete in der Statusleiste klicken).

PhpStorm (Testversion)

Ein PhpStorm-Plugin liegt als [packages/microgulp-phpstorm_latest.zip](packages/microgulp-phpstorm_latest.zip) bereit: Installation über Settings → Plugins → ⚙ → Install Plugin from Disk…, danach das Toolwindow µGulp öffnen. Das Plugin ist ein dünner JCEF-Adapter — die gesamte Engine läuft in einem mitgelieferten Node.js-Sidecar, daher muss Node.js 22+ installiert sein (im PATH, oder Umgebungsvariable MICROGULP_NODE auf die Binary setzen). Neu bauen mit npm run phpstorm (kompiliert gegen eine installierte JetBrains-IDE, kein Gradle nötig).

Dasselbe Dashboard läuft auch in jedem Browser: npm run serve -- --cwd <projekt> --http 9310 --preload, dann http://127.0.0.1:9310/ öffnen.

Konfigurationsdatei `microgulp.config.json` (PhpStorm & CLI)

In VS Code / Cursor wird die Engine über die Erweiterungseinstellungen konfiguriert (microgulp.gulpfilePattern usw.). Hosts ohne eigene Einstellungsoberfläche — das PhpStorm-Plugin und der CLI-/Browser-Betrieb über microgulp-serve — lesen stattdessen eine optionale **microgulp.config.json** im Projektstamm:

{
	"gulpfilePattern": "gulpfile.*\\.mjs$",
	"poolSize": 2,
	"maxParallel": 6,
	"preload": true,
	"watchGulpfiles": true
}

Schlüssel	Typ	Default	Bedeutung
`gulpfile`	String	`"gulpfile.mjs"`	Einzelnes Gulpfile, relativ zum Projektstamm
`gulpfilePattern`	String	—	Case-insensitives Regex gegen workspace-relative POSIX-Pfade; findet alle passenden Gulpfiles (hat Vorrang vor `gulpfile`)
`poolSize`	Int ≥ 0	`2`	Warme Worker pro Gulpfile
`maxParallel`	Int ≥ 1	`6`	Maximal gleichzeitige Task-Läufe
`preload`	Bool	`false`	Worker-Pools direkt nach dem Start vorwärmen (das PhpStorm-Plugin aktiviert dies immer)
`watchGulpfiles`	Bool	`true`	Automatischer Rescan bei Gulpfile-Änderungen
`logToFile`	Bool	`true`	Run-Transkripte (`.log` + `.ndjson`) und die Task-Historie auf die Festplatte schreiben
`logDirectory`	String	`.microgulp/logs`	Verzeichnis für Transkripte und den Historie-Index, relativ zum Projektstamm
`logRetention`	Int ≥ 0	`200`	Maximale Anzahl Runs in der Historie (0 = unbegrenzt); ältere Runs und ihre Logdateien werden entfernt

Vorrang: Kommandozeilen-Argumente > microgulp.config.json > eingebaute Defaults. Ungültige Werte und unbekannte Schlüssel werden mit einer Warnung auf stderr ignoriert; die Datei ist versionierbar und gilt damit fürs ganze Team. Nach dem Bearbeiten der Datei das PhpStorm-Toolwindow neu öffnen (startet den Sidecar neu) bzw. microgulp-serve neu starten.

Projektstruktur

Die kommentierte Verzeichnisübersicht steht im englischen Abschnitt unter Project structure — die Pfade und Kommentare gelten unverändert.

Architekturprinzipien

Engine-Schicht ist IDE-frei. src/engine und src/worker kennen keine VS-Code-APIs. Die Kommunikation läuft über Events (Engine → Host) und Plain-JSON-Kommandos (Host → Engine). Damit ist die Portierung auf PhpStorm (Phase 2) ein reiner Adapter-Tausch — der minimale Sidecar npm run serve (src/host/microgulp-serve.mjs, NDJSON auf stdio) ist bereits vorbereitet.
Task-Preloading. Der TaskWorkerPool hält vorgewärmte Node-Prozesse bereit, in denen das Gulpfile bereits importiert wurde. Beim Start eines Tasks wird ein warmer Worker übergeben und der Pool im Hintergrund aufgefüllt. Nach einem Lauf wird der Prozess verworfen (frischer Modulzustand).
Dynamische Imports. Schwere npm-Pakete (mssql, docx-templates, makensis, …) dürfen im Gulpfile nur per await import() im Task-Body geladen werden — statische Top-Level-Imports sind der Orchestrator-Kernlogik vorbehalten.
Sprachen. GUI-Texte sind American English und laufen über String.i18xTrans() (i18xe-Anbindung folgt); Code-Kommentare English; Handbücher/Dokumentation Deutsch.

Gulpfile-Erkennung (per Regex konfigurierbar)

Gulpfile-Änderungen auf der Festplatte erkennt µGulp™ von selbst: Ein Workspace-Watcher (microgulp.watchGulpfiles, Standard an) scannt nach jeder Änderung automatisch neu und tauscht die warmen Worker gegen frische mit dem aktuellen Code. Während des Scans zeigt die Task-Liste eine animierte Fortschrittsanzeige; das Dashboard hat deshalb keinen Rescan-Button mehr — der Befehl µGulp: Rescan Tasks (Befehlspalette) bleibt als manueller Force-Refresh bestehen. Lädt ein Gulpfile nicht (Syntaxfehler, fehlendes Modul), erscheint ein schließbares Fehlerbanner mit Diagnose und Stack-Trace direkt im Dashboard.

µGulp™ findet Gulpfiles wahlweise über einen einzelnen Pfad oder über ein Regex-Muster, das den gesamten Workspace durchsucht:

microgulp.gulpfilePattern — ein JavaScript-Regex (case-insensitive), das gegen den workspace-relativen Pfad (POSIX-Schreibweise mit /) getestet wird. Ist es gesetzt, wird jede passende Datei gescannt; die Tasks werden im Dashboard nach ihrer Quelle gruppiert. Beispiel: (^|/)gulpfile\.(m|c)?js$ findet gulpfile.mjs/.js/.cjs im Stamm und in jedem Unterordner.
microgulp.gulpfilePath — der klassische Einzelpfad (Default gulpfile.mjs). Wird nur verwendet, wenn gulpfilePattern leer ist.

node_modules, .git und versteckte Ordner (.*) werden bei der Suche nie betreten. Jedes gefundene Gulpfile bekommt einen eigenen warmen Worker-Pool mit dem Verzeichnis des Gulpfiles als Arbeitsverzeichnis, sodass verschachtelte Unterprojekte mit relativen Pfaden korrekt laufen. Die Discovery-Logik liegt IDE-unabhängig in src/engine/GulpfileDiscovery.mjs und steht damit auch der CLI und dem späteren PhpStorm-Adapter zur Verfügung.

µGulp™-Metadaten am Gulp-Task

Empfohlen sind µ-präfixierte Tags in CamelCase (µDisplayName, µIcon, …) — sie sind für die klassische gulp-CLI unsichtbar, dadurch bleiben Gulpfiles auf Systemen ohne µGulp™ voll kompatibel (die gulp-CLI adressiert Tasks über function.displayName; ein hübscher Name mit Leerzeichen würde dort die Task-Adressierung brechen). Das Code-Beispiel steht im englischen Abschnitt unter µGulp™ metadata on a Gulp task.

µGroup ordnet den Task einer verschachtelten Gruppe in der Task-Übersicht zu. Die Definition folgt einer Verzeichnis-Pfadsyntax: µGroup = 'Build/Production' erzeugt die Gruppe Build mit Untergruppe Production. Gruppen sind im Dashboard ein-/ausklappbar; Tasks ohne µGroup stehen auf oberster Ebene. Die Zuordnung ist optional und rein visuell — sie hat keinen Einfluss auf Ausführung oder Concurrency.

µOrder legt die Sortierposition in der linken Spalte fest (aufsteigende Ganzzahl). Geschwister-Tasks und -Gruppen werden nach µOrder sortiert; Tasks ohne Wert erscheinen nach allen sortierten Tasks (Tie-Breaker: Anzeigename). Gruppen sortieren nach dem kleinsten µOrder in ihrem Unterbaum.

Sondertasten am Gruppen-Header:

Aktion	Wirkung
Klick	Gruppe auf-/zuklappen
Strg+Klick (Cmd+Klick)	alle Gruppen derselben Ebene auf-/zuklappen
Alt+Klick	alle Gruppen auf-/zuklappen

Fallback-Kaskade pro Eigenschaft: µDisplayName → ugulp.displayName (Namespace-Objekt) → displayName (Gulps eigenes Feld) → Exportname. executionRestrictions unterstützt deny (gewinnt immer) und allow (Whitelist: alles Nichtgelistete ist verboten).

Metadaten-Strings nutzen i18x mit eingebettetem Kontext-Tag und .i18xRegister() (für i18xe-sync und Dashboard-Übersetzung):

BUILD_STYLES.µDisplayName = 'Build Styles<context="µDisplayName"/>'.i18xRegister();
BUILD_STYLES.µDescription = 'Compiles the µCSS skin into deploy-ready stylesheets.<context="µDescription"/>'.i18xRegister();
BUILD_STYLES.µGroup = 'Build/Assets<context="µGroup"/>'.i18xRegister();

Gulpfile-Migration mit KI

Zum Umbau eines bestehenden Gulpfiles (Konsolenausgabe, Task-Metadaten, i18x/gulp-Wörterbücher) liegt ein gepflegter Prompt im Repository:

Datei	Zweck
`dev/prompts/OptimizeGulpfileForMicroGulp.md`	Copy-Paste-Prompt für Cursor, Claude, ChatGPT, …
`dev/prompts/OptimizeGulpfileForMicroGulp.params.example.json`	Parameter-Vorlage (Projektpfad, Gulpfile-Name, unterstützte Sprachen, `gulp-mu-gulp-api`-Version)

Ablauf

Parameter-Beispiel ins Projektstammverzeichnis kopieren als microgulp-optimize.params.json und ausfüllen: projectRoot, gulpfilePath, supportedLanguages (z. B. en-US, de-DE, zh-CN), gulpMuGulpApiVersion (^0.3.0 oder neuer), sowie githubRepoUrl / githubRef (Standard: https://github.com/mamekudz/microGulp, main).
Prompt-Markdown öffnen, {{PLACEHOLDER}}-Tabelle mit den Werten ersetzen (oder in Cursor Params-Datei und Gulpfile anhängen).
Migration durch die KI ausführen lassen. Schritt 0 im Prompt ist Pflicht: zeitgestempeltes Backup des Gulpfiles (z. B. gulpfile.mjs.20260703-142559.bak) vor jeder Änderung.
Prüfen mit node --check gulpfile.mjs, Tasks im µGulp-Dashboard testen, dann gulpfile.mjs, i18x/gulp/*.json und package.json committen.

Verbraucherprojekte brauchen nur i18x/gulp/<lid>.json — kein i18x/prod. Den Prompt bei µGulp-Releases aktualisieren; vor einer Migration die aktuelle Version in diesem Repository prüfen. Der Prompt enthält einen ausführlichen i18x-Regeln-Abschnitt (Register vs. Translate, Richtig/Falsch-Beispiele, i18xe-sync-Scanning, kein µMeta) — Schritt 3 vor dem KI-Lauf lesen.

Öffentliche Task-API (gulp-mu-gulp-api)

Fremde Gulpfiles und npm-Pakete innerhalb des Streams nutzen die erweiterten Dashboard-Funktionen über das eigenständige npm-Modul **gulp-mu-gulp-api** (liegt als eigenes Projekt unter gulp-mu-gulp-api/, wird separat auf npm veröffentlicht). Das Code-Beispiel steht im englischen Abschnitt unter Public task API.

Das Modul ist abhängigkeitsfrei und spricht direkt über den IPC-Kanal des µGulp™-Workers mit der Engine (Erkennung via IsMicroGulp() / IsµGulp()). Ohne µGulp™ degradiert alles sauber: Fortschritt aufs Terminal, Eingaben per readline (TTY) oder Default-Werte (CI). Details in gulp-mu-gulp-api/README.md. Das interne Modul src/bridge/gulp-ugulp-bridge.mjs bleibt als Low-Level-Transport bestehen; neue Consumer sollten gulp-mu-gulp-api verwenden.

µGulp-ready-Zertifizierung

npm-Module, deren Root-Gulpfile vollständig ins µGulp-Dashboard integriert ist, dürfen das µGulp ready-Logo auf npm-README und Projektseiten zeigen.

Anforderung	Detail
Gulpfile	Exportierte Tasks mit µGulp-Metadaten (`µDisplayName`, `µDescription`, `µGroup`, …)
API	Nutzung von `gulp-mu-gulp-api` für Logging, Fortschritt und optionale Dashboard-Features
CLI-Fallback	Tasks bleiben mit plain `gulp` / `npx gulp` lauffähig, wenn µGulp nicht installiert ist
Badge-Asset	Kanonisches PNG: `media/microgulp-ready.png` im µGulp-Repo. npm-README: absolute raw-URL (npm schreibt relative Pfade auf `microCSS/HEAD/...` um). Beispiel: `<img src="https://raw.githubusercontent.com/mamekudz/microGulp/main/media/microgulp-ready.png" …>` in `<a href="https://github.com/mamekudz/microGulp">`
package.json	Optional `"microgulp": { "ready": true, "certifiedSince": "<semver>" }` für maschinenlesbare Erkennung

Zertifizierte Module

npm-Paket	Seit	Hinweis
`gulp-mu-gulp-api`	0.3.2	Offizielle Task-API — `Log`, `ReportProgress`, i18x-Konsolenschicht, Dashboard-Formulare; npm-README-Badge ab 0.3.3
`gulp-mu-css` (µCSS™)	2.5.15	Monorepo-Root-`gulpfile.mjs` mit vollständigen Task-Metadaten, `i18x/gulp/` (en-US, de-DE) und `LogBuildDebugReport` bei Demo-Builds; npm-README-Badge per absoluter raw-URL ab 2.5.14
`gulp-mu-ps` (µPS)	1.3.5	Test-/Render-Tasks im gemeinsamen Root-`gulpfile.mjs` (`TEST_MICROPS`, `RENDER_EXAMPLES`, …)
`gulp-mu-ft` (µFT)	0.1.5	Test-Task `TEST_MICROFT` im gemeinsamen Root-`gulpfile.mjs`
`gulp-mu-au` (µAU)	0.1.6	Test-Task `TEST_MICROAU` im gemeinsamen Root-`gulpfile.mjs`

Migration mit dev/prompts/OptimizeGulpfileForMicroGulp.md; Zertifizierung per Issue oder PR im µGulp- oder Modul-Repository.

Versionierung (RELEASES.json)

µGulp™ versioniert über **RELEASES.json** im Projektstamm als einzige Versionsquelle. Jeder Release-Eintrag enthält main/minor/revision, Zeitstempel, beta-Flag und eine Liste von Info-Texten. Die Info-Texte tragen den i18x-Kontext-Tag <context="release info"/> und werden über String.i18xRegister() registriert, sodass die i18xe-Engine sie automatisch übersetzen kann.

Das Modul src/engine/ReleaseInfo.mjs liefert dazu:

GetVersionString() / GetFullVersionString() — "0.2.0" bzw. "0.1.4ß" (ß-Suffix für Beta-Builds).
GetVersionHistoryText({ maxReleases, includeBeta }) — die komplette Historie als formatierter String für die Konsole (Task SHOW_VERSION_HISTORY bzw. npm run history).
BUILD_PACKAGE synchronisiert die package.json-Version und die Versionszeile am Kopf dieses READMEs automatisch aus RELEASES.json und stempelt sie in den Artefaktnamen (microgulp_V0.2.0.vsix, Betas mit Suffix _beta). Für ein neues Release genügt also ein neuer Eintrag oben in RELEASES.json.

Projekt-Build (gulpfile.mjs)

Das Projekt baut sich selbst über sein eigenes Gulpfile (Dogfooding: läuft im µGulp™-Dashboard, über die gulp-CLI, über klassische Gulp-IDE-Erweiterungen und headless):

Aufruf	Task	Zweck
`npm test`	`RUN_TESTS`	node:test-Suiten in `tests/` (Unit + Engine-Integration mit echten Worker-Prozessen)
`npm run theme`	`CREATE_THEME_DATA`	Kompiliert jedes `skins/<name>/<name>.µ.css` via µCSS (`gulp-mu-css` `BuildSkin`) nach `src/webview/skins/<name>/dashboard.css` (Standard: `neon-carbon`)
`npm run package`	`BUILD_PACKAGE`	Staged die Extension nach `tmp/package/` und erzeugt das `.vsix` in `packages/` (zusätzlich aktualisiert als `microgulp_latest.vsix`)
`npm run deploy`	`DEPLOY_EXTENSION`	Update-Zyklus automatisiert: `.vsix` bauen und per `cursor --install-extension` installieren (danach Fenster neu laden)
`npm run build`	`BUILD_ALL`	Komplette Pipeline: Clean → Tests → Theme → Paket
`npm run history`	`SHOW_VERSION_HISTORY`	Gibt die formatierte Versionshistorie aus `RELEASES.json` auf der Konsole aus
—	`PUBLISH_API`	Veröffentlicht `gulp-mu-gulp-api` auf npm (führt vorher dessen Tests aus; `npm login` erforderlich)
—	`CLEAN`	Entfernt `tmp/` und `packages/` (exklusiv, Schreibsperre)

Hinweise:

gulp-mu-css ist als lokale file:-Abhängigkeit auf C:\Projects\microCSS\gulp-mu-css eingebunden und wird — wie alle schweren Pakete — erst im Task-Body per await import() geladen.
BUILD_PACKAGE erzeugt ein echtes .vsix, sobald @vscode/vsce installiert ist (npm i -D @vscode/vsce); ohne vsce fällt der Task auf ein Zip des Staging-Ordners zurück.
Skins sind eigenständig: ein Verzeichnis pro Skin unter skins/ (z. B. skins/neon-carbon/, skins/ice-light/), jeweils mit einem <name>.µcss.mjs-Manifest und einer gleichnamigen <name>.µ.css-Quelle. CREATE_THEME_DATA erkennt und baut jeden Skin; neon-carbon (dunkel) ist der Standard, ice-light liefert ein helles Frostglas-Pendant. Weitere/eigene Skins lassen sich als Geschwister-Verzeichnisse ergänzen. Die Skin-Auswahl im Dashboard (Einstellungen → Erscheinungsbild) bietet einen Automatik-Modus, der dem hellen/dunklen IDE-/OS-Theme folgt.
Das Webview bevorzugt automatisch das generierte Standard-Skin (src/webview/skins/neon-carbon/dashboard.css); das handgeschriebene dashboard.css bleibt als Fallback für frische Checkouts.
Das Dashboard zeigt links neben dem Neon-Schriftzug µGulp™ das gelbe Mikroskop (baselogo.svg) per µCSS-Data-URI-Inlining (background-image: µ(DataUri("imgs/baselogo.svg"))). Quelle aller fertigen Art-Assets ist dev/media/final/; der Build synchronisiert daraus media/logo.png (Extension-Icon), media/logo_readme.png (README), src/webview/skins/<name>/imgs/baselogo.svg (Dashboard) und phpstorm/resources/icons/baseoutlinelogo.svg (PhpStorm-Toolwindow + Plugin-Liste).

Ausprobieren

Headless (ohne IDE):

npm run demo

Scannt demo/gulpfile.mjs, wärmt den Pool vor, startet zwei parallele Tasks, einen exklusiven Task (wartet in der Queue) und einen absichtlich fehlschlagenden Task (Diagnose-Engine).

Als Extension: In VS Code/Cursor F5 drücken (Launch-Konfiguration „Run µGulp Extension"), dann im Entwicklungs-Host µGulp: Open Dashboard ausführen.

Lizenz

µGulp™ (Extension, Engine, Dashboard, PhpStorm-Adapter) ist proprietäre Software — siehe LICENSE. Die verteilten Binärdateien dürfen kostenlos genutzt werden; Kopieren, Ändern oder Weiterverbreiten des Quellcodes ist nicht gestattet.

Das begleitende npm-Paket gulp-mu-gulp-api bleibt unter der MIT-Lizenz, damit Gulp-Tasks es uneingeschränkt einbinden können.

Roadmap / offene Punkte des Entwurfs

In V0.5.0 umgesetzt

Noch offen

Explizite Task-Reihenfolge im Dashboard (µOrder-Metadaten)
µLib (microLib) dokumentieren, danach als Utility-Schicht in µGulp einsetzen (i18x ist derzeit eine lokale Webview-Teilmenge)
Direkte i18xe-Server-Anbindung: Live-Übersetzungssync statt der mitgelieferten de-DE/zh-CN-Wörterbücher
GUI.mjs aus µLib um weitere spezielle Steuerelemente für die Dashboard-Formulare erweitern
Optisches Feintuning des Webview-Dashboards
µCSS-Skin ausbauen: Symbol-Font, Sprites und Sounds ins Manifest aufnehmen
Audio-Engine: hochwertige Sounds + Sprachausgabe über i18xe statt WebAudio-Beeps / Web Speech API
PhpStorm-Plugin: Feinschliff über die Testversion hinaus (optionale Settings-UI, Marketplace-Verteilung)
VS-Code-/Cursor-Erweiterung in einem Marketplace veröffentlichen

Name		Name	Last commit message	Last commit date
Latest commit History 39 Commits
.github/workflows		.github/workflows
.vscode		.vscode
demo		demo
dev		dev
gulp-mu-gulp-api		gulp-mu-gulp-api
i18x/gulp		i18x/gulp
media		media
packages		packages
phpstorm		phpstorm
skins		skins
src		src
tests		tests
.gitignore		.gitignore
.vscodeignore		.vscodeignore
LICENSE		LICENSE
README.md		README.md
RELEASES.json		RELEASES.json
gulpfile.mjs		gulpfile.mjs
package-lock.json		package-lock.json
package.json		package.json

Folders and files

Latest commit

History

Repository files navigation

µGulp™ (microGulp)

English

Highlights

Snapshot

Installation

PhpStorm (test build)

Configuration file microgulp.config.json (PhpStorm & CLI)

Project structure

Architecture principles

Gulpfile discovery (regex-configurable)

µGulp™ metadata on a Gulp task

AI-assisted gulpfile migration

Public task API (gulp-mu-gulp-api)

µGulp ready certification

Versioning (RELEASES.json)

Project build (gulpfile.mjs)

Try it

License

Roadmap / open points of this draft

Shipped in V0.5.0

Still open

Deutsch

Highlights

Snapshot

Installation (DE)

PhpStorm (Testversion)

Konfigurationsdatei microgulp.config.json (PhpStorm & CLI)

Projektstruktur

Architekturprinzipien

Gulpfile-Erkennung (per Regex konfigurierbar)

µGulp™-Metadaten am Gulp-Task

Gulpfile-Migration mit KI

Öffentliche Task-API (gulp-mu-gulp-api)

µGulp-ready-Zertifizierung

Versionierung (RELEASES.json)

Projekt-Build (gulpfile.mjs)

Ausprobieren

Lizenz

Roadmap / offene Punkte des Entwurfs

In V0.5.0 umgesetzt

Noch offen

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases 12

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Configuration file `microgulp.config.json` (PhpStorm & CLI)

Konfigurationsdatei `microgulp.config.json` (PhpStorm & CLI)

Packages