| import os
|
| import sys
|
| import subprocess
|
| from pathlib import Path
|
| from typing import List
|
| from dotenv import load_dotenv
|
|
|
| ROOT = Path(__file__).resolve().parents[2]
|
| load_dotenv(str(Path(__file__).resolve().parents[1] / ".env"))
|
|
|
| sys.path.append(str(Path(__file__).resolve().parents[1]))
|
|
|
| import typer
|
|
|
| try:
|
| import questionary
|
| except ImportError:
|
| questionary = None
|
|
|
| from docker_builder import build_dockerfile, write_dockerfile
|
| from graphrag_builder import build_graphrag
|
| from hf_deployer import deploy_space
|
| from vector_db_builder import build_vector_db_for_dir
|
|
|
| app = typer.Typer(help="Interactive build & deploy tool")
|
|
|
| BACKEND_DIR = ROOT / "_backend"
|
| DATA_DIR = BACKEND_DIR / "data"
|
| DEFAULT_DOCKERFILE = ROOT / "Dockerfile.generated"
|
|
|
|
|
| def list_data_files() -> List[Path]:
|
|
|
| folders = [p for p in DATA_DIR.iterdir() if p.is_dir()]
|
| if not folders:
|
| return []
|
| return sorted(folders)
|
|
|
|
|
| def run_command(cmd: List[str], cwd: Path | None = None):
|
| typer.echo(f"Running: {' '.join(cmd)}")
|
| res = subprocess.run(cmd, cwd=cwd, text=True)
|
| if res.returncode != 0:
|
| raise typer.Exit(code=res.returncode)
|
|
|
|
|
| def ensure_questionary():
|
| if questionary is None:
|
| typer.echo("questionary not installed. Please add it to requirements and install.")
|
| raise typer.Exit(code=1)
|
|
|
|
|
| @app.command()
|
| def interactive(
|
| graphrag: bool = typer.Option(False, help="Build GraphRAG artifacts"),
|
| deploy: bool = typer.Option(False, help="Deploy to Hugging Face after build"),
|
| dockerfile_out: Path = typer.Option(DEFAULT_DOCKERFILE, help="Path for generated Dockerfile"),
|
| non_interactive: bool = typer.Option(False, help="Skip confirmations where possible")
|
| ):
|
| """Run the interactive (or semi-interactive) build workflow."""
|
| if not non_interactive:
|
| ensure_questionary()
|
|
|
| files = list_data_files()
|
| if not files:
|
| typer.echo("No data files found under _backend/data.")
|
| raise typer.Exit(code=1)
|
|
|
| if non_interactive:
|
| selected_paths = files
|
| else:
|
| choices = [f.relative_to(DATA_DIR).as_posix() for f in files]
|
| selected_rel = questionary.checkbox(
|
| "Select data files to include:", choices=choices
|
| ).ask()
|
| if not selected_rel:
|
| typer.echo("No files selected.")
|
| raise typer.Exit()
|
| selected_paths = [DATA_DIR / r for r in selected_rel]
|
|
|
|
|
|
|
| do_reset = True if non_interactive else questionary.confirm(
|
| "Build/reset vector database(s) for selected data directories?"
|
| ).ask()
|
| if do_reset:
|
| for data_path in selected_paths:
|
|
|
| if non_interactive:
|
| file_suffix = None
|
| collection_name = data_path.name
|
| else:
|
| file_suffix = questionary.text(
|
| f"File suffix to include for {data_path.name} (e.g. .md, .srt, leave blank for all):",
|
| default=""
|
| ).ask()
|
| file_suffix = file_suffix if file_suffix.strip() else None
|
| collection_name = questionary.text(
|
| f"Collection name for {data_path.name}:",
|
| default=data_path.name
|
| ).ask()
|
| build_vector_db_for_dir(
|
| data_dir=str(data_path),
|
| collection_name=collection_name,
|
| file_suffix=file_suffix,
|
| verbose=True
|
| )
|
|
|
| graphrag_artifact_paths: List[str] = []
|
| build_graphrag_flag = graphrag or (False if non_interactive else questionary.confirm(
|
| "Build GraphRAG artifacts?"
|
| ).ask())
|
| if build_graphrag_flag:
|
| out_dir = BACKEND_DIR / "graphrag_artifacts"
|
| build_graphrag(selected_paths, out_dir)
|
| graphrag_artifact_paths.append(str(out_dir.relative_to(ROOT)))
|
|
|
| frontend_dir = Path(os.getenv("FRONTEND_DIR", "frontend"))
|
| build_cmd = os.getenv("FRONTEND_BUILD_CMD", "npm run build")
|
| build_out = os.getenv("FRONTEND_BUILD_OUTPUT", "dist")
|
|
|
| prebuild_frontend = True if non_interactive else questionary.confirm(
|
| "Pre-build frontend locally first?"
|
| ).ask()
|
| if prebuild_frontend:
|
| if frontend_dir.exists():
|
| run_command(build_cmd.split(), cwd=ROOT / frontend_dir)
|
| else:
|
| typer.echo(f"Frontend directory {frontend_dir} not found; skipping pre-build.")
|
|
|
| docker_content = build_dockerfile(
|
| frontend_build_cmd=build_cmd,
|
| frontend_build_output=build_out,
|
| graphrag_artifact_paths=graphrag_artifact_paths or None,
|
| )
|
| write_dockerfile(dockerfile_out, docker_content)
|
| typer.echo(f"Wrote Dockerfile to {dockerfile_out}")
|
|
|
| build_image = True if non_interactive else questionary.confirm(
|
| "Build Docker image locally?"
|
| ).ask()
|
| if build_image:
|
| tag = os.getenv("IMAGE_TAG", "interview-synth:latest") if non_interactive else questionary.text(
|
| "Image tag:", default="interview-synth:latest"
|
| ).ask()
|
| run_command(["docker", "build", "-f", str(dockerfile_out), "-t", tag, "."], cwd=ROOT)
|
|
|
| do_deploy = deploy or (False if non_interactive else questionary.confirm(
|
| "Deploy to Hugging Face Spaces?"
|
| ).ask())
|
| if do_deploy:
|
| space_id = os.getenv("HF_SPACE_ID") or ("" if non_interactive else questionary.text(
|
| "Enter HF Space (user/space):"
|
| ).ask())
|
| token = os.getenv("HF_TOKEN") or ("" if non_interactive else questionary.password(
|
| "Enter Hugging Face token:"
|
| ).ask())
|
| if not space_id or not token:
|
| typer.echo("Space ID or token missing; aborting deploy.")
|
| else:
|
|
|
| (ROOT / "Dockerfile").write_text(docker_content, encoding="utf-8")
|
| deploy_space(space_id, ROOT, token)
|
|
|
| typer.echo("Done.")
|
|
|
|
|
| if __name__ == "__main__":
|
| app()
|
|
|
