@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/cdh/cli_logging.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import logging
+from logging.handlers import TimedRotatingFileHandler
+from pathlib import Path
+
+
+LOG_DIR = Path.home() / ".cdh" / "logs"
+LOG_FILE = LOG_DIR / "cdh.log"
+LOG_BACKUP_COUNT = 7
+
+_VALID_LOG_LEVELS = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
+
+
+def setup_logging(log_level: str = "INFO") -> logging.Logger:
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    level = log_level.upper()
+    if level not in _VALID_LOG_LEVELS:
+        level = "INFO"
+    numeric_level = getattr(logging, level)
+
+    handler = TimedRotatingFileHandler(
+        LOG_FILE,
+        when="midnight",
+        interval=1,
+        backupCount=LOG_BACKUP_COUNT,
+        encoding="utf-8",
+        utc=False,
+    )
+    handler.suffix = "%Y-%m-%d"
+    handler.setFormatter(
+        logging.Formatter("%(asctime)s [%(name)s] %(levelname)s: %(message)s")
+    )
+
+    root = logging.getLogger()
+    root.setLevel(numeric_level)
+    for h in list(root.handlers):
+        if isinstance(h, TimedRotatingFileHandler) and getattr(h, "baseFilename", "") == str(LOG_FILE):
+            root.removeHandler(h)
+    root.addHandler(handler)
+
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("httpcore").setLevel(logging.WARNING)
+
+    return root

package/cdh/config.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+
+ACTIVE_PROJECT_PATH = Path.home() / ".cdh" / "active_project.yaml"
+
+
+def read_active_project() -> dict | None:
+    if not ACTIVE_PROJECT_PATH.exists():
+        return None
+    try:
+        return yaml.safe_load(ACTIVE_PROJECT_PATH.read_text(encoding="utf-8")) or None
+    except Exception:
+        return None
+
+
+def write_active_project(name: str, path: str) -> None:
+    ACTIVE_PROJECT_PATH.parent.mkdir(parents=True, exist_ok=True)
+    data = {"name": name, "path": path}
+    ACTIVE_PROJECT_PATH.write_text(yaml.dump(data, default_flow_style=False), encoding="utf-8")
+
+
+def clear_active_project() -> None:
+    if ACTIVE_PROJECT_PATH.exists():
+        ACTIVE_PROJECT_PATH.unlink()

package/cdh/event_loop/__init__.py

@@ -0,0 +1,7 @@
+from cdh.event_loop.bus import EventBus, EventHandler, EventLoopState
+from cdh.event_loop.events import Event, EventTypes
+from cdh.event_loop.scheduler import Scheduler, ScheduledJob
+from cdh.event_loop.runner import EventRunner
+
+__all__ = ["EventBus", "EventHandler", "EventLoopState", "Event", "EventTypes",
+           "Scheduler", "ScheduledJob", "EventRunner"]

package/cdh/event_loop/bus.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Callable
+
+from cdh.event_loop.events import Event
+
+logger = logging.getLogger("cdh.event_loop.bus")
+
+EventHandler = Callable[[Event], None]
+
+
+class EventLoopState(Enum):
+    IDLE = "idle"
+    RUNNING = "running"
+    PAUSED = "paused"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+def _is_async(handler: EventHandler) -> bool:
+    return asyncio.iscoroutinefunction(handler) or (
+        hasattr(handler, "__func__")
+        and asyncio.iscoroutinefunction(handler.__func__)  # type: ignore[attr-defined]
+    )
+
+
+@dataclass
+class EventBus:
+    state: EventLoopState = EventLoopState.IDLE
+    _subscribers: dict[str, list[EventHandler]] = field(default_factory=dict)
+    _history: list[Event] = field(default_factory=list)
+    _max_history: int = 1000
+    _pending_tasks: set[asyncio.Task] = field(default_factory=set)
+    _max_pending_tasks: int = 100
+
+    def subscribe(self, event_type: str, handler: EventHandler) -> None:
+        if event_type not in self._subscribers:
+            self._subscribers[event_type] = []
+        self._subscribers[event_type].append(handler)
+        logger.debug("Subscribed %s to %s", getattr(handler, "__name__", handler), event_type)
+
+    def unsubscribe(self, event_type: str, handler: EventHandler) -> None:
+        if event_type in self._subscribers:
+            self._subscribers[event_type] = [
+                h for h in self._subscribers[event_type] if h != handler
+            ]
+
+    def _cleanup_finished_tasks(self) -> None:
+        self._pending_tasks = {t for t in self._pending_tasks if not t.done()}
+
+    def publish(self, event: Event) -> None:
+        self._history.append(event)
+        if len(self._history) > self._max_history:
+            self._history = self._history[-self._max_history:]
+
+        handlers = self._subscribers.get(event.type, [])
+        if not handlers:
+            return
+
+        self._cleanup_finished_tasks()
+
+        try:
+            loop = asyncio.get_running_loop()
+            for handler in handlers:
+                if _is_async(handler):
+                    if len(self._pending_tasks) >= self._max_pending_tasks:
+                        logger.warning(
+                            "EventBus: pending task limit (%d) reached, skipping async handler %s",
+                            self._max_pending_tasks,
+                            getattr(handler, "__name__", handler),
+                        )
+                        continue
+                    task = loop.create_task(self._invoke_async(handler, event))
+                    self._pending_tasks.add(task)
+                    task.add_done_callback(self._pending_tasks.discard)
+                else:
+                    self._invoke_sync(handler, event)
+        except RuntimeError:
+            for handler in handlers:
+                if _is_async(handler):
+                    logger.debug(
+                        "Skipping async handler %s — no running event loop",
+                        getattr(handler, "__name__", handler),
+                    )
+                else:
+                    self._invoke_sync(handler, event)
+
+    async def _invoke_async(self, handler: EventHandler, event: Event) -> None:
+        try:
+            await handler(event)
+        except Exception as exc:
+            logger.warning(
+                "Async handler %s failed on event %s: %s",
+                getattr(handler, "__name__", handler), event.type, exc,
+                exc_info=True,
+            )
+
+    def _invoke_sync(self, handler: EventHandler, event: Event) -> None:
+        try:
+            handler(event)
+        except Exception as exc:
+            logger.warning(
+                "Handler %s failed on event %s: %s",
+                getattr(handler, "__name__", handler), event.type, exc,
+                exc_info=True,
+            )
+
+    def get_history(self, event_type: str | None = None,
+                    limit: int = 100) -> list[Event]:
+        filtered = self._history
+        if event_type:
+            filtered = [e for e in self._history if e.type == event_type]
+        return filtered[-limit:]
+
+    def start(self) -> None:
+        self.state = EventLoopState.RUNNING
+
+    def stop(self) -> None:
+        self.state = EventLoopState.COMPLETED

package/cdh/event_loop/events.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+
+
+@dataclass
+class Event:
+    type: str
+    source: str
+    payload: dict[str, Any]
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+
+class EventTypes:
+    SESSION_ENDED = "session.ended"
+    SESSION_STARTED = "session.started"
+    VERIFICATION_PASSED = "verification.passed"
+    VERIFICATION_FAILED = "verification.failed"
+    CRON_TICK = "cron.tick"
+    FILE_CHANGED = "file.changed"
+    CONFIG_CHANGED = "config.changed"
+    TOOL_EXECUTED = "tool.executed"
+    TOOL_FAILED = "tool.failed"

package/cdh/event_loop/runner.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import logging
+
+from cdh.event_loop.bus import EventBus
+from cdh.event_loop.events import Event, EventTypes
+
+logger = logging.getLogger("cdh.event_loop.runner")
+
+
+class EventRunner:
+    def __init__(self, bus: EventBus):
+        self.bus = bus
+
+    def subscribe_all(self) -> None:
+        self.bus.subscribe(EventTypes.CRON_TICK, self._on_cron_tick)
+        self.bus.subscribe(EventTypes.FILE_CHANGED, self._on_file_changed)
+
+    def _on_cron_tick(self, event: Event) -> None:
+        payload = event.payload
+        job_name = payload.get("job_name", "unknown")
+        command = payload.get("command", "")
+        engine_name = payload.get("engine", "onecode")
+        logger.info("Cron tick: job=%s engine=%s command=%s", job_name, engine_name, command)
+
+    def _on_file_changed(self, event: Event) -> None:
+        path = event.payload.get("path", "")
+        logger.info("File changed: %s", path)

package/cdh/event_loop/scheduler.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+from cdh.event_loop.bus import EventBus, EventLoopState
+from cdh.event_loop.events import Event, EventTypes
+
+logger = logging.getLogger("cdh.event_loop.scheduler")
+
+
+@dataclass
+class ScheduledJob:
+    name: str
+    interval_seconds: int
+    command: str
+    args: dict[str, Any] = field(default_factory=dict)
+    engine: str = "onecode"
+    next_run: datetime | None = None
+    last_run: datetime | None = None
+    active: bool = True
+    run_count: int = 0
+
+
+class Scheduler:
+    def __init__(self, db_path: Path | None = None):
+        self.state = EventLoopState.IDLE
+        self._jobs: dict[str, ScheduledJob] = {}
+        self._db_path = db_path or (Path.home() / ".cdh" / "scheduler.db")
+        self._task: asyncio.Task | None = None
+
+    def add(self, job: ScheduledJob) -> str:
+        now = datetime.now(timezone.utc)
+        job.next_run = now + timedelta(seconds=job.interval_seconds)
+        self._jobs[job.name] = job
+        self._save_jobs()
+        return job.name
+
+    def remove(self, name: str) -> bool:
+        result = self._jobs.pop(name, None) is not None
+        if result:
+            self._save_jobs()
+        return result
+
+    def pause(self, name: str) -> bool:
+        job = self._jobs.get(name)
+        if job:
+            job.active = False
+            self._save_jobs()
+            return True
+        return False
+
+    def resume(self, name: str) -> bool:
+        job = self._jobs.get(name)
+        if job:
+            job.active = True
+            job.next_run = datetime.now(timezone.utc) + timedelta(seconds=job.interval_seconds)
+            self._save_jobs()
+            return True
+        return False
+
+    def list(self) -> list[dict]:
+        return [
+            {
+                "name": j.name,
+                "interval_seconds": j.interval_seconds,
+                "command": j.command,
+                "engine": j.engine,
+                "active": j.active,
+                "run_count": j.run_count,
+                "next_run": j.next_run.isoformat() if j.next_run else None,
+                "last_run": j.last_run.isoformat() if j.last_run else None,
+            }
+            for j in self._jobs.values()
+        ]
+
+    async def start(self, bus: EventBus) -> None:
+        self.state = EventLoopState.RUNNING
+        self._load_jobs()
+
+        async def _tick() -> None:
+            while self.state == EventLoopState.RUNNING:
+                now = datetime.now(timezone.utc)
+                for job in list(self._jobs.values()):
+                    if job.active and job.next_run and now >= job.next_run:
+                        job.last_run = now
+                        job.next_run = now + timedelta(seconds=job.interval_seconds)
+                        job.run_count += 1
+                        bus.publish(Event(
+                            type=EventTypes.CRON_TICK,
+                            source="cdh.scheduler",
+                            payload={
+                                "job_name": job.name,
+                                "command": job.command,
+                                "args": job.args,
+                                "engine": job.engine,
+                            },
+                        ))
+                await asyncio.sleep(1)
+
+        self._task = asyncio.create_task(_tick())
+        logger.info("Scheduler started with %d jobs", len(self._jobs))
+
+    def stop(self) -> None:
+        self.state = EventLoopState.COMPLETED
+        if self._task:
+            self._task.cancel()
+            self._task = None
+        self._save_jobs()
+        logger.info("Scheduler stopped")
+
+    def _save_jobs(self) -> None:
+        data = {}
+        for name, j in self._jobs.items():
+            entry = {
+                "name": j.name,
+                "interval_seconds": j.interval_seconds,
+                "command": j.command,
+                "args": j.args,
+                "engine": j.engine,
+                "active": j.active,
+                "run_count": j.run_count,
+            }
+            if j.next_run:
+                entry["next_run"] = j.next_run.isoformat()
+            if j.last_run:
+                entry["last_run"] = j.last_run.isoformat()
+            data[name] = entry
+        self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._db_path.write_text(json.dumps(data, indent=2))
+
+    def _load_jobs(self) -> None:
+        if not self._db_path.exists():
+            return
+        try:
+            data = json.loads(self._db_path.read_text())
+            for name, j in data.items():
+                job = ScheduledJob(
+                    name=j.get("name", name),
+                    interval_seconds=j.get("interval_seconds", 300),
+                    command=j.get("command", ""),
+                    args=j.get("args", {}),
+                    engine=j.get("engine", "onecode"),
+                    active=j.get("active", True),
+                    run_count=j.get("run_count", 0),
+                )
+                if j.get("next_run"):
+                    job.next_run = datetime.fromisoformat(j["next_run"])
+                if j.get("last_run"):
+                    job.last_run = datetime.fromisoformat(j["last_run"])
+                self._jobs[name] = job
+        except (json.JSONDecodeError, KeyError, ValueError) as e:
+            logger.warning("Failed to load scheduler jobs: %s", e)

package/cdh/generators/__init__.py

@@ -0,0 +1,35 @@
+from .registry import LANGUAGE_RENDERERS, PluginManifest, discover_plugins, render
+
+from .cli import (
+    discover_all,
+    discover_all_as_dict,
+    discover_all_plugins,
+    discover_all_plugins_merged,
+    filter_by_source,
+    format_index_table,
+    format_plugin_table,
+    get_index_entry,
+    install_plugin,
+    search_index,
+    create_plugin_scaffold,
+    validate_plugin,
+)
+
+__all__ = [
+    "LANGUAGE_RENDERERS",
+    "PluginManifest",
+    "discover_plugins",
+    "discover_all",
+    "discover_all_as_dict",
+    "discover_all_plugins",
+    "discover_all_plugins_merged",
+    "filter_by_source",
+    "render",
+    "search_index",
+    "get_index_entry",
+    "install_plugin",
+    "create_plugin_scaffold",
+    "validate_plugin",
+    "format_plugin_table",
+    "format_index_table",
+]

package/cdh/generators/_runtime.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+
+_KIND_KEYS = ("oneOf", "anyOf")
+
+
+def _identifier(name: str, style: str) -> str:
+    parts = [part for part in re.split(r"[^A-Za-z0-9]+", name) if part]
+    if not parts:
+        parts = ["field"]
+    if style in {"pascal", "go", "csharp", "kotlin", "swift"}:
+        value = "".join(part[:1].upper() + part[1:] for part in parts)
+    elif style in {"snake", "rust"}:
+        value = "_".join(part.lower() for part in parts)
+    else:
+        value = parts[0][:1].lower() + parts[0][1:] + "".join(part[:1].upper() + part[1:] for part in parts[1:])
+    if value[0].isdigit():
+        value = f"T{value}"
+    return value
+
+
+def _ref_name(schema: Mapping[str, Any]) -> str | None:
+    ref = schema.get("$ref")
+    return str(ref).split("/")[-1] if ref else None
+
+
+def _union(schema: Mapping[str, Any], mapper: Callable[[Mapping[str, Any]], str], fallback: str) -> str:
+    for key in _KIND_KEYS:
+        if key in schema:
+            members = [mapper(item) for item in schema[key] if isinstance(item, Mapping)]
+            return " | ".join(members) if members else fallback
+    return fallback
+
+
+def _type_mapper(language: str) -> Callable[[Mapping[str, Any]], str]:
+    def map_type(schema: Mapping[str, Any]) -> str:
+        ref = _ref_name(schema)
+        if ref:
+            return _identifier(ref, "pascal")
+        kind = schema.get("type", "object")
+        fmt = schema.get("format", "")
+        if language == "typescript":
+            union = _union(schema, map_type, "unknown")
+            if any(key in schema for key in _KIND_KEYS):
+                return union
+            base = {"string": "string", "integer": "number", "number": "number", "boolean": "boolean", "object": "Record<string, unknown>"}.get(kind, "unknown")
+            if kind == "array":
+                base = f"{map_type(schema.get('items', {}))}[]"
+            return base
+        if language == "python":
+            if any(key in schema for key in _KIND_KEYS):
+                values = _union(schema, map_type, "Any").split(" | ")
+                return f"Union[{', '.join(values)}]"
+            base = {"string": {"date-time": "datetime", "date": "date", "time": "time"}.get(fmt, "str"), "integer": "int", "number": "float", "boolean": "bool", "object": "dict[str, Any]"}.get(kind, "Any")
+            if kind == "array":
+                base = f"list[{map_type(schema.get('items', {}))}]"
+            return base
+        if language in {"java", "csharp", "kotlin"}:
+            maps = {
+                "java": {"string": {"date-time": "OffsetDateTime", "uuid": "UUID"}.get(fmt, "String"), "integer": "Long", "number": "BigDecimal" if fmt == "double" else "Double", "boolean": "Boolean", "object": "Object"},
+                "csharp": {"string": {"date-time": "DateTimeOffset", "uuid": "Guid"}.get(fmt, "string"), "integer": "long", "number": "decimal" if fmt == "double" else "double", "boolean": "bool", "object": "object"},
+                "kotlin": {"string": {"date-time": "Instant", "uuid": "UUID"}.get(fmt, "String"), "integer": "Long", "number": "Double", "boolean": "Boolean", "object": "Any"},
+            }
+            base = maps[language].get(kind, maps[language]["object"])
+            if kind == "array":
+                wrapper = "List" if language != "csharp" else "IReadOnlyList"
+                base = f"{wrapper}<{map_type(schema.get('items', {}))}>"
+            return base
+        if language == "go":
+            base = {"string": {"date-time": "time.Time", "uuid": "uuid.UUID"}.get(fmt, "string"), "integer": "int64", "number": "float64", "boolean": "bool", "object": "any"}.get(kind, "any")
+            if kind == "array":
+                base = f"[]{map_type(schema.get('items', {}))}"
+            return base
+        if language == "rust":
+            base = {"string": {"date-time": "DateTime<Utc>", "uuid": "Uuid"}.get(fmt, "String"), "integer": "i64", "number": "f64", "boolean": "bool", "object": "serde_json::Value"}.get(kind, "serde_json::Value")
+            if kind == "array":
+                base = f"Vec<{map_type(schema.get('items', {}))}>"
+            return base
+        if language == "swift":
+            base = {"string": {"date-time": "Date", "uuid": "UUID"}.get(fmt, "String"), "integer": "Int", "number": "Double", "boolean": "Bool", "object": "JSONValue"}.get(kind, "JSONValue")
+            if kind == "array":
+                base = f"[{map_type(schema.get('items', {}))}]"
+            return base
+        if language == "graphql-schema":
+            base = {"string": "ID" if fmt == "uuid" else "String", "integer": "Int", "number": "Float", "boolean": "Boolean", "object": "JSON"}.get(kind, "JSON")
+            if kind == "array":
+                base = f"[{map_type(schema.get('items', {}))}!]"
+            return base
+        if language == "protobuf":
+            base = {"string": "string", "integer": "int64", "number": "double", "boolean": "bool", "object": "google.protobuf.Struct"}.get(kind, "google.protobuf.Value")
+            if fmt == "date-time":
+                base = "google.protobuf.Timestamp"
+            if kind == "array":
+                base = f"repeated {map_type(schema.get('items', {}))}"
+            return base
+        return "object"
+    return map_type
+
+
+def _collect_schemas(document: Mapping[str, Any]) -> list[tuple[str, Mapping[str, Any]]]:
+    schemas: list[tuple[str, Mapping[str, Any]]] = []
+    components = document.get("components", {}).get("schemas", {})
+    if isinstance(components, Mapping):
+        schemas.extend((str(name), schema) for name, schema in components.items() if isinstance(schema, Mapping))
+    channels = document.get("channels", {})
+    if isinstance(channels, Mapping):
+        for channel_name, channel in channels.items():
+            if not isinstance(channel, Mapping):
+                continue
+            for direction in ("publish", "subscribe"):
+                message = channel.get(direction, {}).get("message", {})
+                payload = message.get("payload", {}) if isinstance(message, Mapping) else {}
+                if isinstance(payload, Mapping) and payload:
+                    schemas.append((f"{channel_name}_{direction}_payload", payload))
+    return schemas
+
+
+def build_context(document: Mapping[str, Any], source_file: Path | str, language: str, package_name: str | None = None) -> dict[str, Any]:
+    mapper = _type_mapper(language)
+    types: list[dict[str, Any]] = []
+    flags = {"nullable": False, "enums": False, "allOf": False, "oneOf": False, "anyOf": False, "uuid": False, "date-time": False}
+    for raw_name, schema in _collect_schemas(document):
+        required = set(schema.get("required", []))
+        properties: list[dict[str, Any]] = []
+        for index, (json_name, prop) in enumerate(schema.get("properties", {}).items(), 1):
+            if not isinstance(prop, Mapping):
+                continue
+            for flag in flags:
+                flags[flag] = flags[flag] or flag in prop or prop.get("format") == flag
+            is_required = json_name in required
+            is_nullable = bool(prop.get("nullable")) or not is_required
+            value_type = mapper(prop)
+            enum_values = list(prop.get("enum", []))
+            properties.append({
+                "Name": _identifier(str(json_name), "pascal" if language in {"go", "csharp", "kotlin", "swift"} else "snake" if language in {"python", "rust", "protobuf"} else "camel"),
+                "JsonName": str(json_name),
+                "Type": value_type,
+                "Format": str(prop.get("format", "")),
+                "IsRequired": is_required,
+                "IsNullable": is_nullable,
+                "IsEnum": bool(enum_values),
+                "EnumValues": enum_values,
+                "Description": str(prop.get("description", "")),
+                "Children": [],
+                "Index": index,
+                "OptionalType": f"Option<{value_type}>" if language == "rust" and is_nullable else value_type,
+                "NullableType": f"{value_type}?" if language in {"csharp", "kotlin", "swift"} and is_nullable else value_type,
+                "GraphQLType": f"{value_type}!" if is_required and not is_nullable else value_type,
+            })
+            flags["nullable"] = flags["nullable"] or is_nullable
+            flags["enums"] = flags["enums"] or bool(enum_values)
+        types.append({
+            "Name": _identifier(raw_name, "pascal"),
+            "Properties": properties,
+            "Description": str(schema.get("description", "")),
+            "IsEnum": bool(schema.get("enum")),
+            "EnumValues": list(schema.get("enum", [])),
+        })
+        for key in ("allOf", "oneOf", "anyOf"):
+            flags[key] = flags[key] or key in schema
+    return {
+        "PackageName": package_name,
+        "SourceFile": Path(source_file).name,
+        "Types": types,
+        "HasUUID": flags["uuid"],
+        "HasDateTime": flags["date-time"],
+        "HasNullable": flags["nullable"],
+        "HasEnums": flags["enums"],
+        "HasAllOf": flags["allOf"],
+        "HasOneOf": flags["oneOf"],
+        "HasAnyOf": flags["anyOf"],
+    }

package/cdh/generators/ada/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for ada
+[plugin]
+name = "ada"
+display_name = "Ada"
+file_extension = ".ads"
+mime_type = "text/x-ada"
+default_outdir = "ada"
+output_filename_template = "{name}}.ads"
+package_name_default = "Types"
+
+[features]
+enums = true
+nullable = false
+format_hints = ["date-time", "uuid"]

package/cdh/generators/ada/template.ads.tmpl

@@ -0,0 +1,7 @@
+-- Auto-generated from {{.SourceFile}}
+package Types is
+{{range .Types}}   type {{.Name}} is record
+{{range .Properties}}      {{.Name}} : String(1..100);
+{{end}}   end record;
+{{end}}
+end Types;

package/cdh/generators/bash/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for bash
+[plugin]
+name = "bash"
+display_name = "Bash"
+file_extension = ".sh"
+mime_type = "text/x-sh"
+default_outdir = "bash"
+output_filename_template = "{name}}.sh"
+package_name_default = "types"
+
+[features]
+enums = false
+nullable = false
+format_hints = ["date-time", "uuid"]