doql 0.0.1__py3-none-any.whl

doql/__init__.py

@@ -0,0 +1,7 @@
+"""doql — Declarative OQL.
+
+Build complete applications, documents, kiosks, and API integrations
+from a single .doql declaration file.
+"""
+
+__version__ = "0.1.0a1"

doql/cli/__init__.py

@@ -0,0 +1,19 @@
+"""doql CLI package — modularized command-line interface."""
+from __future__ import annotations
+
+from .context import BuildContext, build_context, load_spec, scaffold_from_template, estimate_file_count
+from .lockfile import read_lockfile, write_lockfile, diff_sections, spec_section_hashes
+from .main import main
+
+__all__ = [
+    "BuildContext",
+    "build_context",
+    "load_spec",
+    "scaffold_from_template",
+    "estimate_file_count",
+    "read_lockfile",
+    "write_lockfile",
+    "diff_sections",
+    "spec_section_hashes",
+    "main",
+]

doql/cli/build.py

@@ -0,0 +1,159 @@
+"""Full build logic for the build command.
+
+This module handles complete rebuilds by running all applicable generators.
+"""
+from __future__ import annotations
+
+import sys
+import argparse
+
+from .. import parser as doql_parser
+from ..generators import api_gen, web_gen, mobile_gen, desktop_gen, infra_gen, document_gen, report_gen, i18n_gen, integrations_gen, workflow_gen, ci_gen
+from .. import plugins as _plugins
+from .context import BuildContext, load_spec
+from .lockfile import write_lockfile
+
+
+def should_generate_interface(name: str, spec) -> bool:
+    """Check if interface should be generated.
+    
+    Args:
+        name: Interface name (api, web, mobile, desktop, infra)
+        spec: Parsed DoqlSpec
+        
+    Returns:
+        True if interface should be generated
+    """
+    if name == "infra":
+        return True
+    return any(i.name == name for i in spec.interfaces)
+
+
+def run_core_generators(spec, env_vars, ctx: BuildContext) -> None:
+    """Run core interface generators (api, web, mobile, desktop, infra)."""
+    generators = {
+        "api": api_gen.generate,
+        "web": web_gen.generate,
+        "mobile": mobile_gen.generate,
+        "desktop": desktop_gen.generate,
+        "infra": infra_gen.generate,
+    }
+    
+    for name, fn in generators.items():
+        if not should_generate_interface(name, spec):
+            continue
+        
+        print(f"🛠  Generating {name}...")
+        if name == "infra":
+            target_dir = ctx.build_dir / name
+        else:
+            target_dir = ctx.build_dir / name
+        target_dir.mkdir(parents=True, exist_ok=True)
+        fn(spec, env_vars, target_dir)
+
+
+def run_document_generators(spec, env_vars, ctx: BuildContext) -> None:
+    """Run document generators if documents are defined."""
+    if not spec.documents:
+        return
+    
+    print("🛠  Generating documents...")
+    doc_dir = ctx.build_dir / "documents"
+    doc_dir.mkdir(parents=True, exist_ok=True)
+    document_gen.generate(spec, env_vars, doc_dir, project_root=ctx.root)
+
+
+def run_report_generators(spec, env_vars, ctx: BuildContext) -> None:
+    """Run report generators if reports are defined."""
+    if not spec.reports:
+        return
+    
+    print("🛠  Generating reports...")
+    rpt_dir = ctx.build_dir / "reports"
+    rpt_dir.mkdir(parents=True, exist_ok=True)
+    report_gen.generate(spec, env_vars, rpt_dir)
+
+
+def run_i18n_generators(spec, env_vars, ctx: BuildContext) -> None:
+    """Run i18n generators if languages are defined."""
+    if not spec.languages:
+        return
+    
+    print("🛠  Generating i18n...")
+    i18n_dir = ctx.build_dir / "i18n"
+    i18n_dir.mkdir(parents=True, exist_ok=True)
+    i18n_gen.generate(spec, env_vars, i18n_dir)
+
+
+def run_integration_generators(spec, env_vars, ctx: BuildContext) -> None:
+    """Run integration generators if integrations are defined."""
+    if not (spec.integrations or spec.api_clients or spec.webhooks):
+        return
+    
+    print("🛠  Generating integrations...")
+    svc_dir = ctx.build_dir / "api" / "services"
+    svc_dir.mkdir(parents=True, exist_ok=True)
+    integrations_gen.generate(spec, env_vars, svc_dir)
+
+
+def run_workflow_generators(spec, env_vars, ctx: BuildContext) -> None:
+    """Run workflow generators if workflows are defined."""
+    if not spec.workflows:
+        return
+    
+    print("🛠  Generating workflows...")
+    wf_dir = ctx.build_dir / "api" / "workflows"
+    wf_dir.mkdir(parents=True, exist_ok=True)
+    workflow_gen.generate(spec, env_vars, wf_dir)
+
+
+def run_ci_generator(spec, env_vars, ctx: BuildContext) -> None:
+    """Run CI/CD generator (always into project root)."""
+    print("🛠  Generating CI...")
+    ci_gen.generate(spec, env_vars, ctx.root)
+
+
+def run_plugins(spec, env_vars, ctx: BuildContext) -> None:
+    """Run plugin generators."""
+    _plugins.run_plugins(spec, env_vars, ctx.build_dir, ctx.root)
+
+
+def cmd_build(args: argparse.Namespace) -> int:
+    """Generate all code for the project.
+    
+    This command runs all applicable generators to create a complete build.
+    Validation is performed first unless --force is specified.
+    """
+    ctx = BuildContext(
+        root=__import__('pathlib').Path(getattr(args, "dir", None) or ".").resolve(),
+        doql_file=__import__('pathlib').Path(getattr(args, "dir", None) or ".").resolve() / (getattr(args, "file", None) or "app.doql"),
+        env_file=__import__('pathlib').Path(getattr(args, "dir", None) or ".").resolve() / ".env",
+        build_dir=__import__('pathlib').Path(getattr(args, "dir", None) or ".").resolve() / "build",
+    )
+    
+    spec, env_vars = load_spec(ctx)
+    
+    # Validate unless --force
+    issues = doql_parser.validate(spec, env_vars)
+    errors = [i for i in issues if i.severity == "error"]
+    if errors and not getattr(args, "force", False):
+        print("❌ Validation errors (use --force to ignore):", file=sys.stderr)
+        for e in errors:
+            print(f"   {e.path}: {e.message}", file=sys.stderr)
+        return 1
+    
+    ctx.build_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Run all generators in order
+    run_core_generators(spec, env_vars, ctx)
+    run_document_generators(spec, env_vars, ctx)
+    run_report_generators(spec, env_vars, ctx)
+    run_i18n_generators(spec, env_vars, ctx)
+    run_integration_generators(spec, env_vars, ctx)
+    run_workflow_generators(spec, env_vars, ctx)
+    run_ci_generator(spec, env_vars, ctx)
+    run_plugins(spec, env_vars, ctx)
+    
+    write_lockfile(spec, ctx)
+    print(f"\n✅ Build complete — see {ctx.build_dir}/")
+    return 0

doql/cli/commands/__init__.py

@@ -0,0 +1,38 @@
+"""CLI command implementations.
+
+Each module implements a single doql subcommand.
+Commands are organized by functional area:
+- Project lifecycle: init, validate, plan
+- Build & deploy: build, sync, run, deploy
+- Export: export, generate, render, query
+- Utilities: docs, kiosk, quadlet
+"""
+from __future__ import annotations
+
+from .init import cmd_init
+from .validate import cmd_validate
+from .plan import cmd_plan
+from .run import cmd_run
+from .deploy import cmd_deploy
+from .export import cmd_export
+from .generate import cmd_generate
+from .render import cmd_render
+from .query import cmd_query
+from .kiosk import cmd_kiosk
+from .quadlet import cmd_quadlet
+from .docs import cmd_docs
+
+__all__ = [
+    "cmd_init",
+    "cmd_validate",
+    "cmd_plan",
+    "cmd_run",
+    "cmd_deploy",
+    "cmd_export",
+    "cmd_generate",
+    "cmd_render",
+    "cmd_query",
+    "cmd_kiosk",
+    "cmd_quadlet",
+    "cmd_docs",
+]

doql/cli/commands/deploy.py

@@ -0,0 +1,25 @@
+"""Deploy command — deploy to environment."""
+from __future__ import annotations
+
+import argparse
+import pathlib
+
+from ...generators import deploy as deploy_gen
+from ..context import BuildContext
+
+
+def cmd_deploy(args: argparse.Namespace) -> int:
+    """Deploy project to target environment.
+    
+    Delegates to infra_gen's deploy script.
+    """
+    ctx = BuildContext(
+        root=pathlib.Path(getattr(args, "dir", None) or ".").resolve(),
+        doql_file=pathlib.Path(getattr(args, "dir", None) or ".").resolve() / (getattr(args, "file", None) or "app.doql"),
+        env_file=pathlib.Path(getattr(args, "dir", None) or ".").resolve() / ".env",
+        build_dir=pathlib.Path(getattr(args, "dir", None) or ".").resolve() / "build",
+        target_env=getattr(args, "env", None) or "prod",
+    )
+    
+    print(f"🚀 Deploying to {ctx.target_env}...")
+    return deploy_gen.run(ctx, target_env=ctx.target_env)

doql/cli/commands/docs.py

@@ -0,0 +1,21 @@
+"""Docs command — generate documentation site."""
+from __future__ import annotations
+
+import argparse
+import pathlib
+
+from ... import parser as doql_parser
+from ...generators import docs_gen
+
+
+def cmd_docs(args: argparse.Namespace) -> int:
+    """Generate documentation site from .doql spec."""
+    root = pathlib.Path(getattr(args, "dir", None) or ".").resolve()
+    doql_file = root / (getattr(args, "file", None) or "app.doql")
+    
+    spec = doql_parser.parse_file(doql_file)
+    out = root / "docs"
+    
+    docs_gen.generate(spec, out)
+    print(f"📚 Docs generated in {out}")
+    return 0

doql/cli/commands/export.py

@@ -0,0 +1,36 @@
+"""Export command — export OpenAPI / Postman / TS SDK."""
+from __future__ import annotations
+
+import sys
+import argparse
+import pathlib
+
+from ... import parser as doql_parser
+from ...generators import api_gen, export_postman, export_ts_sdk
+
+
+def cmd_export(args: argparse.Namespace) -> int:
+    """Export project specification to various formats.
+    
+    Supported formats:
+    - openapi: OpenAPI 3.0 specification
+    - postman: Postman collection
+    - typescript-sdk: TypeScript client SDK
+    """
+    root = pathlib.Path(getattr(args, "dir", None) or ".").resolve()
+    doql_file = root / (getattr(args, "file", None) or "app.doql")
+    
+    fmt = args.format
+    spec = doql_parser.parse_file(doql_file)
+    
+    if fmt == "openapi":
+        api_gen.export_openapi(spec, sys.stdout)
+    elif fmt == "postman":
+        export_postman.run(spec, sys.stdout)
+    elif fmt == "typescript-sdk":
+        export_ts_sdk.run(spec, sys.stdout)
+    else:
+        print(f"❌ Unknown format: {fmt}", file=sys.stderr)
+        return 1
+    
+    return 0

doql/cli/commands/generate.py

@@ -0,0 +1,34 @@
+"""Generate command — generate a single document/artifact."""
+from __future__ import annotations
+
+import sys
+import argparse
+import pathlib
+
+from ... import parser as doql_parser
+
+
+def cmd_generate(args: argparse.Namespace) -> int:
+    """Generate a single document/artifact.
+    
+    The artifact name must match a DOCUMENT defined in the .doql file.
+    """
+    root = pathlib.Path(getattr(args, "dir", None) or ".").resolve()
+    doql_file = root / (getattr(args, "file", None) or "app.doql")
+    
+    spec = doql_parser.parse_file(doql_file)
+    artifact = args.artifact
+
+    # Find matching DOCUMENT in spec
+    doc = next((d for d in spec.documents if d.name == artifact), None)
+    if not doc:
+        available = [d.name for d in spec.documents]
+        print(f"❌ Unknown artifact '{artifact}'. Available: {available}", file=sys.stderr)
+        return 1
+
+    print(f"📄 Generating {artifact} ({doc.type})...")
+    # TODO: Faza 1 — Jinja2 + WeasyPrint pipeline
+    print(f"   Template: {doc.template or '(none)'}")
+    print(f"   Output: {doc.output or f'{artifact}.{doc.type}'}")
+    print("⚠️  Generator not yet implemented — stub only.")
+    return 0

doql/cli/commands/init.py

@@ -0,0 +1,43 @@
+"""Init command — create new project from template."""
+from __future__ import annotations
+
+import sys
+import argparse
+import pathlib
+
+from ..context import scaffold_from_template
+
+
+def cmd_init(args: argparse.Namespace) -> int:
+    """Create new project from template.
+    
+    With --list-templates, shows available templates and exits.
+    """
+    if getattr(args, "list_templates", False):
+        scaffolds_dir = pathlib.Path(__file__).parent.parent.parent / "scaffolds"
+        templates = sorted(p.name for p in scaffolds_dir.iterdir() if p.is_dir())
+        print("Available doql templates:")
+        for t in templates:
+            doql = scaffolds_dir / t / "app.doql"
+            first_line = ""
+            if doql.exists():
+                with doql.open() as fh:
+                    first_line = fh.readline().strip()
+            print(f"  {t:24} — {first_line}")
+        return 0
+
+    template = args.template or "minimal"
+    target = pathlib.Path(args.name)
+    if target.exists():
+        print(f"❌ Directory {target} already exists", file=sys.stderr)
+        return 1
+
+    print(f"📦 Scaffolding {target} from template '{template}'...")
+    scaffold_from_template(template, target)
+    print(f"✅ Created {target}/")
+    print(f"   Next steps:")
+    print(f"     cd {target}")
+    print(f"     cp .env.example .env && $EDITOR .env")
+    print(f"     doql validate")
+    print(f"     doql build")
+    return 0

doql/cli/commands/kiosk.py

@@ -0,0 +1,20 @@
+"""Kiosk command — kiosk appliance management."""
+from __future__ import annotations
+
+import argparse
+
+
+def cmd_kiosk(args: argparse.Namespace) -> int:
+    """Manage kiosk appliance installation.
+    
+    Use --install to set up kiosk mode on a Raspberry Pi.
+    """
+    if args.install:
+        print("🖥️  Installing kiosk appliance...")
+        print("   Target: Raspberry Pi OS Lite 64-bit")
+        # TODO: Faza 2 — Openbox autostart, chromium --kiosk, udev rules, systemd
+        print("⚠️  Kiosk installer not yet implemented — stub only.")
+        return 0
+    
+    print("ℹ️  Use --install to set up kiosk on this device.")
+    return 0

doql/cli/commands/plan.py

@@ -0,0 +1,115 @@
+"""Plan command — dry-run showing what would be generated."""
+from __future__ import annotations
+
+import argparse
+import pathlib
+from typing import TYPE_CHECKING
+
+from ... import parsers as doql_parser
+from ..context import estimate_file_count
+
+if TYPE_CHECKING:
+    from ...parsers.models import DoqlSpec
+
+
+def _print_header(spec: DoqlSpec) -> None:
+    """Print plan header with app name and version."""
+    print(f"📋 Plan for {spec.app_name} (v{spec.version}):\n")
+    print(f"  Domain:         {spec.domain or '(not set)'}")
+    print(f"  Languages:      {spec.languages or ['(default)']}")
+
+
+def _print_entities(spec: DoqlSpec) -> None:
+    """Print entities section."""
+    print(f"  Entities:       {len(spec.entities)}")
+    for e in spec.entities:
+        print(f"    • {e.name} ({len(e.fields)} fields)")
+
+
+def _print_data_sources(spec: DoqlSpec) -> None:
+    """Print DATA sources section."""
+    print(f"  DATA sources:   {len(spec.data_sources)}")
+    for d in spec.data_sources:
+        file_info = f" → {d.file}" if d.file else ""
+        print(f"    • {d.name} ({d.source}{file_info})")
+
+
+def _print_documents(spec: DoqlSpec) -> None:
+    """Print documents and templates section."""
+    print(f"  Templates:      {len(spec.templates)}")
+    print(f"  Documents:      {len(spec.documents)}")
+    for d in spec.documents:
+        print(f"    • {d.name} ({d.type})")
+
+
+def _print_api_clients(spec: DoqlSpec) -> None:
+    """Print API clients section."""
+    print(f"  API clients:    {len(spec.api_clients)}")
+    for a in spec.api_clients:
+        print(f"    • {a.name} ({a.base_url or ' ?'})")
+
+
+def _print_interfaces(spec: DoqlSpec) -> None:
+    """Print interfaces section."""
+    print(f"  Interfaces:     {[i.name for i in spec.interfaces]}")
+    for i in spec.interfaces:
+        pages = [p.name for p in i.pages]
+        print(f"    • {i.name} ({i.type}) pages={pages}")
+
+
+def _print_workflows(spec: DoqlSpec) -> None:
+    """Print workflows section."""
+    print(f"  Workflows:      {len(spec.workflows)}")
+    for w in spec.workflows:
+        trigger = w.trigger or w.schedule or '?'
+        print(f"    • {w.name} (trigger={trigger})")
+
+
+def _print_summary(spec: DoqlSpec) -> None:
+    """Print summary statistics."""
+    print(f"  Reports:        {len(spec.reports)}")
+    print(f"  Databases:      {len(spec.databases)}")
+    print(f"  Webhooks:       {len(spec.webhooks)}")
+    print(f"  Scenarios:      {len(spec.scenarios)}")
+    print(f"  Integrations:   {[ig.name for ig in spec.integrations]}")
+    print(f"  Roles:          {[r.name for r in spec.roles]}")
+    print(f"  Deploy target:  {spec.deploy.target if spec.deploy else '(none)'}")
+    print(f"  Env references: {len(spec.env_refs)} vars")
+
+
+def _print_file_counts(spec: DoqlSpec) -> None:
+    """Print estimated file generation counts."""
+    print("\n  Files to generate:")
+    total = 0
+    for iface in spec.interfaces:
+        count = estimate_file_count(iface)
+        total += count
+        print(f"    {iface.name:12} ~{count} files")
+
+    infra_count = len(spec.integrations) + 3
+    print(f"    infra        ~{infra_count} files")
+    print(f"  TOTAL:          ~{total + infra_count} files\n")
+
+
+def cmd_plan(args: argparse.Namespace) -> int:
+    """Show dry-run plan of what would be generated.
+
+    Displays project overview including entities, data sources, interfaces,
+    and estimated file counts per interface type.
+    """
+    root = pathlib.Path(getattr(args, "dir", None) or ".").resolve()
+    doql_file = root / (getattr(args, "file", None) or "app.doql")
+
+    spec = doql_parser.parse_file(doql_file)
+
+    _print_header(spec)
+    _print_entities(spec)
+    _print_data_sources(spec)
+    _print_documents(spec)
+    _print_api_clients(spec)
+    _print_summary(spec)
+    _print_interfaces(spec)
+    _print_workflows(spec)
+    _print_file_counts(spec)
+
+    return 0

doql/cli/commands/quadlet.py

@@ -0,0 +1,22 @@
+"""Quadlet command — Podman Quadlet management."""
+from __future__ import annotations
+
+import argparse
+import pathlib
+
+
+def cmd_quadlet(args: argparse.Namespace) -> int:
+    """Manage Podman Quadlet containers.
+    
+    Use --install to deploy Quadlet container definitions to systemd.
+    """
+    if args.install:
+        print("🐳 Installing Quadlet containers to systemd...")
+        quadlet_dir = pathlib.Path.home() / ".config" / "containers" / "systemd"
+        print(f"   Target: {quadlet_dir}")
+        # TODO: Faza 1 — copy .container files, systemctl --user daemon-reload
+        print("⚠️  Quadlet installer not yet implemented — stub only.")
+        return 0
+    
+    print("ℹ️  Use --install to deploy Quadlet containers to systemd.")
+    return 0

doql/cli/commands/query.py

@@ -0,0 +1,31 @@
+"""Query command — query a DATA source → JSON."""
+from __future__ import annotations
+
+import sys
+import argparse
+import pathlib
+
+from ... import parser as doql_parser
+
+
+def cmd_query(args: argparse.Namespace) -> int:
+    """Query a DATA source and output as JSON.
+    
+    Supports JSON, SQLite, CSV, Excel, and API data sources.
+    """
+    root = pathlib.Path(getattr(args, "dir", None) or ".").resolve()
+    doql_file = root / (getattr(args, "file", None) or "app.doql")
+    data_name = args.data
+
+    spec = doql_parser.parse_file(doql_file)
+    ds = next((d for d in spec.data_sources if d.name == data_name), None)
+    
+    if not ds:
+        available = [d.name for d in spec.data_sources]
+        print(f"❌ Unknown DATA source '{data_name}'. Available: {available}", file=sys.stderr)
+        return 1
+
+    print(f"🔎 Querying DATA {data_name} (source: {ds.source})...")
+    # TODO: Faza 1 — load JSON/SQLite/API and output as JSON
+    print("⚠️  Query engine not yet implemented — stub only.")
+    return 0

doql/cli/commands/render.py

@@ -0,0 +1,26 @@
+"""Render command — render a template with data."""
+from __future__ import annotations
+
+import sys
+import argparse
+import pathlib
+
+
+def cmd_render(args: argparse.Namespace) -> int:
+    """Render a template with DATA sources.
+    
+    Template path can be relative to current directory or project root.
+    """
+    root = pathlib.Path(getattr(args, "dir", None) or ".").resolve()
+    template_path = pathlib.Path(args.template)
+    
+    if not template_path.exists():
+        template_path = root / args.template
+    if not template_path.exists():
+        print(f"❌ Template not found: {args.template}", file=sys.stderr)
+        return 1
+
+    print(f"🎨 Rendering {template_path.name}...")
+    # TODO: Faza 1 — Jinja2 render with DATA sources
+    print("⚠️  Renderer not yet implemented — stub only.")
+    return 0

doql/cli/commands/run.py

@@ -0,0 +1,25 @@
+"""Run command — run locally in dev mode."""
+from __future__ import annotations
+
+import sys
+import subprocess
+import argparse
+import pathlib
+
+
+def cmd_run(args: argparse.Namespace) -> int:
+    """Run project locally in dev mode using docker-compose.
+    
+    Requires existing build (run `doql build` first).
+    """
+    root = pathlib.Path(getattr(args, "dir", None) or ".").resolve()
+    build_dir = root / "build"
+    compose = build_dir / "infra" / "docker-compose.yml"
+    
+    if not compose.exists():
+        print("❌ No build found. Run `doql build` first.", file=sys.stderr)
+        return 1
+    
+    return subprocess.call([
+        "docker", "compose", "-f", str(compose), "up", "--build"
+    ])

doql/cli/commands/validate.py

@@ -0,0 +1,43 @@
+"""Validate command — validate .doql + .env."""
+from __future__ import annotations
+
+import sys
+import argparse
+import pathlib
+
+from ... import parser as doql_parser
+
+
+def cmd_validate(args: argparse.Namespace) -> int:
+    """Validate .doql file and .env configuration.
+    
+    Returns:
+        0 if validation passes, 1 if there are errors
+    """
+    root = pathlib.Path(getattr(args, "dir", None) or ".").resolve()
+    doql_file = root / (getattr(args, "file", None) or "app.doql")
+    env_file = root / ".env"
+    
+    print(f"🔍 Validating {doql_file}...")
+    
+    try:
+        spec = doql_parser.parse_file(doql_file)
+        env_vars = doql_parser.parse_env(env_file)
+        issues = doql_parser.validate(spec, env_vars, project_root=root)
+    except doql_parser.DoqlParseError as e:
+        print(f"❌ Parse error: {e}", file=sys.stderr)
+        return 1
+
+    if not issues:
+        print("✅ Everything looks good.")
+        return 0
+
+    errors = sum(1 for i in issues if i.severity == "error")
+    warnings = sum(1 for i in issues if i.severity == "warning")
+    
+    for issue in issues:
+        level = "❌" if issue.severity == "error" else "⚠️ "
+        print(f"{level} {issue.path}: {issue.message}")
+    
+    print(f"\n  {errors} error(s), {warnings} warning(s)")
+    return 1 if errors > 0 else 0