osdlc-kit 0.3.0__py3-none-any.whl

osdlc/__main__.py

@@ -0,0 +1,5 @@
+import sys
+from osdlc.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

osdlc/cli.py

@@ -0,0 +1,188 @@
+import os
+import sys
+import argparse
+from osdlc.detector import detect_project_type, suggest_language_by_extension
+from osdlc.scaffold import scaffold
+
+
+def prompt(prompt_text, default=None):
+    if default is not None:
+        user_input = input(f"{prompt_text} [{default}]: ").strip()
+        return user_input if user_input else default
+    return input(f"{prompt_text}: ").strip()
+
+
+def confirm(prompt_text, default=True):
+    default_str = "Y/n" if default else "y/N"
+    user_input = input(f"{prompt_text} [{default_str}]: ").strip().lower()
+    if not user_input:
+        return default
+    return user_input.startswith("y")
+
+
+def print_banner():
+    print("=" * 60)
+    print("  AI Open SDLC Kit - Project Scaffolding")
+    print("=" * 60)
+
+
+def print_summary(generated, skipped, errors):
+    print()
+    print("=" * 60)
+    print("  Summary")
+    print("=" * 60)
+
+    if generated:
+        print(f"\n  Generated ({len(generated)} files):")
+        for f in generated:
+            print(f"    + {f}")
+
+    if skipped:
+        print(f"\n  Skipped ({len(skipped)} files - already exist):")
+        for f in skipped:
+            print(f"    ~ {f}")
+        print("\n  Use --force to overwrite existing files.")
+
+    if errors:
+        print(f"\n  Errors ({len(errors)}):")
+        for f, err in errors:
+            print(f"    ! {f}: {err}")
+
+    print()
+    print("  Quick Start:")
+    print("  -------------")
+    print("  Run /oc analyze on any issue to start the agent-driven SDLC cycle.")
+    print("  Create an issue and comment with '/oc analyze' to get started.")
+    print()
+
+
+def check_git_repo(root="."):
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            capture_output=True, text=True, timeout=5,
+            cwd=root
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="AI Open SDLC Kit - Bootstrap your repository with SDLC methodology"
+    )
+    parser.add_argument(
+        "command", nargs="?", default="init",
+        choices=["init"],
+        help="Command to run (default: init)"
+    )
+    parser.add_argument(
+        "--force", "-f", action="store_true",
+        help="Overwrite existing files"
+    )
+    parser.add_argument(
+        "--target", "-t", default=".",
+        help="Target directory (default: current directory)"
+    )
+    parser.add_argument(
+        "--non-interactive", action="store_true",
+        help="Skip interactive prompts (use defaults/detected values)"
+    )
+
+    args = parser.parse_args()
+
+    if args.command != "init":
+        print(f"Unknown command: {args.command}")
+        return 1
+
+    root = os.path.abspath(args.target)
+
+    if not os.path.isdir(root):
+        print(f"Error: target directory '{root}' does not exist.")
+        return 1
+
+    if not check_git_repo(root):
+        print("Warning: Not inside a Git repository. Some features may not work.")
+        print("Consider running 'git init' first.")
+
+    print_banner()
+
+    detected = detect_project_type(root)
+    ext_lang = suggest_language_by_extension(root)
+
+    if detected:
+        print(f"\n  Detected: {detected['language']} ({detected['build_system']})")
+    elif ext_lang:
+        print(f"\n  Suggested language (by file extension): {ext_lang}")
+    else:
+        print("\n  No build system detected. You will be prompted for project details.")
+
+    print()
+
+    if args.non_interactive:
+        if detected:
+            config = detected.copy()
+        else:
+            config = {
+                "build_system": "unknown",
+                "language": ext_lang or "unknown",
+                "version_file": "VERSION",
+                "build_cmd": "echo 'no build command configured'",
+                "test_cmd": "echo 'no test command configured'",
+                "lint_cmd": "echo 'no lint command configured'",
+                "probe": "manual",
+            }
+        config.setdefault("project_name", os.path.basename(root))
+        config.setdefault("default_branch", "main")
+        config.setdefault("error_to_issue", False)
+        config.setdefault("provider_google", "")
+        config.setdefault("model", "opencode/deepseek-v4-flash-free")
+        config.setdefault("env_notes", "No special environment constraints.")
+        config.setdefault("architectural_notes", "")
+    else:
+        config = {}
+
+        template = detected or {}
+
+        project_name = prompt("Project name", default=os.path.basename(root))
+        config["project_name"] = project_name
+
+        config["default_branch"] = prompt("Default branch name", default="main")
+
+        version_file_default = template.get("version_file", "VERSION")
+        config["version_file"] = prompt("Version config file path", default=version_file_default)
+
+        config["build_cmd"] = prompt("Build command", default=template.get("build_cmd", "echo 'no build'"))
+        config["test_cmd"] = prompt("Test command", default=template.get("test_cmd", "echo 'no tests'"))
+        config["lint_cmd"] = prompt("Lint command", default=template.get("lint_cmd", "echo 'no linter'"))
+
+        config["language"] = template.get("language", ext_lang or prompt("Language", default="unknown"))
+        config["build_system"] = template.get("build_system", prompt("Build system", default="manual"))
+        config["probe"] = template.get("probe", "manual")
+
+        error_to_issue = confirm("Enable error-to-issue pipeline?", default=False)
+        config["error_to_issue"] = error_to_issue
+
+        if error_to_issue:
+            config["github_token_env"] = prompt("GITHUB_TOKEN environment variable name", default="GITHUB_TOKEN")
+            config["provider_google"] = ',\n    "google": {\n      "options": {\n        "timeout": 300000,\n        "chunkTimeout": 60000\n      }\n    }'
+        else:
+            config["provider_google"] = ""
+
+        config["model"] = prompt("Default model", default="opencode/deepseek-v4-flash-free")
+
+        config["env_notes"] = prompt("Environment notes (optional)", default="No special environment constraints.")
+        config["architectural_notes"] = prompt("Architectural notes (optional)", default="")
+
+    print("Scaffolding project...")
+    generated, skipped, errors = scaffold(config, root=root, force=args.force)
+
+    print_summary(generated, skipped, errors)
+
+    return 0 if not errors else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

osdlc/detector.py

@@ -0,0 +1,67 @@
+import os
+
+PROBES = [
+    ("pom.xml",             "Maven",       "Java",        "pom.xml",              "mvn compile",           "mvn test",            "mvn checkstyle:check"),
+    ("build.gradle.kts",    "Gradle Kotlin","Kotlin/Java","gradle.properties",    "./gradlew build",       "./gradlew test",      "./gradlew ktlintCheck"),
+    ("build.gradle",        "Gradle",      "Java",        "gradle.properties",    "./gradlew build",       "./gradlew test",      "./gradlew check"),
+    ("yarn.lock",           "Yarn",        "JavaScript",  "package.json",         "yarn build",            "yarn test",           "yarn lint"),
+    ("pnpm-lock.yaml",      "pnpm",        "JavaScript",  "package.json",         "pnpm build",            "pnpm test",           "pnpm lint"),
+    ("package.json",        "npm",         "JavaScript",  "package.json",         "npm run build",         "npm test",            "npm run lint"),
+    ("Cargo.toml",          "Cargo",       "Rust",        "Cargo.toml",           "cargo build",           "cargo test",          "cargo clippy"),
+    ("pyproject.toml",      "PEP 621",     "Python",      "pyproject.toml",       "python -m build",       "pytest",              "ruff check ."),
+    ("setup.py",            "setuptools",  "Python",      "VERSION",              "python setup.py sdist", "pytest",              "ruff check ."),
+    ("requirements.txt",    "pip",         "Python",      "VERSION",              "pip install -r requirements.txt", "pytest",        "ruff check ."),
+    ("go.mod",              "Go modules",  "Go",          "version.go",           "go build ./...",        "go test ./...",       "go vet ./..."),
+    ("composer.json",       "Composer",    "PHP",         "composer.json",        "composer install",      "phpunit",             "phpcs"),
+    ("Gemfile",             "Bundler",     "Ruby",        "lib/version.rb",       "bundle exec rake build", "bundle exec rspec",   "bundle exec rubocop"),
+    ("CMakeLists.txt",      "CMake",       "C/C++",       "CMakeLists.txt",       "cmake --build build",   "ctest",               "cmake --build build --target lint"),
+    ("mix.exs",             "Mix",         "Elixir",      "mix.exs",              "mix compile",           "mix test",            "mix credo"),
+]
+
+LANGUAGE_EXTENSIONS = {
+    ".kt":   "Kotlin",
+    ".kts":  "Kotlin",
+    ".java": "Java",
+    ".js":   "JavaScript",
+    ".ts":   "TypeScript",
+    ".jsx":  "React",
+    ".tsx":  "React TypeScript",
+    ".rs":   "Rust",
+    ".py":   "Python",
+    ".go":   "Go",
+    ".rb":   "Ruby",
+    ".ex":   "Elixir",
+    ".exs":  "Elixir",
+    ".php":  "PHP",
+    ".cs":   "C#",
+    ".swift":"Swift",
+}
+
+
+def detect_project_type(root="."):
+    for probe, build_system, language, version_file, build_cmd, test_cmd, lint_cmd in PROBES:
+        path = os.path.join(root, probe)
+        if os.path.exists(path):
+            return {
+                "build_system": build_system,
+                "language": language,
+                "version_file": version_file,
+                "build_cmd": build_cmd,
+                "test_cmd": test_cmd,
+                "lint_cmd": lint_cmd,
+                "probe": probe,
+            }
+    return None
+
+
+def suggest_language_by_extension(root="."):
+    counts = {}
+    for entry in os.scandir(root):
+        if entry.is_file():
+            _, ext = os.path.splitext(entry.name)
+            if ext in LANGUAGE_EXTENSIONS:
+                lang = LANGUAGE_EXTENSIONS[ext]
+                counts[lang] = counts.get(lang, 0) + 1
+    if counts:
+        return max(counts, key=counts.get)
+    return None

osdlc/scaffold.py

@@ -0,0 +1,206 @@
+import os
+from osdlc.templates import ALL_TEMPLATES
+
+
+def detect_codeql_languages(language):
+    mapping = {
+        "Java": "java-kotlin",
+        "Kotlin": "java-kotlin",
+        "Kotlin/Java": "java-kotlin",
+        "JavaScript": "javascript-typescript",
+        "TypeScript": "javascript-typescript",
+        "Python": "python",
+        "Rust": "rust",
+        "Go": "go",
+        "Ruby": "ruby",
+        "PHP": "python",
+        "C/C++": "cpp",
+        "C#": "csharp",
+        "Swift": "swift",
+        "Elixir": "python",
+    }
+    return mapping.get(language, "python")
+
+
+def detect_ecosystem(build_system):
+    mapping = {
+        "Maven": "maven",
+        "Gradle Kotlin": "gradle",
+        "Gradle": "gradle",
+        "npm": "npm",
+        "Yarn": "npm",
+        "pnpm": "npm",
+        "Cargo": "cargo",
+        "PEP 621": "pip",
+        "setuptools": "pip",
+        "pip": "pip",
+        "Go modules": "go_mod",
+        "Composer": "composer",
+        "Bundler": "bundler",
+        "CMake": "cmake",
+        "Mix": "mix",
+    }
+    return mapping.get(build_system, "pip")
+
+
+def detect_language_setup_step(language):
+    mapping = {
+        "Java": """\
+      - name: Set up JDK 17
+        uses: actions/setup-java@v5
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v3""",
+        "Kotlin/Java": """\
+      - name: Set up JDK 17
+        uses: actions/setup-java@v5
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v3""",
+        "JavaScript": """\
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 'latest'
+
+      - name: Install dependencies
+        run: npm ci""",
+        "Python": """\
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Install dependencies
+        run: pip install .""",
+        "Rust": """\
+      - name: Setup Rust
+        uses: dtolnay/action-rust-toolchain@stable""",
+        "Go": """\
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: 'stable'""",
+        "Ruby": """\
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.x'
+          bundler-cache: true""",
+        "PHP": """\
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: '8.2'""",
+        "C/C++": """\
+      - name: Setup CMake
+        uses: lukka/get-cmake@latest""",
+        "Elixir": """\
+      - name: Setup Elixir
+        uses: erlef/setup-beam@v1
+        with:
+          elixir-version: 'latest'
+          otp-version: 'latest'""",
+    }
+    return mapping.get(language, "")
+
+
+def build_template_vars(config):
+    language = config["language"]
+    build_system = config["build_system"]
+    codeql_lang = detect_codeql_languages(language)
+    ecosystem = detect_ecosystem(build_system)
+    lang_setup = detect_language_setup_step(language)
+
+    l = language.lower()
+    validate_java = "true" if l in ("java", "kotlin", "kotlin/java") else "false"
+    validate_kotlin = "true" if l in ("kotlin", "kotlin/java") else "false"
+    validate_javascript = "true" if l in ("javascript", "typescript", "react", "react typescript") else "false"
+    validate_typescript = "true" if l in ("typescript", "react typescript") else "false"
+    validate_python = "true" if l == "python" else "false"
+    validate_go = "true" if l == "go" else "false"
+    validate_rust = "true" if l == "rust" else "false"
+    validate_ruby = "true" if l == "ruby" else "false"
+    validate_php = "true" if l == "php" else "false"
+    validate_xml = "true" if l in ("java", "kotlin", "kotlin/java") else "false"
+    validate_properties = "true" if l in ("java", "kotlin", "kotlin/java") else "false"
+
+    return {
+        "project_name": config.get("project_name", "my-project"),
+        "default_branch": config["default_branch"],
+        "version_file": config["version_file"],
+        "build_cmd": config["build_cmd"],
+        "test_cmd": config["test_cmd"],
+        "lint_cmd": config["lint_cmd"],
+        "language_description": f"This project uses {language} with the {build_system} build system ({config['probe']}).",
+        "env_notes": config.get("env_notes", "No special environment constraints."),
+        "architectural_notes": config.get("architectural_notes", ""),
+        "model": config.get("model", "opencode/deepseek-v4-flash-free"),
+        "provider_google": config.get("provider_google", ""),
+        "codeql_languages": repr(codeql_lang),
+        "ecosystem": ecosystem,
+        "language_setup": lang_setup,
+        "validate_java": validate_java,
+        "validate_kotlin": validate_kotlin,
+        "validate_javascript": validate_javascript,
+        "validate_typescript": validate_typescript,
+        "validate_python": validate_python,
+        "validate_go": validate_go,
+        "validate_rust": validate_rust,
+        "validate_ruby": validate_ruby,
+        "validate_php": validate_php,
+        "validate_xml": validate_xml,
+        "validate_properties": validate_properties,
+    }
+
+
+def render_template(template, vars_dict):
+    result = template
+    for key, value in vars_dict.items():
+        placeholder = "{" + key + "}"
+        result = result.replace(placeholder, str(value))
+    return result
+
+
+def scaffold(config, root=".", force=False):
+    vars_dict = build_template_vars(config)
+    generated = []
+    skipped = []
+    errors = []
+
+    templates = dict(ALL_TEMPLATES)
+    if not config.get("error_to_issue"):
+        templates.pop(".opencode/skills/error-handling/SKILL.md", None)
+
+    dirs_to_create = set()
+    for filepath in templates:
+        full_path = os.path.join(root, filepath)
+        parent = os.path.dirname(full_path)
+        if parent:
+            dirs_to_create.add(parent)
+
+    for d in sorted(dirs_to_create):
+        os.makedirs(d, exist_ok=True)
+
+    for filepath, template in templates.items():
+        full_path = os.path.join(root, filepath)
+
+        if os.path.exists(full_path) and not force:
+            skipped.append(filepath)
+            continue
+
+        try:
+            content = render_template(template, vars_dict)
+            with open(full_path, "w", newline="\n", encoding="utf-8") as f:
+                f.write(content)
+            generated.append(filepath)
+        except Exception as e:
+            errors.append((filepath, str(e)))
+
+    return generated, skipped, errors