@sanity/runtime-cli 17.1.0 → 17.2.0-blueprinit.g62f8017

package/dist/baseCommands.d.ts

@@ -10,10 +10,11 @@ export declare const pathFlagConfig: {
     description: string;
     env: string;
     aliases: string[];
-    char: "p";
+    char: 'p';
 };
 export declare const baseFlags: {
     json: Interfaces.BooleanFlag<boolean>;
+    llms: Interfaces.BooleanFlag<boolean>;
     path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
     trace: Interfaces.BooleanFlag<boolean>;
     'validate-resources': Interfaces.BooleanFlag<boolean>;
@@ -42,6 +43,7 @@ export declare abstract class RuntimeCommand<T extends typeof Command> extends C
     protected args: Args<T>;
     static baseFlags: {
         json: Interfaces.BooleanFlag<boolean>;
+        llms: Interfaces.BooleanFlag<boolean>;
         path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
         trace: Interfaces.BooleanFlag<boolean>;
         'validate-resources': Interfaces.BooleanFlag<boolean>;
@@ -112,14 +114,15 @@ export type Need = 'token' | 'blueprint' | 'scope' | 'stackId' | 'deployedStack'
 export declare abstract class ResolvedCommand<T extends typeof Command> extends RuntimeCommand<T> {
     static needs: readonly Need[];
     static baseFlags: {
-        stack: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
-        'project-id': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
-        'organization-id': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
         json: Interfaces.BooleanFlag<boolean>;
+        llms: Interfaces.BooleanFlag<boolean>;
         path: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
         trace: Interfaces.BooleanFlag<boolean>;
         'validate-resources': Interfaces.BooleanFlag<boolean>;
         verbose: Interfaces.BooleanFlag<boolean>;
+        stack: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        'project-id': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        'organization-id': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
     };
     protected sanityToken: string;
     protected blueprint: ReadBlueprintResult;

package/dist/baseCommands.js

@@ -6,6 +6,7 @@ import { resolveIds } from './actions/blueprints/resolve.js';
 import { getStack, resolveStackIdByNameOrId } from './actions/blueprints/stacks.js';
 import config from './config.js';
 import { CI_SETUP_DOCS_URL } from './constants.js';
+import { commandSkillFilename, readCommandSkill } from './utils/command-skills.js';
 import { presentBlueprintParserErrors } from './utils/display/errors.js';
 import { Logger } from './utils/logger.js';
 import { styleText } from './utils/style-text.js';
@@ -30,6 +31,10 @@ export const baseFlags = {
         // override defaults from oclif's built-in --json flag
         description: 'Format output as json',
     }),
+    llms: OclifFlags.boolean({
+        description: 'Show agent-oriented guidance for this command',
+        aliases: ['skill'],
+    }),
     path: OclifFlags.string({
         ...pathFlagConfig,
         hidden: true,
@@ -118,6 +123,18 @@ export class RuntimeCommand extends Command {
         return commandHelp.generate();
     }
     async init() {
+        if (this.argv.some((arg) => arg === '--llms' || arg === '--skill')) {
+            const commandId = this.id ?? this.ctor.id;
+            const skill = await readCommandSkill(commandId);
+            if (!skill) {
+                const commandName = commandId.replaceAll(':', ' ');
+                this.error(`No agent guidance is available for \`${commandName}\`.`, {
+                    suggestions: [`Add it at skills/${commandSkillFilename(commandId)}.`],
+                });
+            }
+            process.stdout.write(skill.endsWith('\n') ? skill : `${skill}\n`);
+            this.exit();
+        }
         const { args, flags } = await this.parse({
             flags: this.ctor.flags,
             baseFlags: super.ctor.baseFlags,

package/dist/commands/blueprinit.d.ts

@@ -0,0 +1,13 @@
+import { RuntimeCommand } from '../baseCommands.js';
+export default class BlueprinitCommand extends RuntimeCommand<typeof BlueprinitCommand> {
+    static hidden: boolean;
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'organization-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'project-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<Record<string, unknown> | undefined>;
+}

package/dist/commands/blueprinit.js

@@ -0,0 +1,44 @@
+import { Flags } from '@oclif/core';
+import { RuntimeCommand } from '../baseCommands.js';
+import { blueprinitCore } from '../cores/blueprinit.js';
+import { Logger } from '../utils/logger.js';
+export default class BlueprinitCommand extends RuntimeCommand {
+    static hidden = true;
+    static summary = 'Experimental blueprints-first project init';
+    static description = `Scaffolds a Blueprint, Studio, and starter function around an existing Sanity project.
+
+This hidden command is an experiment; its interface and generated files are not stable.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --yes',
+    ];
+    static flags = {
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip confirmation prompts',
+            default: false,
+        }),
+        'organization-id': Flags.string({
+            description: 'Organization to use when the account has several',
+            aliases: ['organization', 'organizationId', 'org'],
+        }),
+        'project-id': Flags.string({
+            description: 'Project to use when the organization has several',
+            aliases: ['project', 'projectId'],
+        }),
+    };
+    async run() {
+        const result = await blueprinitCore({
+            bin: this.config.bin,
+            log: Logger(this.log.bind(this), this.flags),
+            flags: {
+                yes: this.flags.yes,
+                organizationId: this.flags['organization-id'],
+                projectId: this.flags['project-id'],
+            },
+        });
+        if (!result.success)
+            this.coreError(result);
+        return result.json;
+    }
+}

package/dist/commands/blueprints/add.d.ts

@@ -4,7 +4,7 @@
  */
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class AddCommand extends ResolvedCommand<typeof AddCommand> {
-    static needs: readonly ["blueprint"];
+    static needs: readonly ['blueprint'];
     static state: string;
     static deprecationOptions: {
         to: string;

package/dist/commands/blueprints/config.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class ConfigCommand extends ResolvedCommand<typeof ConfigCommand> {
-    static needs: readonly ["token", "blueprint"];
+    static needs: readonly ['token', 'blueprint'];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/blueprints/deploy.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class DeployCommand extends ResolvedCommand<typeof DeployCommand> {
-    static needs: readonly ["deployedStack", "blueprint"];
+    static needs: readonly ['deployedStack', 'blueprint'];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/blueprints/destroy.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class DestroyCommand extends ResolvedCommand<typeof DestroyCommand> {
-    static needs: readonly ["scope"];
+    static needs: readonly ['scope'];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/blueprints/doctor.d.ts

@@ -6,7 +6,6 @@ export default class DoctorCommand extends RuntimeCommand<typeof DoctorCommand>
     static flags: {
         path: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         fix: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<Record<string, unknown> | undefined>;
 }

package/dist/commands/blueprints/doctor.js

@@ -7,8 +7,9 @@ export default class DoctorCommand extends RuntimeCommand {
     static summary = 'Diagnose potential issues with local Blueprint and remote Stack configuration';
     static description = `Analyzes your local Blueprint and remote Stack configuration for common issues, such as missing authentication, invalid project references, or misconfigured resources.
 
-Run this command when encountering errors with other Blueprint commands. Use --fix to interactively resolve detected issues.`;
-    // TODO: add "Supports --json for programmatic consumption of diagnostic results." to help text
+Run this command when encountering errors with other Blueprint commands. Use --fix to interactively resolve detected issues.
+
+Supports --json for programmatic consumption of diagnostic results.`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --fix',
@@ -19,11 +20,6 @@ Run this command when encountering errors with other Blueprint commands. Use --f
             description: 'Interactively fix configuration issues',
             default: false,
         }),
-        verbose: Flags.boolean({
-            description: 'Verbose output; defaults to true',
-            default: true,
-            allowNo: true,
-        }),
     };
     async run() {
         const { token } = config;

package/dist/commands/blueprints/info.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class InfoCommand extends ResolvedCommand<typeof InfoCommand> {
-    static needs: readonly ["deployedStack"];
+    static needs: readonly ['deployedStack'];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/blueprints/logs.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class LogsCommand extends ResolvedCommand<typeof LogsCommand> {
-    static needs: readonly ["deployedStack"];
+    static needs: readonly ['deployedStack'];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/blueprints/mint-deploy-token.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class MintDeployTokenCommand extends ResolvedCommand<typeof MintDeployTokenCommand> {
-    static needs: readonly ["scope"];
+    static needs: readonly ['scope'];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/blueprints/plan.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class PlanCommand extends ResolvedCommand<typeof PlanCommand> {
-    static needs: readonly ["token", "blueprint"];
+    static needs: readonly ['token', 'blueprint'];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/blueprints/promote.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class PromoteCommand extends ResolvedCommand<typeof PromoteCommand> {
-    static needs: readonly ["deployedStack", "blueprint"];
+    static needs: readonly ['deployedStack', 'blueprint'];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/blueprints/stacks.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class StacksCommand extends ResolvedCommand<typeof StacksCommand> {
-    static needs: readonly ["scope"];
+    static needs: readonly ['scope'];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/functions/add.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class AddCommand extends ResolvedCommand<typeof AddCommand> {
-    static needs: readonly ["blueprint"];
+    static needs: readonly ['blueprint'];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/functions/build.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class BuildCommand extends ResolvedCommand<typeof BuildCommand> {
-    static needs: readonly ["blueprint"];
+    static needs: readonly ['blueprint'];
     static summary: string;
     static hidden: boolean;
     static args: {

package/dist/commands/functions/dev.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class DevCommand extends ResolvedCommand<typeof DevCommand> {
-    static needs: readonly ["blueprint"];
+    static needs: readonly ['blueprint'];
     static summary: string;
     static description: string;
     static examples: string[];

package/dist/commands/functions/env/add.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../../baseCommands.js';
 export default class EnvAddCommand extends ResolvedCommand<typeof EnvAddCommand> {
-    static needs: readonly ["deployedStack", "blueprint"];
+    static needs: readonly ['deployedStack', 'blueprint'];
     static summary: string;
     static description: string;
     static args: {
@@ -8,6 +8,9 @@ export default class EnvAddCommand extends ResolvedCommand<typeof EnvAddCommand>
         key: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
         value: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static flags: {
+        stack: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
     static examples: string[];
     run(): Promise<Record<string, unknown> | undefined>;
 }

package/dist/commands/functions/env/add.js

@@ -1,5 +1,5 @@
-import { Args } from '@oclif/core';
-import { ResolvedCommand } from '../../../baseCommands.js';
+import { Args, Flags } from '@oclif/core';
+import { ResolvedCommand, stackFlagConfig } from '../../../baseCommands.js';
 import { functionEnvAddCore } from '../../../cores/functions/env/add.js';
 import { Logger } from '../../../utils/logger.js';
 export default class EnvAddCommand extends ResolvedCommand {
@@ -13,8 +13,12 @@ Environment variables are useful for API keys, configuration values, and other s
         key: Args.string({ description: 'The name of the environment variable', required: true }),
         value: Args.string({ description: 'The value of the environment variable', required: true }),
     };
+    static flags = {
+        stack: Flags.string({ ...stackFlagConfig }),
+    };
     static examples = [
         '<%= config.bin %> <%= command.id %> MyFunction API_URL https://api.example.com/',
+        '<%= config.bin %> <%= command.id %> --stack <name-or-id> MyFunction API_URL https://api.example.com/',
     ];
     async run() {
         const result = await functionEnvAddCore({

package/dist/commands/functions/env/list.d.ts

@@ -1,11 +1,14 @@
 import { ResolvedCommand } from '../../../baseCommands.js';
 export default class EnvListCommand extends ResolvedCommand<typeof EnvListCommand> {
-    static needs: readonly ["deployedStack", "blueprint"];
+    static needs: readonly ['deployedStack', 'blueprint'];
     static summary: string;
     static description: string;
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static flags: {
+        stack: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
     static examples: string[];
     run(): Promise<Record<string, unknown> | undefined>;
 }

package/dist/commands/functions/env/list.js

@@ -1,5 +1,5 @@
-import { Args } from '@oclif/core';
-import { ResolvedCommand } from '../../../baseCommands.js';
+import { Args, Flags } from '@oclif/core';
+import { ResolvedCommand, stackFlagConfig } from '../../../baseCommands.js';
 import { functionEnvListCore } from '../../../cores/functions/env/list.js';
 import { Logger } from '../../../utils/logger.js';
 export default class EnvListCommand extends ResolvedCommand {
@@ -11,7 +11,13 @@ Use 'functions env add' to set variables or 'functions env remove' to delete the
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: true }),
     };
-    static examples = ['<%= config.bin %> <%= command.id %> MyFunction'];
+    static flags = {
+        stack: Flags.string({ ...stackFlagConfig }),
+    };
+    static examples = [
+        '<%= config.bin %> <%= command.id %> MyFunction',
+        '<%= config.bin %> <%= command.id %> --stack <name-or-id> MyFunction',
+    ];
     async run() {
         const result = await functionEnvListCore({
             bin: this.config.bin,

package/dist/commands/functions/env/remove.d.ts

@@ -1,12 +1,15 @@
 import { ResolvedCommand } from '../../../baseCommands.js';
 export default class EnvRemoveCommand extends ResolvedCommand<typeof EnvRemoveCommand> {
-    static needs: readonly ["deployedStack", "blueprint"];
+    static needs: readonly ['deployedStack', 'blueprint'];
     static summary: string;
     static description: string;
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
         key: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static flags: {
+        stack: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
     static examples: string[];
     run(): Promise<Record<string, unknown> | undefined>;
 }

package/dist/commands/functions/env/remove.js

@@ -1,5 +1,5 @@
-import { Args } from '@oclif/core';
-import { ResolvedCommand } from '../../../baseCommands.js';
+import { Args, Flags } from '@oclif/core';
+import { ResolvedCommand, stackFlagConfig } from '../../../baseCommands.js';
 import { functionEnvRemoveCore } from '../../../cores/functions/env/remove.js';
 import { Logger } from '../../../utils/logger.js';
 export default class EnvRemoveCommand extends ResolvedCommand {
@@ -12,7 +12,13 @@ Use 'functions env list' to see current variables before removing.`;
         name: Args.string({ description: 'The name of the Sanity Function', required: true }),
         key: Args.string({ description: 'The name of the environment variable', required: true }),
     };
-    static examples = ['<%= config.bin %> <%= command.id %> MyFunction API_URL'];
+    static flags = {
+        stack: Flags.string({ ...stackFlagConfig }),
+    };
+    static examples = [
+        '<%= config.bin %> <%= command.id %> MyFunction API_URL',
+        '<%= config.bin %> <%= command.id %> --stack <name-or-id> MyFunction API_URL',
+    ];
     async run() {
         const result = await functionEnvRemoveCore({
             bin: this.config.bin,

package/dist/commands/functions/logs.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class LogsCommand extends ResolvedCommand<typeof LogsCommand> {
-    static needs: readonly ["deployedStack", "blueprint"];
+    static needs: readonly ['deployedStack', 'blueprint'];
     static summary: string;
     static description: string;
     static args: {

package/dist/commands/functions/test.d.ts

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class TestCommand extends ResolvedCommand<typeof TestCommand> {
-    static needs: readonly ["blueprint"];
+    static needs: readonly ['blueprint'];
     static summary: string;
     static description: string;
     static args: {

package/dist/constants.d.ts

@@ -9,6 +9,7 @@ export declare const SANITY_PROJECT = "sanity.project";
 export declare const SANITY_PROJECT_CORS = "sanity.project.cors";
 export declare const SANITY_PROJECT_DATASET = "sanity.project.dataset";
 export declare const SANITY_PROJECT_WEBHOOK = "sanity.project.webhook";
+export declare const SANITY_STUDIO = "sanity.studio";
 export declare const EVENT_DOCUMENT_PUBLISH = "document-publish";
 export declare const EVENT_DOCUMENT_CREATE = "document-create";
 export declare const EVENT_DOCUMENT_UPDATE = "document-update";

package/dist/constants.js

@@ -9,6 +9,7 @@ export const SANITY_PROJECT = 'sanity.project';
 export const SANITY_PROJECT_CORS = 'sanity.project.cors';
 export const SANITY_PROJECT_DATASET = 'sanity.project.dataset';
 export const SANITY_PROJECT_WEBHOOK = 'sanity.project.webhook';
+export const SANITY_STUDIO = 'sanity.studio';
 export const EVENT_DOCUMENT_PUBLISH = 'document-publish';
 export const EVENT_DOCUMENT_CREATE = 'document-create';
 export const EVENT_DOCUMENT_UPDATE = 'document-update';

package/dist/cores/blueprinit/adopt.d.ts

@@ -0,0 +1,6 @@
+import type { DetectedStudio } from '../../actions/blueprinit/studio.js';
+import type { CoreResult } from '../index.js';
+import type { BlueprinitFlowOptions } from './types.js';
+export declare function adoptFlow(options: BlueprinitFlowOptions & {
+    studio: DetectedStudio;
+}): Promise<CoreResult>;

package/dist/cores/blueprinit/adopt.js

@@ -0,0 +1,90 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { slugify } from '../../actions/blueprinit/manifest.js';
+import { adoptWorkspace } from '../../actions/blueprinit/workspace.js';
+import { listDatasets } from '../../actions/sanity/datasets.js';
+import { groupProjectsByOrganization } from '../../actions/sanity/projects.js';
+import { check } from '../../utils/display/presenters.js';
+import { getLatestNpmVersion } from '../../utils/external/npmjs.js';
+import { isInteractive } from '../../utils/interactive.js';
+import { createStackAndFinish } from './finish.js';
+import { confirmUnlessSkipped, promptForStudioName } from './prompts.js';
+import { findProject } from './selection.js';
+export async function adoptFlow(options) {
+    const { bin, dir, flags, log, studio, token } = options;
+    if (!studio.projectId || !studio.dataset) {
+        return {
+            success: false,
+            error: `Found ${studio.configFile}, but could not read a projectId and dataset from it.`,
+            suggestions: ['Use literal projectId and dataset values in the Studio config.'],
+        };
+    }
+    if (flags.projectId && flags.projectId !== studio.projectId) {
+        return { success: false, error: `The Studio uses project "${studio.projectId}".` };
+    }
+    log(check(`Studio detected (${studio.configFile})`));
+    const grouped = await groupProjectsByOrganization({ token, logger: log });
+    if (!grouped.ok) {
+        return { success: false, error: `Could not list organizations: ${grouped.error}` };
+    }
+    const match = findProject(grouped.organizations, studio.projectId);
+    if (!match) {
+        return {
+            success: false,
+            error: `Project "${studio.projectId}" from ${studio.configFile} was not found in your account.`,
+        };
+    }
+    if (flags.organizationId && flags.organizationId !== match.organization.id) {
+        return {
+            success: false,
+            error: `Project "${studio.projectId}" belongs to organization "${match.organization.id}".`,
+        };
+    }
+    const datasets = await listDatasets({ token, projectId: match.project.id, logger: log });
+    if (!datasets.ok) {
+        return { success: false, error: `Could not list datasets: ${datasets.error}` };
+    }
+    if (!datasets.datasets.some(({ name }) => name === studio.dataset)) {
+        return {
+            success: false,
+            error: `Dataset "${studio.dataset}" was not found in project ${match.project.displayName}.`,
+        };
+    }
+    log(check(`Matches project ${match.project.displayName} (${match.project.id}), dataset ${studio.dataset}`));
+    log('');
+    const confirmed = await confirmUnlessSkipped(flags, isInteractive, 'Adopt this Studio into a Blueprint?');
+    if (!confirmed)
+        return { success: false, error: 'Initialization cancelled.' };
+    const studioName = await promptForStudioName(flags, isInteractive);
+    const stackName = slugify(match.project.displayName) || match.project.id;
+    const marker = (file) => (existsSync(join(dir, file)) ? '~' : '+');
+    log('Changes:');
+    log("  + sanity.blueprint.ts             attach project + dataset; adopt Studio at '.'");
+    log(`  + .sanity/blueprint.config.json   org scope, stack ${stackName}`);
+    log(`  ${marker('.gitignore')} .gitignore`);
+    log(`  ${marker('package.json')} package.json`);
+    log('');
+    const adoption = adoptWorkspace({
+        dir,
+        projectId: match.project.id,
+        displayName: match.project.displayName,
+        datasetName: studio.dataset,
+        stackName,
+        studioName,
+        blueprintsVersion: await getLatestNpmVersion('@sanity/blueprints', log),
+    });
+    return await createStackAndFinish({
+        ...options,
+        organizationId: match.organization.id,
+        projectId: match.project.id,
+        datasetName: studio.dataset,
+        stackName,
+        blueprintFilePath: adoption.blueprintFilePath,
+        files: adoption.files,
+        nextSteps: [
+            `  npx ${bin} blueprints plan`,
+            `  npx ${bin} blueprints deploy`,
+            `  npx ${bin} blueprints info`,
+        ],
+    });
+}

package/dist/cores/blueprinit/finish.d.ts

@@ -0,0 +1,14 @@
+import type { CoreResult } from '../index.js';
+import type { BlueprinitFlowOptions } from './types.js';
+interface FinishOptions extends BlueprinitFlowOptions {
+    organizationId: string;
+    projectId: string;
+    datasetName: string;
+    stackName: string;
+    blueprintFilePath: string;
+    files: string[];
+    nextSteps: string[];
+}
+export declare function createStackAndFinish(options: FinishOptions): Promise<CoreResult>;
+export declare function alignSteps(steps: Array<[command: string, description?: string]>): string[];
+export {};

package/dist/cores/blueprinit/finish.js

@@ -0,0 +1,36 @@
+import { writeConfigFile } from '../../actions/blueprints/config.js';
+import { createEmptyStack } from '../../actions/blueprints/stacks.js';
+import { check } from '../../utils/display/presenters.js';
+export async function createStackAndFinish(options) {
+    const stack = await createEmptyStack({
+        token: options.token,
+        scopeType: 'organization',
+        scopeId: options.organizationId,
+        name: options.stackName,
+        logger: options.log,
+    });
+    writeConfigFile(options.blueprintFilePath, {
+        organizationId: options.organizationId,
+        stackId: stack.id,
+    });
+    options.log(check(`Stack ${stack.name} created (org scope)`));
+    options.log('');
+    options.log('Next steps:');
+    for (const step of options.nextSteps)
+        options.log(step);
+    return {
+        success: true,
+        json: {
+            organizationId: options.organizationId,
+            projectId: options.projectId,
+            dataset: options.datasetName,
+            stackId: stack.id,
+            stackName: stack.name,
+            files: [...options.files, '.sanity/blueprint.config.json'],
+        },
+    };
+}
+export function alignSteps(steps) {
+    const width = Math.max(...steps.map(([command]) => command.length));
+    return steps.map(([command, description]) => description ? `  ${command.padEnd(width + 2)}${description}` : `  ${command}`);
+}

package/dist/cores/blueprinit/fresh.d.ts

@@ -0,0 +1,3 @@
+import type { CoreResult } from '../index.js';
+import type { BlueprinitFlowOptions } from './types.js';
+export declare function freshFlow(options: BlueprinitFlowOptions): Promise<CoreResult>;