@10et/cli 1.0.0

package/dist/lib/service-analyzer.js

@@ -0,0 +1,704 @@
+/**
+ * Service Analyzer
+ *
+ * Deep codebase analysis for existing software projects.
+ * Two-pass: static file scan + optional LLM synthesis.
+ *
+ * @purpose Deep-analyze a codebase to generate GTM context and tailored questionnaire
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, relative, extname } from "path";
+import { execSync } from "child_process";
+import { extractServiceMetadata } from "./service-detector.js";
+const SKIP_DIRS = new Set([
+    "node_modules", "dist", "build", "out", ".next", ".git", ".jfl", ".claude",
+    ".tenet", "__pycache__", ".venv", "venv", "target", "vendor", ".turbo",
+    "coverage", ".nyc_output", ".cache", ".parcel-cache", "tmp", "temp",
+]);
+const ENTRY_POINT_CANDIDATES = [
+    "src/index.ts", "src/index.tsx", "src/main.ts", "src/main.tsx",
+    "src/app.ts", "src/server.ts", "src/cli.ts",
+    "app/page.tsx", "app/layout.tsx", "pages/index.tsx",
+    "index.ts", "index.js", "main.ts", "main.go", "main.rs",
+    "server.ts", "server.js", "server.py",
+    "app.ts", "app.js", "app.py",
+    "cmd/main.go", "src/main.rs", "src/lib.rs",
+];
+const MAX_FILES = 200;
+const MAX_PREVIEW_LINES = 100;
+export function detectExistingProject(dir) {
+    const indicators = [
+        "package.json", "Cargo.toml", "go.mod", "pyproject.toml",
+        "Gemfile", "setup.py", "requirements.txt", "pom.xml",
+        "build.gradle", "CMakeLists.txt", "Makefile",
+    ];
+    const hasIndicator = indicators.some(f => existsSync(join(dir, f)));
+    const hasSourceDir = existsSync(join(dir, "src")) || existsSync(join(dir, "app")) || existsSync(join(dir, "lib"));
+    const isAlreadyJfl = existsSync(join(dir, ".jfl", "config.json"));
+    return (hasIndicator || hasSourceDir) && !isAlreadyJfl;
+}
+export function deepScan(servicePath) {
+    const metadata = extractServiceMetadata(servicePath);
+    return {
+        metadata,
+        readme: readReadme(servicePath),
+        fileTree: collectFileTree(servicePath),
+        entryPoints: collectEntryPoints(servicePath),
+        apiRoutes: detectApiRoutes(servicePath),
+        database: detectDatabase(servicePath),
+        auth: detectAuth(servicePath),
+        ci: detectCI(servicePath),
+        testing: detectTesting(servicePath),
+        envVars: detectEnvVars(servicePath),
+        openApiSpec: detectOpenApiSpec(servicePath),
+        gitHistory: collectGitHistory(servicePath),
+        monorepo: detectMonorepo(servicePath),
+        workspaces: detectWorkspaces(servicePath),
+        packageDescription: readPackageDescription(servicePath),
+        scripts: readPackageScripts(servicePath),
+    };
+}
+function readReadme(dir) {
+    const candidates = ["README.md", "README.MD", "readme.md", "README", "readme"];
+    for (const name of candidates) {
+        const p = join(dir, name);
+        if (existsSync(p)) {
+            const content = readFileSync(p, "utf-8");
+            return content.length > 15000 ? content.slice(0, 15000) + "\n...[truncated]" : content;
+        }
+    }
+    return null;
+}
+function collectFileTree(dir, maxFiles = MAX_FILES) {
+    const files = [];
+    function walk(current, depth) {
+        if (depth > 8 || files.length >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(current);
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            if (files.length >= maxFiles)
+                break;
+            const fullPath = join(current, name);
+            let isDir = false;
+            try {
+                isDir = statSync(fullPath).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (isDir) {
+                if (SKIP_DIRS.has(name) || name.startsWith("."))
+                    continue;
+                walk(fullPath, depth + 1);
+            }
+            else {
+                files.push(relative(dir, fullPath));
+            }
+        }
+    }
+    walk(dir, 0);
+    return files.sort();
+}
+function collectEntryPoints(dir) {
+    const results = [];
+    for (const candidate of ENTRY_POINT_CANDIDATES) {
+        const fullPath = join(dir, candidate);
+        if (existsSync(fullPath)) {
+            try {
+                const content = readFileSync(fullPath, "utf-8");
+                const lines = content.split("\n").slice(0, MAX_PREVIEW_LINES);
+                results.push({ path: candidate, preview: lines.join("\n") });
+            }
+            catch {
+                // skip unreadable
+            }
+        }
+        if (results.length >= 6)
+            break;
+    }
+    return results;
+}
+function detectApiRoutes(dir) {
+    const routes = [];
+    const routeDirs = [
+        "src/routes", "src/api", "routes", "api",
+        "app/api", "pages/api", "src/app/api",
+        "src/controllers", "controllers",
+    ];
+    for (const routeDir of routeDirs) {
+        const fullPath = join(dir, routeDir);
+        if (!existsSync(fullPath))
+            continue;
+        try {
+            const files = collectFileTree(fullPath, 50);
+            for (const f of files) {
+                const ext = extname(f);
+                if ([".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs"].includes(ext)) {
+                    routes.push(join(routeDir, f));
+                }
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    return routes;
+}
+function detectDatabase(dir) {
+    if (existsSync(join(dir, "prisma", "schema.prisma"))) {
+        const schema = readFileSync(join(dir, "prisma", "schema.prisma"), "utf-8");
+        const truncated = schema.length > 5000 ? schema.slice(0, 5000) + "\n...[truncated]" : schema;
+        return { type: "prisma", schema: truncated };
+    }
+    if (existsSync(join(dir, "drizzle.config.ts")) || existsSync(join(dir, "drizzle.config.js"))) {
+        return { type: "drizzle" };
+    }
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (allDeps["mongoose"] || allDeps["mongodb"])
+                return { type: "mongodb" };
+            if (allDeps["pg"] || allDeps["postgres"] || allDeps["@neondatabase/serverless"])
+                return { type: "postgresql" };
+            if (allDeps["mysql2"] || allDeps["mysql"])
+                return { type: "mysql" };
+            if (allDeps["better-sqlite3"] || allDeps["sqlite3"])
+                return { type: "sqlite" };
+            if (allDeps["redis"] || allDeps["ioredis"])
+                return { type: "redis" };
+            if (allDeps["typeorm"])
+                return { type: "typeorm" };
+            if (allDeps["sequelize"])
+                return { type: "sequelize" };
+            if (allDeps["knex"])
+                return { type: "knex" };
+        }
+        catch {
+            // skip
+        }
+    }
+    const pyFiles = ["requirements.txt", "pyproject.toml"];
+    for (const f of pyFiles) {
+        const p = join(dir, f);
+        if (existsSync(p)) {
+            const content = readFileSync(p, "utf-8").toLowerCase();
+            if (content.includes("sqlalchemy"))
+                return { type: "sqlalchemy" };
+            if (content.includes("django"))
+                return { type: "django-orm" };
+            if (content.includes("tortoise"))
+                return { type: "tortoise-orm" };
+            if (content.includes("pymongo"))
+                return { type: "mongodb" };
+        }
+    }
+    if (existsSync(join(dir, "go.mod"))) {
+        const goMod = readFileSync(join(dir, "go.mod"), "utf-8").toLowerCase();
+        if (goMod.includes("gorm"))
+            return { type: "gorm" };
+        if (goMod.includes("sqlx"))
+            return { type: "sqlx" };
+        if (goMod.includes("pgx"))
+            return { type: "postgresql" };
+    }
+    return null;
+}
+function detectAuth(dir) {
+    const authFiles = [
+        "src/auth.ts", "src/lib/auth.ts", "src/middleware/auth.ts",
+        "auth.ts", "lib/auth.ts", "middleware/auth.ts",
+        "src/auth/index.ts", "app/api/auth/[...nextauth]/route.ts",
+    ];
+    for (const f of authFiles) {
+        if (existsSync(join(dir, f))) {
+            return { detected: true, type: f.includes("nextauth") ? "next-auth" : "custom" };
+        }
+    }
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (allDeps["next-auth"] || allDeps["@auth/core"])
+                return { detected: true, type: "next-auth" };
+            if (allDeps["passport"])
+                return { detected: true, type: "passport" };
+            if (allDeps["@clerk/nextjs"] || allDeps["@clerk/clerk-sdk-node"])
+                return { detected: true, type: "clerk" };
+            if (allDeps["@supabase/supabase-js"])
+                return { detected: true, type: "supabase-auth" };
+            if (allDeps["firebase-admin"] || allDeps["firebase"])
+                return { detected: true, type: "firebase-auth" };
+            if (allDeps["jsonwebtoken"] || allDeps["jose"])
+                return { detected: true, type: "jwt" };
+        }
+        catch {
+            // skip
+        }
+    }
+    return null;
+}
+function detectCI(dir) {
+    return {
+        github_actions: existsSync(join(dir, ".github", "workflows")),
+        docker: existsSync(join(dir, "Dockerfile")) || existsSync(join(dir, "docker-compose.yml")),
+        fly: existsSync(join(dir, "fly.toml")),
+        vercel: existsSync(join(dir, "vercel.json")) || existsSync(join(dir, ".vercel")),
+    };
+}
+function detectTesting(dir) {
+    let framework = null;
+    let testCount = 0;
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (allDeps["vitest"])
+                framework = "vitest";
+            else if (allDeps["jest"])
+                framework = "jest";
+            else if (allDeps["mocha"])
+                framework = "mocha";
+            else if (allDeps["ava"])
+                framework = "ava";
+        }
+        catch {
+            // skip
+        }
+    }
+    if (existsSync(join(dir, "pytest.ini")) || existsSync(join(dir, "conftest.py"))) {
+        framework = "pytest";
+    }
+    try {
+        const result = execSync(`find . -not -path '*/node_modules/*' -not -path '*/dist/*' -not -path '*/.git/*' \\( -name '*.test.*' -o -name '*.spec.*' -o -name 'test_*' \\) | wc -l`, { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).trim();
+        testCount = parseInt(result, 10) || 0;
+    }
+    catch {
+        // skip
+    }
+    return { framework, testCount };
+}
+function detectEnvVars(dir) {
+    const vars = new Set();
+    const envFiles = [".env.example", ".env.template", ".env.sample", ".env.local.example"];
+    for (const f of envFiles) {
+        const p = join(dir, f);
+        if (existsSync(p)) {
+            const content = readFileSync(p, "utf-8");
+            const matches = content.matchAll(/^([A-Z][A-Z0-9_]+)=/gm);
+            for (const m of matches) {
+                vars.add(m[1]);
+            }
+        }
+    }
+    try {
+        const result = execSync(`grep -roh 'process\\.env\\.[A-Z][A-Z0-9_]*' src/ app/ lib/ 2>/dev/null | sort -u | head -30`, { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).trim();
+        for (const line of result.split("\n")) {
+            const match = line.match(/process\.env\.([A-Z][A-Z0-9_]+)/);
+            if (match)
+                vars.add(match[1]);
+        }
+    }
+    catch {
+        // skip
+    }
+    return Array.from(vars).sort();
+}
+function detectOpenApiSpec(dir) {
+    const candidates = [
+        "openapi.yaml", "openapi.yml", "openapi.json",
+        "swagger.yaml", "swagger.yml", "swagger.json",
+        "api.yaml", "api.yml", "api.json",
+        "docs/openapi.yaml", "docs/openapi.yml",
+    ];
+    for (const candidate of candidates) {
+        const p = join(dir, candidate);
+        if (existsSync(p)) {
+            const content = readFileSync(p, "utf-8");
+            return content.length > 5000 ? content.slice(0, 5000) + "\n...[truncated]" : content;
+        }
+    }
+    return null;
+}
+function collectGitHistory(dir) {
+    const result = { commits: 0, contributors: [], firstCommit: "", recentCommits: [] };
+    try {
+        result.commits = parseInt(execSync("git rev-list --count HEAD", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).trim(), 10) || 0;
+    }
+    catch {
+        return result;
+    }
+    try {
+        const contributors = execSync("git shortlog -sn --no-merges HEAD | head -10", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).trim();
+        result.contributors = contributors.split("\n").map(l => l.replace(/^\s*\d+\s+/, "").trim()).filter(Boolean);
+    }
+    catch {
+        // skip
+    }
+    try {
+        result.firstCommit = execSync("git log --reverse --format='%ai' | head -1", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).trim();
+    }
+    catch {
+        // skip
+    }
+    try {
+        const recent = execSync("git log --oneline -20", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).trim();
+        result.recentCommits = recent.split("\n").filter(Boolean);
+    }
+    catch {
+        // skip
+    }
+    return result;
+}
+function detectMonorepo(dir) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            if (pkg.workspaces)
+                return true;
+        }
+        catch {
+            // skip
+        }
+    }
+    if (existsSync(join(dir, "pnpm-workspace.yaml")))
+        return true;
+    if (existsSync(join(dir, "lerna.json")))
+        return true;
+    if (existsSync(join(dir, "turbo.json")))
+        return true;
+    if (existsSync(join(dir, "nx.json")))
+        return true;
+    return false;
+}
+function detectWorkspaces(dir) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            if (Array.isArray(pkg.workspaces))
+                return pkg.workspaces;
+            if (Array.isArray(pkg.workspaces?.packages))
+                return pkg.workspaces.packages;
+        }
+        catch {
+            // skip
+        }
+    }
+    if (existsSync(join(dir, "pnpm-workspace.yaml"))) {
+        try {
+            const content = readFileSync(join(dir, "pnpm-workspace.yaml"), "utf-8");
+            const matches = content.matchAll(/- ['"]?([^'"]+)['"]?/g);
+            return Array.from(matches).map(m => m[1]);
+        }
+        catch {
+            // skip
+        }
+    }
+    return [];
+}
+function readPackageDescription(dir) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            return pkg.description || null;
+        }
+        catch {
+            // skip
+        }
+    }
+    return null;
+}
+function readPackageScripts(dir) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            return pkg.scripts || {};
+        }
+        catch {
+            // skip
+        }
+    }
+    return {};
+}
+export function buildAnalysisPrompt(scan) {
+    const sections = [];
+    sections.push(`# Codebase Analysis Request
+
+Analyze this software project and produce a structured assessment. Be specific — cite file names, dependencies, and patterns you see.
+
+## Service Metadata (auto-detected)
+- Name: ${scan.metadata.name}
+- Type: ${scan.metadata.type}
+- Version: ${scan.metadata.version}
+- Port: ${scan.metadata.port || "unknown"}
+- Dependencies: ${scan.metadata.dependencies.join(", ") || "none detected"}
+`);
+    if (scan.packageDescription) {
+        sections.push(`## Package Description\n${scan.packageDescription}\n`);
+    }
+    if (scan.readme) {
+        sections.push(`## README\n\`\`\`\n${scan.readme}\n\`\`\`\n`);
+    }
+    sections.push(`## File Tree (${scan.fileTree.length} files)\n\`\`\`\n${scan.fileTree.join("\n")}\n\`\`\`\n`);
+    if (scan.entryPoints.length > 0) {
+        sections.push("## Entry Points\n");
+        for (const ep of scan.entryPoints) {
+            sections.push(`### ${ep.path}\n\`\`\`\n${ep.preview}\n\`\`\`\n`);
+        }
+    }
+    if (scan.apiRoutes.length > 0) {
+        sections.push(`## API Routes\n${scan.apiRoutes.map(r => `- ${r}`).join("\n")}\n`);
+    }
+    if (scan.database) {
+        sections.push(`## Database\n- Type: ${scan.database.type}`);
+        if (scan.database.schema) {
+            sections.push(`\n\`\`\`prisma\n${scan.database.schema}\n\`\`\``);
+        }
+        sections.push("");
+    }
+    if (scan.auth) {
+        sections.push(`## Authentication\n- Detected: ${scan.auth.detected}\n- Type: ${scan.auth.type || "unknown"}\n`);
+    }
+    sections.push(`## CI/CD
+- GitHub Actions: ${scan.ci.github_actions}
+- Docker: ${scan.ci.docker}
+- Fly.io: ${scan.ci.fly}
+- Vercel: ${scan.ci.vercel}
+`);
+    sections.push(`## Testing
+- Framework: ${scan.testing.framework || "none detected"}
+- Test files: ${scan.testing.testCount}
+`);
+    if (scan.envVars.length > 0) {
+        sections.push(`## Environment Variables\n${scan.envVars.map(v => `- ${v}`).join("\n")}\n`);
+    }
+    if (scan.gitHistory.commits > 0) {
+        sections.push(`## Git History
+- Commits: ${scan.gitHistory.commits}
+- Contributors: ${scan.gitHistory.contributors.join(", ") || "unknown"}
+- First commit: ${scan.gitHistory.firstCommit || "unknown"}
+- Recent commits:\n${scan.gitHistory.recentCommits.map(c => `  - ${c}`).join("\n")}
+`);
+    }
+    if (scan.monorepo) {
+        sections.push(`## Monorepo\n- Workspaces: ${scan.workspaces.join(", ")}\n`);
+    }
+    if (Object.keys(scan.scripts).length > 0) {
+        sections.push(`## Package Scripts\n${Object.entries(scan.scripts).map(([k, v]) => `- ${k}: ${v}`).join("\n")}\n`);
+    }
+    sections.push(`## Instructions
+
+Respond with ONLY a JSON object (no markdown fencing) matching this exact shape:
+
+{
+  "confident": {
+    "purpose": "2-3 sentence description of what this project does",
+    "architecture": "1-2 sentence description of how it's built",
+    "keyFeatures": ["feature 1", "feature 2", ...],
+    "techStack": ["tech 1", "tech 2", ...],
+    "deploymentTarget": "where it's deployed or null"
+  },
+  "uncertain": ["thing I couldn't determine 1", "thing 2", ...],
+  "questions": [
+    {
+      "id": "unique-id",
+      "question": "Question text shown to user",
+      "why": "Brief explanation of why this matters for GTM",
+      "type": "text",
+      "default": "Best guess pre-fill or empty string",
+      "category": "vision|audience|roadmap|brand|narrative|deployment|monetization"
+    }
+  ]
+}
+
+Generate 8-15 questions. Prioritize questions where you DON'T have a confident answer. For questions where you CAN infer an answer from the codebase, provide a "default" value. Categories must be one of: vision, audience, roadmap, brand, narrative, deployment, monetization.
+
+Focus questions on GTM (go-to-market) context: who is this for, what problem does it solve, how will they find it, what's the timeline, what's the competitive angle.`);
+    return sections.join("\n");
+}
+export function buildDocGenerationPrompt(scan, analysis, answers) {
+    const sections = [];
+    sections.push(`# Generate GTM Knowledge Documents
+
+Based on the codebase analysis and user's answers, generate the complete set of GTM knowledge documents.
+
+## What We Know (from codebase analysis)
+
+**Purpose:** ${analysis.confident.purpose}
+**Architecture:** ${analysis.confident.architecture}
+**Key Features:** ${analysis.confident.keyFeatures.join(", ")}
+**Tech Stack:** ${analysis.confident.techStack.join(", ")}
+**Deployment:** ${analysis.confident.deploymentTarget || "Unknown"}
+
+## User's Answers
+`);
+    for (const [id, answer] of Object.entries(answers)) {
+        sections.push(`- **${id}**: ${answer}`);
+    }
+    sections.push(`
+## Service Details
+- Name: ${scan.metadata.name}
+- Type: ${scan.metadata.type}
+- Database: ${scan.database?.type || "none"}
+- Auth: ${scan.auth?.type || "none"}
+- Test framework: ${scan.testing.framework || "none"}
+- Test files: ${scan.testing.testCount}
+- API routes: ${scan.apiRoutes.length}
+
+## Instructions
+
+Generate a JSON object (no markdown fencing) with these keys. Each value is the FULL markdown content for that file. Use real content from the analysis and answers — never leave placeholders like "{fill this in}".
+
+{
+  "VISION.md": "full markdown content...",
+  "NARRATIVE.md": "full markdown content...",
+  "THESIS.md": "full markdown content...",
+  "ROADMAP.md": "full markdown content...",
+  "BRAND_BRIEF.md": "full markdown content...",
+  "PRODUCT_SPEC.md": "full markdown content..."
+}
+
+### Document Guidelines
+
+**VISION.md** — Start with "# [Project Name]", include: the vision (2-3 paragraphs), who it's for, what problem it solves, the one-liner. Mark "Status: EMERGENT" unless the user was very definitive.
+
+**NARRATIVE.md** — The story: how you explain it at a party, the before/after, emotional hook, key messages. Include casual and formal pitch variants.
+
+**THESIS.md** — Why this will win: unfair advantages, timing, unique insight, competitive positioning.
+
+**ROADMAP.md** — Phases with dates if provided. Current state assessment based on what exists in the codebase. Next milestones. Include "Phase 0: Current State" showing what's already built.
+
+**BRAND_BRIEF.md** — Brand direction: vibe, personality, audience expectations. Can be minimal if user didn't provide much — that's fine, mark as "Needs refinement."
+
+**PRODUCT_SPEC.md** — Technical product spec: features table (with status based on what exists), tech stack, architecture description, API routes, database schema summary, environment variables, deployment setup. This should be dense and useful for an engineer picking up the project.`);
+    return sections.join("\n");
+}
+export async function synthesizeWithLLM(prompt) {
+    const Anthropic = (await import("@anthropic-ai/sdk")).default;
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        throw new Error("ANTHROPIC_API_KEY not set");
+    }
+    const anthropic = new Anthropic({ apiKey });
+    const message = await anthropic.messages.create({
+        model: "claude-sonnet-4-20250514",
+        max_tokens: 8192,
+        messages: [{ role: "user", content: prompt }],
+    });
+    const textBlock = message.content.find(b => b.type === "text");
+    return textBlock?.text || "";
+}
+export function getStaticFallbackQuestions() {
+    return [
+        {
+            id: "purpose",
+            question: "What does this project do? (2-3 sentences)",
+            why: "Core of your VISION.md — everything else builds on this",
+            type: "text",
+            default: "",
+            category: "vision",
+        },
+        {
+            id: "audience",
+            question: "Who is this for? (specific person, not 'everyone')",
+            why: "Defines your messaging, positioning, and where to find users",
+            type: "text",
+            default: "",
+            category: "audience",
+        },
+        {
+            id: "problem",
+            question: "What problem does it solve for them?",
+            why: "The pain point drives your narrative and content",
+            type: "text",
+            default: "",
+            category: "vision",
+        },
+        {
+            id: "one-liner",
+            question: "What's your rough one-liner?",
+            why: "Used everywhere: Twitter bio, landing page, pitch",
+            type: "text",
+            default: "",
+            category: "narrative",
+        },
+        {
+            id: "party-pitch",
+            question: "How would you explain this at a party?",
+            why: "Your casual pitch — tests if the concept is clear",
+            type: "text",
+            default: "",
+            category: "narrative",
+        },
+        {
+            id: "before-after",
+            question: "What's the before/after? (their life before vs after)",
+            why: "Drives emotional connection in content and marketing",
+            type: "text",
+            default: "",
+            category: "narrative",
+        },
+        {
+            id: "launch-date",
+            question: "When do you want to launch? (date or timeframe)",
+            why: "Sets the countdown — everything works backward from this",
+            type: "text",
+            default: "",
+            category: "roadmap",
+        },
+        {
+            id: "mvp",
+            question: "What's the first thing that needs to work? (MVP)",
+            why: "Scopes the roadmap and prevents over-building",
+            type: "text",
+            default: "",
+            category: "roadmap",
+        },
+        {
+            id: "why-you",
+            question: "Why will YOU win? (not just anyone — you specifically)",
+            why: "Your unfair advantage — core of the thesis",
+            type: "text",
+            default: "",
+            category: "monetization",
+        },
+        {
+            id: "why-now",
+            question: "Why now? What changed that makes this possible/needed?",
+            why: "Timing thesis — investors and users both care about this",
+            type: "text",
+            default: "",
+            category: "monetization",
+        },
+        {
+            id: "vibe",
+            question: "What's the vibe? (professional, playful, bold, minimal, techy, human)",
+            why: "Sets brand direction for all visual and written content",
+            type: "text",
+            default: "",
+            category: "brand",
+        },
+        {
+            id: "deploy-target",
+            question: "Where is this deployed (or where will it be)?",
+            why: "Informs product spec and deployment docs",
+            type: "text",
+            default: "",
+            category: "deployment",
+        },
+    ];
+}
+//# sourceMappingURL=service-analyzer.js.map