startup-builder 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,122 +1,678 @@
-import * as landing_page from 'landing-page';
-export { landing } from 'landing-page';
-import * as startup_names from 'startup-names';
-export { startup as names } from 'startup-names';
-import * as storybrand from 'storybrand';
-export { story } from 'storybrand';
-import * as jobs_to_be_done from 'jobs-to-be-done';
-export { jtbd } from 'jobs-to-be-done';
-import * as ideal_customer_profile from 'ideal-customer-profile';
-export { icp } from 'ideal-customer-profile';
-import * as lean_canvas from 'lean-canvas';
-export { canvas } from 'lean-canvas';
-import * as foundation_sprint from 'foundation-sprint';
-export { sprint } from 'foundation-sprint';
-
-/**
- * Complete startup package returned by builder.create()
- */
-interface StartupPackage {
-    foundation: any;
-    canvas: any;
-    icp: any;
-    jtbd: any;
-    story: any;
-    name: any;
-    landing: any;
-}
-/**
- * Founder information used to personalize the startup
- */
-interface FounderInfo {
-    capabilities?: string[];
-    insight?: string;
-    motivation?: string;
-    founderNames?: string[];
-}
-/**
- * Options for creating a startup
- */
-interface CreateOptions {
-    idea: string;
-    founder?: FounderInfo;
-    industry?: string;
-    tone?: 'professional' | 'playful' | 'modern' | 'traditional';
-}
-/**
- * Options for deploying a startup
- */
-interface DeployOptions {
-    domain?: string;
-}
-/**
- * Deploy result
- */
-interface DeployResult {
-    landing: string;
-    dashboard?: string;
-}
-/**
- * Main builder API
- */
-declare const builder: {
-    /**
-     * Create complete startup foundation from idea
-     *
-     * @example
-     * ```typescript
-     * const startup = await builder.create({
-     *   idea: 'AI code review for engineering teams',
-     *   founder: {
-     *     capabilities: ['ML expertise', 'DevTools experience'],
-     *     insight: 'Code review is the biggest bottleneck',
-     *     motivation: 'Hated waiting for reviews'
-     *   }
-     * })
-     * ```
-     */
-    create(options: CreateOptions): Promise<StartupPackage>;
-    /**
-     * Run foundation sprint
-     */
-    foundation(idea: string, founder?: FounderInfo): Promise<foundation_sprint.Foundation>;
-    /**
-     * Generate lean canvas
-     */
-    canvas(input: string | any): Promise<lean_canvas.LeanCanvas>;
-    /**
-     * Generate ideal customer profile
-     */
-    icp(input: string | any): Promise<ideal_customer_profile.GenerateResult>;
-    /**
-     * Generate jobs to be done
-     */
-    jtbd(input: string | any): Promise<jobs_to_be_done.DiscoverResult>;
-    /**
-     * Generate story brand messaging
-     */
-    story(input: string | any, customerProfile?: any): Promise<storybrand.StoryBrandScript>;
-    /**
-     * Generate startup name
-     */
-    name(input: string | any, options?: any): Promise<startup_names.GenerateResult>;
-    /**
-     * Generate landing page
-     */
-    landing(name: any, brandStory?: any): Promise<landing_page.LandingPageOutput>;
-    /**
-     * Deploy startup to web
-     */
-    deploy(startup: StartupPackage, options?: DeployOptions): Promise<DeployResult>;
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+
+interface Res<T = any> {
+    status: number;
+    ok: boolean;
+    url: string;
+    json: T;
+    text: string;
+    headers: Record<string, string>;
+}
+interface ApiOpts {
+    base: string;
+    token?: string;
+    bind?: string;
+    fetch?: typeof fetch;
+    userAgent?: string;
+}
+declare class Api {
+    readonly base: string;
+    readonly token?: string;
+    readonly origin: string;
+    readonly reads: string[];
+    private f;
+    private ua;
+    constructor(o: ApiOpts);
+    url(pathOrUrl: string): string;
+    sameOrigin(url: string): boolean;
+    private headers;
+    get<T = any>(pathOrUrl: string, accept?: string): Promise<Res<T>>;
+    post<T = any>(pathOrUrl: string, body: unknown, o?: {
+        idempotencyKey?: string;
+        prefer?: string;
+    }): Promise<Res<T> & {
+        idempotencyKey: string;
+    }>;
+}
+
+interface Stored {
+    issuer: string;
+    client_id: string;
+    access_token: string;
+    refresh_token?: string;
+    expires_at?: number;
+    api: string;
+}
+interface AuthDeps {
+    api: string;
+    file: string;
+    issuer?: string;
+    fetch?: typeof fetch;
+    openBrowser?: (url: string) => boolean;
+    log?: (line: string) => void;
+    now?: () => number;
+    ports?: number[];
+    timeoutMs?: number;
+    clientId?: string;
+}
+type J$5 = Record<string, any>;
+declare function pkce(verifier?: string): {
+    verifier: string;
+    challenge: string;
+};
+declare function unwrapState(s: string | null): string | null;
+declare class Auth {
+    readonly api: string;
+    readonly file: string;
+    readonly issuer: string;
+    private f;
+    private open;
+    private log;
+    private now;
+    private ports;
+    private timeoutMs;
+    private fixedClient?;
+    constructor(d: AuthDeps);
+    stored(): Promise<Stored | undefined>;
+    private save;
+    clientId(): Promise<string>;
+    private token;
+    loopback(client: string): Promise<J$5 | undefined>;
+    device(client: string): Promise<J$5>;
+    current(): Promise<Stored | undefined>;
+    login(opts?: {
+        device?: boolean;
+        force?: boolean;
+    }): Promise<{
+        stored: Stored;
+        fresh: boolean;
+    }>;
+    logout(): Promise<void>;
+}
+
+declare const DEFAULT_API = "https://api.sb";
+type Env$1 = Record<string, string | undefined>;
+declare function apiBase(flag?: string, env?: Env$1): string;
+declare function tokenFile(env?: Env$1): string;
+
+type J$4 = Record<string, any>;
+interface ClosesOn {
+    event: string;
+    verb: string;
+    url: string;
+    target?: string;
+    via: 'api.sb' | 'preview' | 'derived';
+    permission?: {
+        needs: string;
+        held: boolean;
+        heldBy: Record<string, string>;
+        assignee?: string;
+        why?: string;
+    };
+    approvalNeeded?: boolean;
+    refused?: string;
+    blocked?: string;
+    says?: string;
+}
+interface Task {
+    $id: string;
+    type: string;
+    name: string;
+    status: string;
+    reason?: string;
+    startup: string;
+    worker: string;
+    role?: string;
+    verb?: string;
+    object?: string;
+    about?: string;
+    conversation?: string;
+    due?: string;
+    overdue?: number;
+    age?: number;
+    since?: string;
+    priority: number;
+    priorityText?: string;
+    priorityWhy: string[];
+    step: string;
+    stepTitle?: string;
+    closesOn?: ClosesOn;
+}
+interface RoleDesk {
+    name: string;
+    $id: string;
+    owns?: string;
+    summary: string[];
+    permissions: string[];
+    mandates?: string[];
+    limits: {
+        name: string;
+        limit?: number;
+        used?: number;
+        text?: string;
+    }[];
+    tools: string[];
+}
+interface StartupDesk {
+    domain: string;
+    $id: string;
+    real?: string;
+    worker?: {
+        name: string;
+        kind?: string;
+        model?: string;
+        $id: string;
+        skills: string[];
+    };
+    roles: RoleDesk[];
+    open: number;
+    glossary?: string;
+    glossaryUrl: string;
+}
+interface Cluster {
+    worker: string;
+    startup: string;
+    step: string;
+    stepTitle?: string;
+    tasks: Task[];
+}
+interface Worklist {
+    source: 'api.sb' | 'stub';
+    worker: {
+        handle: string;
+        name: string;
+        kind?: string;
+        model?: string;
+        $id?: string;
+    };
+    startups: StartupDesk[];
+    open: number;
+    limit: number;
+    limitMax?: number;
+    limitAsked?: number;
+    page?: number;
+    pages?: number;
+    more?: number;
+    moreText?: string;
+    next?: string;
+    links?: {
+        next?: string;
+        prev?: string;
+        first?: string;
+        last?: string;
+        self?: string;
+    };
+    batch: Cluster[];
+    tasks: Task[];
+    planned?: J$4[];
+    gaps: string[];
+    sources: string[];
+    priorityBands?: Record<string, string>;
+    rules?: string[];
+    asOf?: string;
+    datesRelativeTo?: 'asOf';
+    clock?: string;
+    generatedAt: string;
+}
+declare class WorklistError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+interface WorklistOpts {
+    worker: string;
+    startups: string[];
+    limit?: number;
+    page?: number;
+    all?: boolean;
+    today?: string;
+    previews?: boolean;
+    stubOnly?: boolean;
+}
+declare function worklistPath(worker: string, startups: string[], limit: number, md?: boolean, page?: number): string;
+declare const heldByNames: (h: Record<string, string> | string[] | undefined) => string[];
+declare function fetchWorklistMarkdown(api: Api, o: {
+    worker: string;
+    startups: string[];
+    limit?: number;
+    page?: number;
+}): Promise<string>;
+declare function parseWorker(arg?: string): string | undefined;
+declare function derivePriority(t: J$4, today: string): {
+    priority: number;
+    why: string[];
 };
-/**
- * Build complete startup from idea (convenience function)
- *
- * @example
- * ```typescript
- * const startup = await buildStartup('AI code review for teams')
- * ```
- */
-declare function buildStartup(idea: string, founder?: FounderInfo): Promise<StartupPackage>;
-
-export { type CreateOptions, type DeployOptions, type DeployResult, type FounderInfo, type StartupPackage, buildStartup, builder };
+declare function stepOf(t: J$4, domain: string): string;
+declare function selectBatch(tasks: Task[], limit: number): Cluster[];
+interface StartupGroup {
+    startup: string;
+    steps: {
+        step: string;
+        stepTitle?: string;
+        tasks: Task[];
+    }[];
+}
+declare function groupBatch(batch: Cluster[]): StartupGroup[];
+declare function buildWorklist(api: Api, o: WorklistOpts): Promise<Worklist>;
+
+type J$3 = Record<string, any>;
+type Mode = 'try' | 'send' | 'do';
+interface CloseOpts {
+    task: string;
+    mode?: Mode;
+    as?: string;
+    input?: J$3;
+    idempotencyKey?: string;
+    force?: boolean;
+    prepare?: (c: ClosesOn) => {
+        input?: J$3;
+        error?: string;
+    };
+}
+type Outcome = 'Done' | 'Pending' | 'Refused' | 'Replayed' | 'KeyReused' | 'Blocked' | 'NotSent' | 'Error';
+interface CloseResult {
+    task: {
+        $id: string;
+        name: string;
+        type: string;
+        status?: string;
+        startup: string;
+        worker: string;
+        priorityText?: string;
+        stepTitle?: string;
+    };
+    closesOn: ClosesOn;
+    mode: Mode;
+    as: string;
+    request: {
+        method: 'POST';
+        url: string;
+        prefer: string;
+        idempotencyKey: string;
+    };
+    status: number;
+    outcome: Outcome;
+    action?: J$3;
+    replayed: boolean;
+    tried: boolean;
+    sink?: string;
+    blocked?: {
+        code?: string;
+        message?: string;
+    };
+    note?: string;
+    body: unknown;
+}
+interface ClosingTask {
+    $id: string;
+    name: string;
+    type: string;
+    status?: string;
+    startup: string;
+    worker: string;
+    priorityText?: string;
+    stepTitle?: string;
+    closesOn: ClosesOn;
+}
+declare function findClosesOn(api: Api, taskRef: string): Promise<{
+    task: ClosingTask;
+    thing: J$3;
+    worklist?: Worklist;
+}>;
+declare function closeTask(api: Api, o: CloseOpts): Promise<CloseResult>;
+declare const closesOf: (a: J$3 | undefined) => string[];
+
+declare function batchText(w: Worklist, o?: {
+    bin?: string;
+}): string;
+declare function closeText(r: CloseResult): string;
+
+declare function renderPrompt(w: Worklist, o?: {
+    bin?: string;
+}): string;
+
+interface CloudSession {
+    startup: string;
+    via: 'api.sb' | 'claude-runner' | 'none';
+    url?: string;
+    status?: number;
+    session?: string;
+    request: {
+        url: string;
+        body: Record<string, unknown>;
+    };
+    note?: string;
+}
+declare function runCloud(api: Api, w: Worklist, o: {
+    runner: string;
+    runnerToken?: string;
+    dryRun?: boolean;
+    bin?: string;
+    model?: string;
+    fetch?: typeof fetch;
+}): Promise<CloudSession[]>;
+
+type J$2 = Record<string, any>;
+declare function collectionOf(noun: string): string;
+declare function verbPath(spec: string, target: string | undefined, startup: string | undefined): string;
+interface VerbPreview {
+    url: string;
+    status: number;
+    name?: string;
+    does?: string;
+    event?: string;
+    mode?: string;
+    state?: string;
+    refused?: string;
+    permission?: {
+        needs: string;
+        heldBy: string[];
+    };
+    approvalNeeded?: boolean;
+    inputs: string[];
+    error?: string;
+}
+interface DoResult {
+    preview: VerbPreview;
+    invoked: boolean;
+    post?: {
+        status: number;
+        idempotencyKey: string;
+        body: unknown;
+        action?: string;
+        actionStatus?: string;
+        says?: string;
+        note?: string;
+    };
+}
+declare function doVerb(api: Api, o: {
+    spec: string;
+    target?: string;
+    startup?: string;
+    input?: J$2;
+    mode?: string;
+    as?: string;
+    previewOnly?: boolean;
+    force?: boolean;
+    idempotencyKey?: string;
+}): Promise<DoResult>;
+
+type Env = Record<string, string | undefined>;
+interface Lease {
+    batch: string;
+    worker: string;
+    startup: string;
+    step: string;
+    priority?: number;
+    tasks: string[];
+    prompt: string;
+    until: string;
+    token: string;
+    session: string;
+    claimedAt: string;
+    leaseSeconds: number;
+    api: string;
+    closed: string[];
+    held?: 'dispatcher';
+}
+declare function leasesDir(env?: Env): string;
+declare class Leases {
+    readonly dir: string;
+    private now;
+    private env;
+    private memory?;
+    constructor(dir: string, now?: () => number, env?: Env);
+    private ensure;
+    private write;
+    file(batch: string): string;
+    save(l: Lease): Lease;
+    adopt(l: Lease): Lease;
+    get pin(): string | undefined;
+    needsAdoption(): boolean;
+    all(): Lease[];
+    live(l: Lease): boolean;
+    get(ref: string): Lease | undefined;
+    current(): Lease | undefined;
+    holding(task: string): Lease | undefined;
+    update(batch: string, patch: (l: Lease) => void): Lease | undefined;
+    markClosed(batch: string, task: string): Lease | undefined;
+    remove(batch: string): void;
+    remember(kind: 'queue' | 'worklist', ids: string[]): void;
+    recall(kind: 'queue' | 'worklist'): string[];
+}
+
+type J$1 = Record<string, any>;
+interface Out<T = unknown> {
+    text: string;
+    data: T;
+    exit: number;
+}
+interface Batch {
+    $id: string;
+    worker: string;
+    startup: string;
+    startups?: string[];
+    step: string;
+    stepTitle?: string;
+    priority: number;
+    tasks: string[];
+    prompt: string;
+    claim: string;
+    [k: string]: unknown;
+}
+interface Cred {
+    token: string;
+    api: string;
+}
+interface SessionDeps {
+    base: string;
+    leases: Leases;
+    token: () => Promise<string | Cred | undefined>;
+    login?: () => Promise<string | Cred | undefined>;
+    fetch?: typeof fetch;
+    userAgent?: string;
+    now?: () => number;
+    session?: string;
+    leaseSeconds?: number;
+    env?: Record<string, string | undefined>;
+}
+declare class Session {
+    readonly base: string;
+    readonly leases: Leases;
+    private d;
+    constructor(d: SessionDeps);
+    api(c?: string | Cred): Api;
+    private cred;
+    private leaseCred;
+    private now;
+    private get env();
+    private adopting?;
+    ensureLease(): Promise<Out<null> | undefined>;
+    private adopt;
+    private ended;
+    short(u: string | undefined): string;
+    when(iso: string | undefined): string;
+    private baseToken;
+    private fail;
+    private none;
+    resolve(ref: string, o?: {
+        kind?: 'task' | 'batch';
+    }): string;
+    private label;
+    private readToken;
+    batchLine(b: Batch, i: number, withWorker: boolean): string;
+    listQueue(o?: {
+        worker?: string;
+        limit?: number;
+    }): Promise<{
+        r: Res;
+        batches: Batch[];
+    }>;
+    queue(o?: {
+        worker?: string;
+        limit?: number;
+    }): Promise<Out<{
+        batches: Batch[];
+    }>>;
+    private batchOf;
+    private claimOne;
+    claim(o?: {
+        ref?: string;
+        worker?: string;
+        leaseSeconds?: number;
+        skip?: Set<string>;
+    }): Promise<Out<{
+        lease?: Omit<Lease, 'token'>;
+        taken: string[];
+    }>>;
+    private leaseOf;
+    private leasePost;
+    renew(o?: {
+        batch?: string | Lease;
+        leaseSeconds?: number;
+        notAfter?: number;
+    }): Promise<Out<{
+        until?: string;
+        lost?: boolean;
+        dispatcher?: boolean;
+        capped?: boolean;
+    }>>;
+    release(o?: {
+        batch?: string | Lease;
+    }): Promise<Out<{
+        closed: number;
+        returned: number;
+        already?: boolean;
+        dispatcher?: boolean;
+    }>>;
+    batchPrompt(l: Lease): Promise<Out<{
+        url: string;
+    }>>;
+    prompt(o?: {
+        name?: string;
+        set?: string;
+    }): Promise<Out<J$1>>;
+    private isLeaseToken;
+    promptSet(o: {
+        name: string;
+        text: string;
+        idempotencyKey?: string;
+    }): Promise<Out<J$1>>;
+    show(o: {
+        ref: string;
+        md?: boolean;
+    }): Promise<Out<J$1>>;
+    thingText(t: J$1): string;
+    value(v: unknown, max?: number): string;
+    diffText(a: J$1 | undefined): string;
+    closeLine(label: string, r: CloseResult, left?: number): string;
+    close(o: {
+        ref: string;
+        body?: unknown;
+        mode?: Mode;
+        as?: string;
+        force?: boolean;
+        idempotencyKey?: string;
+    }): Promise<Out<CloseResult | null>>;
+    closedOf(l: Lease): Promise<string[]>;
+    worklistText(w: Worklist): string;
+    taskLine(t: Task, n: number): string;
+    worklist(o: {
+        worker: string;
+        startups?: string[];
+        limit?: number;
+        page?: number;
+    }): Promise<Out<Worklist>>;
+    versions(o: {
+        ref: string;
+        limit?: number;
+    }): Promise<Out<J$1>>;
+    revert(o: {
+        ref: string;
+        to: string;
+        mode?: Mode;
+        idempotencyKey?: string;
+    }): Promise<Out<J$1>>;
+    changes(o?: {
+        worker?: string;
+        startup?: string;
+        limit?: number;
+    }): Promise<Out<J$1>>;
+}
+
+type J = Record<string, any>;
+declare const VERDICTS: readonly ["confirmed", "corrected", "unsure"];
+declare function checkBody(event: string, body: unknown): {
+    body?: J;
+    errors: string[];
+};
+
+interface AgentRun {
+    prompt: string;
+    env: Record<string, string>;
+    cwd: string;
+    batch: string;
+    log: {
+        out: (chunk: string) => void;
+        err: (chunk: string) => void;
+    };
+    signal: AbortSignal;
+    done: () => Promise<boolean>;
+}
+interface AgentResult {
+    exitCode: number | null;
+    note?: string;
+}
+type AgentRunner = (r: AgentRun) => Promise<AgentResult>;
+interface WorkOpts {
+    agent: AgentRunner;
+    agentName: string;
+    worker?: string;
+    maxBatches?: number;
+    wait?: boolean;
+    pollMs?: number;
+    renewMs?: number;
+    watchMs?: number;
+    logDir: string;
+    line: (s: string) => void;
+    signal: AbortSignal;
+    env?: Record<string, string | undefined>;
+    selfCli?: string;
+    tmpRoot?: string;
+    now?: () => number;
+    wallMinutes?: number;
+}
+interface WorkSummary {
+    batches: number;
+    tasks: number;
+    closed: number;
+    errors: number;
+    ms: number;
+    stopped: 'empty' | 'max' | 'signal' | 'error';
+}
+declare function agentEnv(base: Record<string, string | undefined>, lease: Lease, api: string, binDir?: string, configHome?: string, workdir?: string): Record<string, string>;
+declare function agentPrompt(md: string, n: number): string;
+declare function work(s: Session, o: WorkOpts): Promise<WorkSummary>;
+
+declare function printRunner(o?: {
+    out?: (s: string) => void;
+    pollMs?: number;
+}): AgentRunner;
+
+type A = Record<string, any>;
+interface ToolDef {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+    run: (s: Session, a: A) => Promise<Out>;
+}
+declare const TOOLS: ToolDef[];
+declare function mcpServer(session: Session, version: string, o?: {
+    owner?: boolean;
+}): Server;
+
+export { type AgentRun, type AgentRunner, Api, Auth, type Batch, type CloseResult, type ClosesOn, type ClosingTask, type Cluster, DEFAULT_API, type Lease, Leases, type Mode, type Out, type Res, Session, type SessionDeps, type Stored, TOOLS, type Task, VERDICTS, type WorkOpts, type WorkSummary, type Worklist, WorklistError, agentEnv, agentPrompt, apiBase, batchText, buildWorklist, checkBody, closeTask, closeText, closesOf, collectionOf, derivePriority, doVerb, fetchWorklistMarkdown, findClosesOn, groupBatch, heldByNames, leasesDir, mcpServer, parseWorker, pkce, printRunner, renderPrompt, runCloud, selectBatch, stepOf, tokenFile, unwrapState, verbPath, work, worklistPath };