@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/cdh/cli_logging.py

@@ -1,45 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,176 +0,0 @@
-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

@@ -1,14 +0,0 @@
-# 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

@@ -1,7 +0,0 @@
--- 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

@@ -1,14 +0,0 @@
-# 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"]