kiro-cli 1.0.0__tar.gz

kiro_cli-1.0.0/LICENSE

@@ -0,0 +1,23 @@
+
+---
+
+# 📜 `LICENSE` (MIT License)
+
+Create a file called `LICENSE`:
+
+```txt
+MIT License
+
+Copyright (c) 2026 Jimoh Olamide Prince
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

kiro_cli-1.0.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: kiro-cli
+Version: 1.0.0
+Summary: A CLI scaffolding tool for backend projects
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer
+Requires-Dist: questionary
+Requires-Dist: rich
+Dynamic: license-file
+
+# ⚡ Kiro
+
+Kiro is a CLI scaffolding tool that helps developers quickly set up backend projects without wasting time on repetitive configuration.
+
+Instead of manually setting up folders, dependencies, and boilerplate, Kiro guides you through an interactive setup and generates a ready-to-code project.
+
+---
+
+## 🚀 Features (current stage)
+
+- Interactive CLI wizard
+- Runtime selection (Node.js, Python)
+- Framework selection based on runtime
+- Project name prompt
+- Automatic folder generation
+- Basic starter files setup
+- file config for node js(ts/js) and python
+
+---
+
+## 📦 Installation (development)
+
+```bash
+pip install -r requirements.txt
+```
+
+Follow the interactive prompts to generate a project.
+
+---
+
+## 📁 Output Example
+
+```bash
+
+my-app/
+├── src/
+│   ├── main.py / index.js
+│   └── routes/
+
+```
+
+
+## 🚧 Roadmap
+
+ Template engine system
+ Dependency auto-installation
+ Git initialization support
+ Docker integration
+ Database setup wizard
+ Plugin-based architecture
+ Global CLI installation (npm/pipx-style experience)
+ Web landing page + documentation site
+
+
+## 🧠 Philosophy
+
+Kiro is built around a simple idea:
+
+“Stop setting up. Start building.”
+
+The focus is on reducing friction between idea and execution.
+
+.
+
+## 👨‍💻 Author
+
+Built by Jimoh Olamide Prince
+
+## 📜 License
+MIT

kiro_cli-1.0.0/README.md

@@ -0,0 +1,70 @@
+# ⚡ Kiro
+
+Kiro is a CLI scaffolding tool that helps developers quickly set up backend projects without wasting time on repetitive configuration.
+
+Instead of manually setting up folders, dependencies, and boilerplate, Kiro guides you through an interactive setup and generates a ready-to-code project.
+
+---
+
+## 🚀 Features (current stage)
+
+- Interactive CLI wizard
+- Runtime selection (Node.js, Python)
+- Framework selection based on runtime
+- Project name prompt
+- Automatic folder generation
+- Basic starter files setup
+- file config for node js(ts/js) and python
+
+---
+
+## 📦 Installation (development)
+
+```bash
+pip install -r requirements.txt
+```
+
+Follow the interactive prompts to generate a project.
+
+---
+
+## 📁 Output Example
+
+```bash
+
+my-app/
+├── src/
+│   ├── main.py / index.js
+│   └── routes/
+
+```
+
+
+## 🚧 Roadmap
+
+ Template engine system
+ Dependency auto-installation
+ Git initialization support
+ Docker integration
+ Database setup wizard
+ Plugin-based architecture
+ Global CLI installation (npm/pipx-style experience)
+ Web landing page + documentation site
+
+
+## 🧠 Philosophy
+
+Kiro is built around a simple idea:
+
+“Stop setting up. Start building.”
+
+The focus is on reducing friction between idea and execution.
+
+.
+
+## 👨‍💻 Author
+
+Built by Jimoh Olamide Prince
+
+## 📜 License
+MIT

kiro_cli-1.0.0/kiro/cli.py

@@ -0,0 +1,62 @@
+from kiro.prompts import (
+    select_runtime,
+    select_framework,
+    ask_project_name,
+    ask_language,
+    select_database,
+    select_orm
+)
+
+from kiro.state import KiroState
+from kiro.generators import create_project
+from kiro.database import setup_database
+from kiro.installers import install_dependencies
+from kiro.ui import show_success
+
+
+def run_cli():
+    print("\n⚡ Welcome to Kiro\n")
+
+    state = KiroState()
+
+    # Runtime
+    state.runtime = select_runtime()
+    print(f"\n✔ Selected runtime: {state.runtime}")
+
+    # Language (Node.js only)
+    if state.runtime == "Node.js":
+        state.language = ask_language()
+        print(f"\n✔ Language: {state.language}")
+
+    # Framework
+    state.framework = select_framework(state.runtime)
+    print(f"\n✔ Selected framework: {state.framework}")
+
+    # Project name
+    state.project_name = ask_project_name()
+    print(f"\n✔ Project name: {state.project_name}")
+
+    # Database
+    state.database = select_database()
+    print(f"\n✔ Database: {state.database}")
+
+    # ORM (only if a database was selected)
+    state.orm = select_orm(
+        state.runtime,
+        state.database
+    )
+
+    if state.orm:
+        print(f"\n✔ ORM: {state.orm}")
+
+    # Generate project
+    create_project(state)
+
+    # Configure database
+    setup_database(state)
+
+    # Install dependencies
+    install_dependencies(state)
+
+    # Success message (always last)
+    show_success(state)

kiro_cli-1.0.0/kiro/database.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+def setup_database(state):
+    if state.database == "None":
+        return
+
+    project = Path(state.project_name)
+    env = project / ".env"
+
+    database_urls = {
+        "PostgreSQL": "postgresql://username:password@localhost:5432/mydb",
+        "MySQL": "mysql://root:password@localhost:3306/mydb",
+        "SQLite": "file:./database.db",
+        "MongoDB": "mongodb://localhost:27017/mydb",
+    }
+
+    database_url = database_urls.get(state.database)
+
+    if database_url:
+        with env.open("a") as f:
+            f.write(f"DATABASE_URL={database_url}\n")
+
+    print(f"🗄 Setting up {state.database}...")

kiro_cli-1.0.0/kiro/generators.py

@@ -0,0 +1,48 @@
+# Creates files/folders
+import os
+from pathlib import Path
+import shutil
+from kiro.utils.files import replace_placeholders
+from kiro.ui import show_success
+from kiro.installers import install_dependencies
+
+
+
+def create_project(state):
+    base_path = Path(state.project_name)
+    base_path.mkdir(exist_ok=True)
+
+    template_path = get_template_path(state)
+
+    if template_path and template_path.exists():
+        shutil.copytree(
+            template_path,
+            base_path,
+            dirs_exist_ok=True
+        )
+
+        replace_placeholders(base_path, state)
+
+    show_success(state)
+
+
+
+def get_template_path(state):
+    base = Path("kiro") / "templates"
+
+    if state.runtime == "Node.js":
+        framework = state.framework.lower()
+
+        language = state.language.lower()  # javascript / typescript
+
+        return base / "node" / framework / language
+
+    if state.runtime == "Python":
+        framework = state.framework.lower()
+        return base / "python" / framework
+
+    if state.runtime == "Go":
+        framework = state.framework.lower()
+        return base / "go" / framework
+
+    return None

kiro_cli-1.0.0/kiro/installers.py

@@ -0,0 +1,79 @@
+"""Install dependencies for generated Kiro projects."""
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from kiro.packages import get_packages
+
+
+def install_dependencies(state):
+    """Install the dependencies implied by the user's project selections."""
+    project = Path(state.project_name).resolve()
+
+    if not project.is_dir():
+        raise FileNotFoundError(f"Generated project directory was not found: {project}")
+
+    packages, dev_packages = get_packages(state)
+
+    if state.runtime == "Node.js":
+        _install_node_dependencies(project, packages, dev_packages)
+    elif state.runtime == "Python":
+        _install_python_dependencies(project, packages)
+    elif state.runtime == "Go":
+        _install_go_dependencies(project, packages)
+    else:
+        raise ValueError(f"Unsupported runtime: {state.runtime}")
+
+    print("Dependencies installed successfully.")
+
+
+def _require_command(name: str) -> str:
+    command = shutil.which(name)
+    if not command:
+        raise RuntimeError(f"{name} was not found on PATH. Install it and try again.")
+    return command
+
+
+def _install_node_dependencies(project: Path, packages: list[str], dev_packages: list[str]):
+    npm = _require_command("npm")
+
+    # Install dependencies declared by the copied template first.
+    subprocess.run([npm, "install"], cwd=project, check=True)
+
+    if packages:
+        subprocess.run([npm, "install", *packages], cwd=project, check=True)
+    if dev_packages:
+        subprocess.run([npm, "install", "--save-dev", *dev_packages], cwd=project, check=True)
+
+
+def _install_python_dependencies(project: Path, packages: list[str]):
+    pip = _create_python_venv(project)
+    requirements = project / "requirements.txt"
+
+    if requirements.is_file():
+        subprocess.run([str(pip), "install", "-r", str(requirements)], cwd=project, check=True)
+    if packages:
+        subprocess.run([str(pip), "install", *packages], cwd=project, check=True)
+
+
+def _create_python_venv(project: Path) -> Path:
+    if sys.platform == "win32":
+        pip = project / ".venv" / "Scripts" / "pip.exe"
+    else:
+        pip = project / ".venv" / "bin" / "pip"
+
+    if not pip.is_file():
+        print("Creating virtual environment...")
+        subprocess.run([sys.executable, "-m", "venv", ".venv"], cwd=project, check=True)
+
+    return pip
+
+
+def _install_go_dependencies(project: Path, packages: list[str]):
+    go = _require_command("go")
+
+    for package in packages:
+        subprocess.run([go, "get", package], cwd=project, check=True)
+    subprocess.run([go, "mod", "tidy"], cwd=project, check=True)

kiro_cli-1.0.0/kiro/main.py

@@ -0,0 +1,7 @@
+from kiro.cli import run_cli
+
+def main():
+    run_cli()
+
+if __name__ == "__main__":
+    main()

kiro_cli-1.0.0/kiro/orm.py

@@ -0,0 +1,99 @@
+from pathlib import Path
+
+def setup_orm(state):
+    if state.orm is None:
+        return
+    
+    project = Path(state.project_name)
+
+    if state.runtime == "Node.js":
+        setup_node_orm(state, project)
+
+    elif state.runtime == "Python":
+        setup_python_orm(state, project)
+
+
+def setup_node_orm(state, project):
+
+    orm = state.orm.lower()
+
+    if orm == "prisma":
+        setup_prisma(project)
+
+    elif orm == "drizzle":
+        setup_drizzle(project)
+
+    elif orm == "typeorm":
+        setup_typeorm(project)
+
+    elif orm == "mongoose":
+        setup_mongoose(project)
+
+
+def setup_drizzle(project):
+
+    db = project / "src" / "db"
+
+    db.mkdir(parents=True, exist_ok=True)
+
+    (db / "index.ts").write_text(
+"""export * from "./schema";
+"""
+    )
+
+    (db / "schema.ts").write_text(
+"""// Your Drizzle schema goes here
+"""
+    )
+
+
+def setup_prisma(project):
+
+    prisma = project / "prisma"
+
+    prisma.mkdir(exist_ok=True)
+
+    (prisma / "schema.prisma").write_text(
+"""generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "sqlite"
+  url = env("DATABASE_URL")
+}
+"""
+    )
+
+
+def setup_typeorm(project):
+
+    entities = project / "src" / "entities"
+
+    entities.mkdir(parents=True, exist_ok=True)
+
+
+def setup_mongoose(project):
+
+    models = project / "src" / "models"
+
+    models.mkdir(parents=True, exist_ok=True)
+
+
+def setup_python_orm(state, project):
+
+    if state.orm == "SQLAlchemy":
+
+        db = project / "app" / "db"
+
+        db.mkdir(parents=True, exist_ok=True)
+
+        (db / "__init__.py").touch()
+
+    elif state.orm == "Tortoise ORM":
+
+        db = project / "app" / "db"
+
+        db.mkdir(parents=True, exist_ok=True)
+
+        (db / "__init__.py").touch()

kiro_cli-1.0.0/kiro/packages.py

@@ -0,0 +1,155 @@
+def get_packages(state):
+
+    packages = []
+    dev_packages = []
+
+
+    # ======================
+    # NODE.JS
+    # ======================
+
+    if state.runtime == "Node.js":
+
+        # Framework
+        if state.framework == "Express":
+            packages += [
+                "express",
+                "dotenv",
+                "cors"
+            ]
+
+        elif state.framework == "Fastify":
+            packages += [
+                "fastify",
+                "dotenv",
+                "@fastify/cors"
+            ]
+
+        elif state.framework == "Nest":
+            packages += [
+                "@nestjs/core",
+                "@nestjs/common",
+                "@nestjs/platform-express"
+            ]
+
+
+        # Language
+        if getattr(state, "language", None) == "TypeScript":
+            dev_packages += [
+                "typescript",
+                "ts-node-dev",
+                "@types/node"
+            ]
+
+
+        # Database
+        if state.database == "PostgreSQL":
+            packages.append("pg")
+
+        elif state.database == "MySQL":
+            packages.append("mysql2")
+
+        elif state.database == "MongoDB":
+            packages.append("mongodb")
+
+
+        # ORM
+        if state.orm == "Prisma":
+            packages.append("prisma")
+
+        elif state.orm == "Drizzle":
+            packages.append("drizzle-orm")
+            dev_packages.append("drizzle-kit")
+
+
+    # ======================
+    # PYTHON
+    # ======================
+
+    elif state.runtime == "Python":
+
+        # Framework
+        if state.framework == "FastAPI":
+            packages += [
+                "fastapi",
+                "uvicorn"
+            ]
+
+        elif state.framework == "Flask":
+            packages.append(
+                "flask"
+            )
+
+
+        # Database
+        if state.database == "PostgreSQL":
+            packages.append(
+                "psycopg2-binary"
+            )
+
+        elif state.database == "MySQL":
+            packages.append(
+                "mysql-connector-python"
+            )
+
+        elif state.database == "MongoDB":
+            packages.append(
+                "pymongo"
+            )
+
+        elif state.database == "SQLite":
+            packages.append(
+                "sqlalchemy"
+            )
+
+
+        # ORM
+        if state.orm == "SQLAlchemy":
+            packages.append(
+                "sqlalchemy"
+            )
+
+        elif state.orm == "MongoEngine":
+            packages.append(
+                "mongoengine"
+            )
+
+        elif state.orm == "Peewee":
+            packages.append(
+                "peewee"
+            )
+
+
+    # ======================
+    # GO
+    # ======================
+
+    elif state.runtime == "Go":
+
+        # Go dependencies are handled by go.mod
+        # and go mod tidy
+
+        if state.framework == "Gin":
+            packages.append(
+                "github.com/gin-gonic/gin"
+            )
+
+
+        if state.database == "PostgreSQL":
+            packages.append(
+                "github.com/lib/pq"
+            )
+
+        elif state.database == "MongoDB":
+            packages.append(
+                "go.mongodb.org/mongo-driver/mongo"
+            )
+
+
+        if state.orm == "GORM":
+            packages.append(
+                "gorm.io/gorm"
+            )
+
+
+    return packages, dev_packages

kiro_cli-1.0.0/kiro/prompts.py

@@ -0,0 +1,122 @@
+# Questionary prompts
+import questionary
+import typer
+
+def confirm_install_dependencies():
+    return typer.confirm(
+        "Install dependencies?",
+        default=True
+    )
+
+
+def confirm_git_init():
+    return typer.confirm(
+        "Initialize Git repository?",
+        default=True
+    )
+
+def select_runtime():
+    return questionary.select(
+        "Which runtime do you want to use?",
+        choices=[
+            "Node.js",
+            "Python",
+            "Go"
+        ]
+    ).ask()
+
+
+def select_framework(runtime: str):
+    if runtime == "Node.js":
+        choices = ["Express", "Fastify", "NestJS"]
+    elif runtime == "Python":
+        choices = ["FastAPI", "Flask", "Django"]
+    else:
+        choices = ["None"]
+
+    return questionary.select(
+        "Choose a framework",
+        choices=choices,
+    ).ask()
+
+def ask_project_name():
+    return questionary.text(
+        "project name?",
+        validate=lambda text: len(text.strip()) > 0 or "Project name cannot be empty"
+        ).ask()
+
+def ask_language():
+    return questionary.select(
+        "Choose language",
+        choices=[
+            "JavaScript",
+            "TypeScript"
+        ]
+    ).ask()
+
+    return choice
+
+def select_database():
+    return questionary.select(
+        "Select database",
+        choices=[
+            "PostgreSQL",
+            "MySQL",
+            "SQLite",
+            "MongoDB",
+            "None",
+        ]
+    ).ask()
+    return choice
+
+import questionary
+
+def select_orm(runtime, database):
+    choices = []
+
+    if runtime == "Node.js":
+        if database == "MongoDB":
+            choices = [
+                "Mongoose",
+                "None"
+            ]
+        elif database != "None":
+            choices = [
+                "Prisma",
+                "Drizzle",
+                "TypeORM",
+                "None"
+            ]
+        else:
+            return None
+
+    elif runtime == "Python":
+        if database == "MongoDB":
+            choices = [
+                "MongoEngine",
+                "Beanie",
+                "None"
+            ]
+        elif database != "None":
+            choices = [
+                "SQLAlchemy",
+                "Tortoise ORM",
+                "None"
+            ]
+        else:
+            return None
+
+    elif runtime == "Go":
+        if database != "None":
+            choices = [
+                "GORM",
+                "sqlx",
+                "None"
+            ]
+        else:
+            return None
+
+    return questionary.select(
+        "Choose ORM",
+        choices=choices
+    ).ask()

kiro_cli-1.0.0/kiro/state.py

@@ -0,0 +1,12 @@
+#store user choices
+
+class KiroState:
+    def __init__(self):
+        self.runtime = None
+        self.framework = None
+        self.database = None
+        self.project_name = None
+        self.language = None #js or ts
+        self.database = None
+        self.orm = None
+    

kiro_cli-1.0.0/kiro/templates/python/fastapi/app/main.py

@@ -0,0 +1,7 @@
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/")
+def root():
+    return {"message": "Hello from Kiro 🚀"}

kiro_cli-1.0.0/kiro/templates/python/flask/app.py

@@ -0,0 +1,10 @@
+from flask import Flask
+
+app = Flask(__name__)
+
+@app.get("/")
+def home():
+    return {"message": "Hello from Kiro 🚀"}
+
+if __name__ == "__main__":
+    app.run(debug=True)

kiro_cli-1.0.0/kiro/ui.py

@@ -0,0 +1,10 @@
+def show_success(state):
+    print("\n✨ Project created successfully!\n")
+    print(f"📦 Project   : {state.project_name}")
+    print(f"⚙ Runtime   : {state.runtime}")
+    print(f"🚀 Framework : {state.framework}")
+
+    if state.language:
+        print(f"💻 Language  : {state.language}")
+
+    print(f"📁 Location  : ./{state.project_name}\n")

kiro_cli-1.0.0/kiro/utils/files.py

@@ -0,0 +1,24 @@
+#for every file read file replace placeholders write file
+from pathlib import Path
+
+def replace_placeholders(project_path, state):
+    placeholders = {
+        "{{project_name}}": state.project_name,
+        "{{runtime}}": state.runtime,
+        "{{framework}}": state.framework,
+        "{{language}}": state.language or "",
+    }
+
+    for file in Path(project_path).rglob("*"):
+        if file.is_file():
+            try:
+                content = file.read_text(encoding="utf-8")
+
+                for placeholder, value in placeholders.items():
+                    content = content.replace(placeholder, value)
+
+                file.write_text(content, encoding = "utf-8")
+
+            except UnicodeDecodeError:
+
+                continue

kiro_cli-1.0.0/kiro_cli.egg-info/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: kiro-cli
+Version: 1.0.0
+Summary: A CLI scaffolding tool for backend projects
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer
+Requires-Dist: questionary
+Requires-Dist: rich
+Dynamic: license-file
+
+# ⚡ Kiro
+
+Kiro is a CLI scaffolding tool that helps developers quickly set up backend projects without wasting time on repetitive configuration.
+
+Instead of manually setting up folders, dependencies, and boilerplate, Kiro guides you through an interactive setup and generates a ready-to-code project.
+
+---
+
+## 🚀 Features (current stage)
+
+- Interactive CLI wizard
+- Runtime selection (Node.js, Python)
+- Framework selection based on runtime
+- Project name prompt
+- Automatic folder generation
+- Basic starter files setup
+- file config for node js(ts/js) and python
+
+---
+
+## 📦 Installation (development)
+
+```bash
+pip install -r requirements.txt
+```
+
+Follow the interactive prompts to generate a project.
+
+---
+
+## 📁 Output Example
+
+```bash
+
+my-app/
+├── src/
+│   ├── main.py / index.js
+│   └── routes/
+
+```
+
+
+## 🚧 Roadmap
+
+ Template engine system
+ Dependency auto-installation
+ Git initialization support
+ Docker integration
+ Database setup wizard
+ Plugin-based architecture
+ Global CLI installation (npm/pipx-style experience)
+ Web landing page + documentation site
+
+
+## 🧠 Philosophy
+
+Kiro is built around a simple idea:
+
+“Stop setting up. Start building.”
+
+The focus is on reducing friction between idea and execution.
+
+.
+
+## 👨‍💻 Author
+
+Built by Jimoh Olamide Prince
+
+## 📜 License
+MIT

kiro_cli-1.0.0/kiro_cli.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+LICENSE
+README.md
+pyproject.toml
+kiro/__init__.py
+kiro/cli.py
+kiro/constants.py
+kiro/database.py
+kiro/generators.py
+kiro/installers.py
+kiro/main.py
+kiro/orm.py
+kiro/packages.py
+kiro/prompts.py
+kiro/state.py
+kiro/ui.py
+kiro/templates/python/fastapi/app/main.py
+kiro/templates/python/flask/app.py
+kiro/utils/files.py
+kiro/utils/logger.py
+kiro/utils/shell.py
+kiro_cli.egg-info/PKG-INFO
+kiro_cli.egg-info/SOURCES.txt
+kiro_cli.egg-info/dependency_links.txt
+kiro_cli.egg-info/entry_points.txt
+kiro_cli.egg-info/requires.txt
+kiro_cli.egg-info/top_level.txt

kiro_cli-1.0.0/kiro_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kiro_cli-1.0.0/kiro_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kiro = kiro.main:app

kiro_cli-1.0.0/kiro_cli.egg-info/requires.txt

@@ -0,0 +1,3 @@
+typer
+questionary
+rich

kiro_cli-1.0.0/kiro_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+kiro

kiro_cli-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+
+[project]
+name = "kiro-cli"
+version = "1.0.0"
+description = "A CLI scaffolding tool for backend projects"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+
+dependencies = [
+    "typer",
+    "questionary",
+    "rich"
+]
+
+
+[project.scripts]
+kiro = "kiro.main:app"

kiro_cli-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+