skene 0.3.0__py3-none-any.whl

skene/__init__.py

@@ -0,0 +1,84 @@
+"""
+skene: PLG analysis toolkit for codebases.
+
+This library provides tools for analyzing codebases, detecting growth opportunities,
+and generating documentation.
+"""
+
+from skene.analyzers import (
+    GrowthFeaturesAnalyzer,
+    ManifestAnalyzer,
+    TechStackAnalyzer,
+)
+from skene.codebase import (
+    DEFAULT_EXCLUDE_FOLDERS,
+    CodebaseExplorer,
+    build_directory_tree,
+)
+from skene.config import Config, load_config
+from skene.docs import DocsGenerator, PSEOBuilder
+from skene.llm import LLMClient, create_llm_client
+from skene.manifest import (
+    GrowthFeature,
+    GrowthManifest,
+    GrowthOpportunity,
+    TechStack,
+)
+from skene.planner import (
+    Planner,
+)
+from skene.strategies import (
+    AnalysisContext,
+    AnalysisMetadata,
+    AnalysisResult,
+    AnalysisStrategy,
+    MultiStepStrategy,
+)
+from skene.strategies.steps import (
+    AnalysisStep,
+    AnalyzeStep,
+    GenerateStep,
+    ReadFilesStep,
+    SelectFilesStep,
+)
+
+__version__ = "0.3.0"
+
+__all__ = [
+    # Analyzers
+    "TechStackAnalyzer",
+    "GrowthFeaturesAnalyzer",
+    "ManifestAnalyzer",
+    # Manifest schemas
+    "TechStack",
+    "GrowthFeature",
+    "GrowthOpportunity",
+    "GrowthManifest",
+    # Codebase
+    "CodebaseExplorer",
+    "build_directory_tree",
+    "DEFAULT_EXCLUDE_FOLDERS",
+    # Config
+    "Config",
+    "load_config",
+    # LLM
+    "LLMClient",
+    "create_llm_client",
+    # Strategies
+    "AnalysisStrategy",
+    "AnalysisResult",
+    "AnalysisMetadata",
+    "AnalysisContext",
+    "MultiStepStrategy",
+    # Steps
+    "AnalysisStep",
+    "SelectFilesStep",
+    "ReadFilesStep",
+    "AnalyzeStep",
+    "GenerateStep",
+    # Documentation
+    "DocsGenerator",
+    "PSEOBuilder",
+    # Planner
+    "Planner",
+]

skene/analyzers/__init__.py

@@ -0,0 +1,18 @@
+"""
+Analyzers for PLG (Product-Led Growth) analysis.
+
+Each analyzer uses the MultiStepStrategy pattern to perform
+a specific type of analysis on a codebase.
+"""
+
+from skene.analyzers.docs import DocsAnalyzer
+from skene.analyzers.growth_features import GrowthFeaturesAnalyzer
+from skene.analyzers.manifest import ManifestAnalyzer
+from skene.analyzers.tech_stack import TechStackAnalyzer
+
+__all__ = [
+    "TechStackAnalyzer",
+    "GrowthFeaturesAnalyzer",
+    "ManifestAnalyzer",
+    "DocsAnalyzer",
+]

skene/analyzers/docs.py

@@ -0,0 +1,179 @@
+"""
+Documentation-focused analyzer using MultiStepStrategy.
+
+Extends growth manifest analysis to include real product documentation
+fields like product_overview and features.
+"""
+
+from typing import Any
+
+from skene.analyzers.prompts import (
+    FEATURES_PROMPT,
+    INDUSTRY_PROMPT,
+    PRODUCT_OVERVIEW_PROMPT,
+    TECH_STACK_PROMPT,
+    build_docs_manifest_prompt,
+    build_growth_features_prompt,
+)
+from skene.manifest import (
+    DocsManifest,
+    IndustryInfo,
+    ProductOverview,
+    TechStack,
+)
+from skene.strategies import MultiStepStrategy
+from skene.strategies.steps import (
+    AnalyzeStep,
+    GenerateStep,
+    ReadFilesStep,
+    SelectFilesStep,
+)
+
+
+class DocsAnalyzer(MultiStepStrategy):
+    """
+    Documentation analyzer that produces a DocsManifest.
+
+    This analyzer extends the base growth manifest with documentation
+    fields by running in 5 phases:
+
+    1. Tech stack detection (config files)
+    2. Product overview extraction (README, docs)
+    3. Industry classification (reuses docs from phase 2)
+    4. Feature documentation + current growth features (source files)
+    5. Final manifest generation
+
+    Example:
+        analyzer = DocsAnalyzer()
+        result = await analyzer.run(
+            codebase=CodebaseExplorer("/path/to/repo"),
+            llm=create_llm_client(),
+            request="Generate documentation for this project",
+        )
+        manifest = DocsManifest.model_validate(result.data.get("output"))
+    """
+
+    def __init__(self, existing_growth_loops: list[dict[str, Any]] | None = None):
+        """Initialize the docs analyzer with all analysis steps."""
+        self.existing_growth_loops = existing_growth_loops or []
+
+        # Format existing loops for prompt inclusion
+        from skene.growth_loops.storage import format_growth_loops_summary
+
+        loops_summary = format_growth_loops_summary(self.existing_growth_loops)
+
+        # Build prompts with existing loops context
+        growth_features_prompt = build_growth_features_prompt(loops_summary)
+        docs_manifest_prompt = build_docs_manifest_prompt(loops_summary)
+
+        super().__init__(
+            steps=[
+                # Phase 1: Tech Stack Detection
+                SelectFilesStep(
+                    prompt="Select configuration files for tech stack detection. "
+                    "Include package managers, framework configs, and dependency files.",
+                    patterns=[
+                        "package.json",
+                        "requirements.txt",
+                        "pyproject.toml",
+                        "Cargo.toml",
+                        "go.mod",
+                        "Gemfile",
+                        "*.config.js",
+                        "*.config.ts",
+                        "tsconfig.json",
+                        "docker-compose.yml",
+                        "Dockerfile",
+                    ],
+                    max_files=10,
+                    output_key="config_files",
+                ),
+                ReadFilesStep(
+                    source_key="config_files",
+                    output_key="config_contents",
+                ),
+                AnalyzeStep(
+                    prompt=TECH_STACK_PROMPT,
+                    output_schema=TechStack,
+                    output_key="tech_stack",
+                    source_key="config_contents",
+                ),
+                # Phase 2: Product Overview Extraction
+                SelectFilesStep(
+                    prompt="Select documentation files for product overview. "
+                    "Look for README, docs, and package descriptions.",
+                    patterns=[
+                        "README.md",
+                        "README*.md",
+                        "readme.md",
+                        "docs/*.md",
+                        "docs/**/*.md",
+                        "package.json",
+                        "pyproject.toml",
+                        "Cargo.toml",
+                    ],
+                    max_files=8,
+                    output_key="overview_files",
+                ),
+                ReadFilesStep(
+                    source_key="overview_files",
+                    output_key="overview_contents",
+                ),
+                AnalyzeStep(
+                    prompt=PRODUCT_OVERVIEW_PROMPT,
+                    output_schema=ProductOverview,
+                    output_key="product_overview",
+                    source_key="overview_contents",
+                ),
+                # Phase 3: Industry Classification (reuses overview_contents)
+                AnalyzeStep(
+                    prompt=INDUSTRY_PROMPT,
+                    output_schema=IndustryInfo,
+                    output_key="industry",
+                    source_key="overview_contents",
+                ),
+                # Phase 4: Feature Documentation + Current Growth Features
+                SelectFilesStep(
+                    prompt="Select source files with growth features. "
+                    "Look for user management, invitations, sharing, payments, analytics.",
+                    patterns=[
+                        "**/*.py",
+                        "**/*.ts",
+                        "**/*.tsx",
+                        "**/*.js",
+                        "**/routes/**/*",
+                        "**/api/**/*",
+                        "**/features/**/*",
+                    ],
+                    max_files=30,
+                    output_key="source_files",
+                ),
+                ReadFilesStep(
+                    source_key="source_files",
+                    output_key="source_contents",
+                ),
+                AnalyzeStep(
+                    prompt=FEATURES_PROMPT,
+                    output_key="features",
+                    source_key="source_contents",
+                ),
+                AnalyzeStep(
+                    prompt=growth_features_prompt,
+                    output_key="current_growth_features",
+                    source_key="source_contents",
+                ),
+                # Phase 5: Final Manifest Generation
+                GenerateStep(
+                    prompt=docs_manifest_prompt,
+                    output_schema=DocsManifest,
+                    include_context_keys=[
+                        "tech_stack",
+                        "product_overview",
+                        "industry",
+                        "features",
+                        "current_growth_features",
+                    ],
+                    output_key="output",
+                ),
+            ]
+        )

skene/analyzers/growth_features.py

@@ -0,0 +1,71 @@
+"""
+Growth features analyzer using MultiStepStrategy.
+
+Identifies current features and areas of a codebase with growth potential.
+"""
+
+from skene.analyzers.prompts import GROWTH_FEATURES_PROMPT
+from skene.strategies import MultiStepStrategy
+from skene.strategies.steps import (
+    AnalyzeStep,
+    ReadFilesStep,
+    SelectFilesStep,
+)
+
+
+class GrowthFeaturesAnalyzer(MultiStepStrategy):
+    """
+    Analyzer for identifying current growth features in a codebase.
+
+    Current growth features are features or areas that:
+    - Enable viral growth (sharing, invitations, referrals)
+    - Drive user engagement
+    - Facilitate onboarding
+    - Support monetization
+    - Enable data-driven decisions
+
+    Example:
+        analyzer = GrowthFeaturesAnalyzer()
+        result = await analyzer.run(
+            codebase=CodebaseExplorer("/path/to/repo"),
+            llm=create_llm_client(),
+            request="Find growth opportunities",
+        )
+        features = result.data.get("current_growth_features", [])
+    """
+
+    def __init__(self):
+        """Initialize the growth features analyzer with predefined steps."""
+        super().__init__(
+            steps=[
+                SelectFilesStep(
+                    prompt="Select source files that might contain growth-related features. "
+                    "Look for: user management, invitations, sharing, payments, "
+                    "analytics, onboarding, notifications, and engagement features.",
+                    patterns=[
+                        "**/*.py",
+                        "**/*.ts",
+                        "**/*.tsx",
+                        "**/*.js",
+                        "**/*.jsx",
+                        "**/routes/**/*",
+                        "**/api/**/*",
+                        "**/features/**/*",
+                        "**/components/**/*",
+                        "**/pages/**/*",
+                        "**/app/**/*",
+                    ],
+                    max_files=30,
+                    output_key="selected_files",
+                ),
+                ReadFilesStep(
+                    source_key="selected_files",
+                    output_key="file_contents",
+                ),
+                AnalyzeStep(
+                    prompt=GROWTH_FEATURES_PROMPT,
+                    output_key="current_growth_features",
+                    source_key="file_contents",
+                ),
+            ]
+        )

skene/analyzers/manifest.py

@@ -0,0 +1,197 @@
+"""
+Full manifest analyzer using MultiStepStrategy.
+
+Combines tech stack and growth features analysis to produce
+a complete GrowthManifest.
+"""
+
+from typing import Any
+
+from skene.analyzers.prompts import (
+    INDUSTRY_PROMPT,
+    REVENUE_LEAKAGE_PROMPT,
+    TECH_STACK_PROMPT,
+    build_growth_features_prompt,
+    build_manifest_prompt,
+)
+from skene.manifest import GrowthManifest, IndustryInfo, TechStack
+from skene.strategies import MultiStepStrategy
+from skene.strategies.steps import (
+    AnalyzeStep,
+    GenerateStep,
+    ReadFilesStep,
+    SelectFilesStep,
+)
+
+
+class ManifestAnalyzer(MultiStepStrategy):
+    """
+    Full-pipeline analyzer that produces a complete GrowthManifest.
+
+    This analyzer runs in four phases:
+    1. Tech stack detection (config files)
+    2. Current growth features identification (source files)
+    3. Revenue leakage analysis (pricing/payment files)
+    4. Industry classification (docs/README)
+    5. Manifest generation (combining results + growth opportunities)
+
+    Example:
+        analyzer = ManifestAnalyzer()
+        result = await analyzer.run(
+            codebase=CodebaseExplorer("/path/to/repo"),
+            llm=create_llm_client(),
+            request="Generate a growth manifest for this project",
+        )
+        manifest = GrowthManifest.model_validate(result.data.get("output"))
+    """
+
+    def __init__(self, existing_growth_loops: list[dict[str, Any]] | None = None):
+        """Initialize the manifest analyzer with all analysis steps."""
+        self.existing_growth_loops = existing_growth_loops or []
+
+        # Format existing loops for prompt inclusion
+        from skene.growth_loops.storage import format_growth_loops_summary
+
+        loops_summary = format_growth_loops_summary(self.existing_growth_loops)
+
+        # Build prompts with existing loops context
+        growth_features_prompt = build_growth_features_prompt(loops_summary)
+        manifest_prompt = build_manifest_prompt(loops_summary)
+
+        super().__init__(
+            steps=[
+                # Phase 1: Detect tech stack
+                SelectFilesStep(
+                    prompt="Select configuration files and representative source files for tech stack detection. "
+                    "Include package managers, framework configs, dependency files, "
+                    "and a few source files to identify the language.",
+                    patterns=[
+                        "package.json",
+                        "requirements.txt",
+                        "pyproject.toml",
+                        "Cargo.toml",
+                        "go.mod",
+                        "Gemfile",
+                        "*.config.js",
+                        "*.config.ts",
+                        "tsconfig.json",
+                        "docker-compose.yml",
+                        "Dockerfile",
+                        # Include source files to help identify language
+                        "**/*.py",
+                        "**/*.js",
+                        "**/*.ts",
+                        "**/*.tsx",
+                        "**/*.go",
+                        "**/*.rs",
+                        "**/*.rb",
+                    ],
+                    max_files=15,
+                    output_key="config_files",
+                ),
+                ReadFilesStep(
+                    source_key="config_files",
+                    output_key="file_contents",
+                ),
+                AnalyzeStep(
+                    prompt=TECH_STACK_PROMPT,
+                    output_schema=TechStack,
+                    output_key="tech_stack",
+                    source_key="file_contents",
+                ),
+                # Phase 2: Find current growth features
+                # Note: file_contents will be overwritten, but tech_stack is preserved
+                SelectFilesStep(
+                    prompt="Select source files with potential growth features. "
+                    "Look for user management, invitations, sharing, payments, "
+                    "analytics, onboarding, and engagement features.",
+                    patterns=[
+                        "**/*.py",
+                        "**/*.ts",
+                        "**/*.tsx",
+                        "**/*.js",
+                        "**/routes/**/*",
+                        "**/api/**/*",
+                        "**/features/**/*",
+                    ],
+                    max_files=30,
+                    output_key="source_files",
+                ),
+                ReadFilesStep(
+                    source_key="source_files",
+                    output_key="file_contents",
+                ),
+                AnalyzeStep(
+                    prompt=growth_features_prompt,
+                    output_key="current_growth_features",
+                    source_key="file_contents",
+                ),
+                # Phase 2.5: Analyze revenue leakage
+                SelectFilesStep(
+                    prompt="Select files related to pricing, payments, subscriptions, billing, "
+                    "usage limits, feature flags, tier management, and monetization. "
+                    "Look for payment processing, subscription logic, free tier restrictions, "
+                    "upgrade prompts, and pricing configurations.",
+                    patterns=[
+                        "**/pricing/**/*",
+                        "**/payment/**/*",
+                        "**/billing/**/*",
+                        "**/subscription/**/*",
+                        "**/plan/**/*",
+                        "**/tier/**/*",
+                        "**/usage/**/*",
+                        "**/limit/**/*",
+                        "**/upgrade/**/*",
+                        "**/monetization/**/*",
+                        "**/stripe/**/*",
+                        "**/paypal/**/*",
+                    ],
+                    max_files=20,
+                    output_key="revenue_files",
+                ),
+                ReadFilesStep(
+                    source_key="revenue_files",
+                    output_key="revenue_file_contents",
+                ),
+                AnalyzeStep(
+                    prompt=REVENUE_LEAKAGE_PROMPT,
+                    output_key="revenue_leakage",
+                    source_key="revenue_file_contents",
+                ),
+                # Phase 3: Industry classification
+                SelectFilesStep(
+                    prompt="Select documentation and package metadata files for industry classification. "
+                    "Look for README, docs, and package descriptors that describe what the product does.",
+                    patterns=[
+                        "README.md",
+                        "README*.md",
+                        "readme.md",
+                        "docs/*.md",
+                        "docs/**/*.md",
+                        "package.json",
+                        "pyproject.toml",
+                        "Cargo.toml",
+                        "go.mod",
+                    ],
+                    max_files=10,
+                    output_key="industry_files",
+                ),
+                ReadFilesStep(
+                    source_key="industry_files",
+                    output_key="industry_file_contents",
+                ),
+                AnalyzeStep(
+                    prompt=INDUSTRY_PROMPT,
+                    output_schema=IndustryInfo,
+                    output_key="industry",
+                    source_key="industry_file_contents",
+                ),
+                # Phase 4: Generate final manifest
+                GenerateStep(
+                    prompt=manifest_prompt,
+                    output_schema=GrowthManifest,
+                    include_context_keys=["tech_stack", "current_growth_features", "revenue_leakage", "industry"],
+                    output_key="output",
+                ),
+            ]
+        )