@unbrained/pm-cli 2026.6.30 → 2026.7.2

package/dist/cli/commands/init.js

@@ -4,7 +4,7 @@
  * Implements the pm init command surface and its agent-facing runtime behavior.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="cfc0ecc2-1b5c-5332-8da2-deedda554690")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a0acfeba-010e-51e0-bc49-90e4854fe975")}catch(e){}}();
 import fs from "node:fs/promises";
 import path from "node:path";
 import readline from "node:readline/promises";
@@ -254,6 +254,27 @@ async function assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, global, force
         },
     });
 }
+async function ensureInitDirectories(pmRoot, subdirs) {
+    const createdDirs = [];
+    const warnings = [];
+    for (const subdir of subdirs) {
+        const target = subdir ? path.join(pmRoot, subdir) : pmRoot;
+        const existed = await pathExists(target);
+        await fs.mkdir(target, { recursive: true });
+        if (existed) {
+            warnings.push(`already_exists:${target}`);
+        }
+        else {
+            createdDirs.push(target);
+        }
+        warnings.push(...(await runActiveOnWriteHooks({
+            path: target,
+            scope: "project",
+            op: "init:ensure_dir",
+        })));
+    }
+    return { createdDirs, warnings };
+}
 async function runInitWizard(initialPrefix, telemetryDefault) {
     const rl = createInitReadlineInterface();
     try {
@@ -297,131 +318,160 @@ async function runInitWizard(initialPrefix, telemetryDefault) {
         rl.close();
     }
 }
-/**
- * Implements run init for the public runtime surface of this module.
- */
-export async function runInit(prefixArg, global, options = {}) {
-    const cwd = process.cwd();
-    const invocation = resolveInitInvocation(cwd, global, prefixArg);
-    const pmRoot = invocation.pmRoot;
-    prefixArg = invocation.prefixArg;
-    await assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, global, options.force === true);
-    const createdDirs = [];
-    const warnings = [];
-    let wizardUsed = false;
-    for (const subdir of PM_REQUIRED_SUBDIRS) {
-        const target = subdir ? path.join(pmRoot, subdir) : pmRoot;
-        const existed = await pathExists(target);
-        await fs.mkdir(target, { recursive: true });
-        if (existed) {
-            warnings.push(`already_exists:${target}`);
-        }
-        else {
-            createdDirs.push(target);
-        }
-        warnings.push(...(await runActiveOnWriteHooks({
-            path: target,
-            scope: "project",
-            op: "init:ensure_dir",
-        })));
+function normalizeInitCommandOptions(options) {
+    return {
+        presetFromOption: normalizeInitGovernancePreset(options.preset),
+        useDefaults: options.defaults === true,
+        authorFromOption: normalizeOptionalInitAuthor(options.author),
+        installBundledPackages: options.withPackages === true,
+        agentGuidanceMode: normalizeInitAgentGuidanceMode(options.agentGuidance),
+        typePreset: normalizeInitTypePreset(options.typePreset),
+    };
+}
+function collectExistingSettingsPendingChanges(params) {
+    const pendingChanges = [];
+    if (params.prefixArg !== undefined && params.settings.id_prefix !== params.normalizedPrefix) {
+        pendingChanges.push("id_prefix");
     }
-    const settingsPath = path.join(pmRoot, "settings.json");
-    const settingsExists = await pathExists(settingsPath);
-    let normalizedPrefix = normalizePrefix(prefixArg);
-    const presetFromOption = normalizeInitGovernancePreset(options.preset);
-    const useDefaults = options.defaults === true;
-    const authorFromOption = normalizeOptionalInitAuthor(options.author);
-    const installBundledPackages = options.withPackages === true;
-    const agentGuidanceMode = normalizeInitAgentGuidanceMode(options.agentGuidance);
-    const typePreset = normalizeInitTypePreset(options.typePreset);
-    let chosenPreset = presetFromOption;
-    let chosenTelemetryEnabled;
-    let settings;
-    if (settingsExists) {
-        settings = await readSettings(pmRoot);
-        warnings.push(`already_exists:${settingsPath}`);
-        const pendingChanges = [];
-        const shouldUpdatePrefix = prefixArg !== undefined && settings.id_prefix !== normalizedPrefix;
-        const shouldUpdatePreset = presetFromOption !== undefined && settings.governance.preset !== presetFromOption;
-        const shouldUpdateAuthor = authorFromOption !== undefined && settings.author_default !== authorFromOption;
-        if (shouldUpdatePrefix) {
-            pendingChanges.push("id_prefix");
-        }
-        if (shouldUpdatePreset) {
-            pendingChanges.push("governance_preset");
-        }
-        if (shouldUpdateAuthor) {
-            pendingChanges.push("author_default");
-        }
-        if (pendingChanges.length > 0 && options.force !== true) {
-            throw new PmCliError(`Refusing to update existing tracker settings at ${settingsPath} without --force.`, EXIT_CODE.USAGE, {
-                code: "init_existing_settings_requires_force",
-                type: "urn:pm-cli:error:init_existing_settings_requires_force",
-                required: `--force for ${pendingChanges.join(", ")}`,
-                why: "pm init is safe to rerun, but changing id prefix, governance preset, or default author on an existing tracker can corrupt long-lived project context when an agent meant to initialize a sandbox path.",
-                examples: [
-                    "pm init --yes",
-                    "pm init ./sandbox-pm --yes",
-                    "pm init acme --yes --force",
-                ],
-                nextSteps: [
-                    "If you meant to initialize a sandbox tracker, pass a path-like positional such as ./sandbox-pm or /tmp/pm-test.",
-                    "If you intentionally want to rewrite this existing tracker's init-managed settings, rerun with --force.",
-                ],
-            });
-        }
-        let changed = false;
-        if (shouldUpdatePrefix) {
-            settings.id_prefix = normalizedPrefix;
-            warnings.push(`updated:id_prefix:${normalizedPrefix}`);
-            changed = true;
-        }
-        if (shouldUpdatePreset) {
-            applyGovernancePreset(settings, presetFromOption);
-            warnings.push(`updated:governance_preset:${presetFromOption}`);
-            changed = true;
-        }
-        if (shouldUpdateAuthor) {
-            settings.author_default = authorFromOption;
-            warnings.push(`updated:author_default:${authorFromOption}`);
-            changed = true;
-        }
-        if (changed) {
-            await writeSettings(pmRoot, settings);
-        }
+    if (params.presetFromOption !== undefined && params.settings.governance.preset !== params.presetFromOption) {
+        pendingChanges.push("governance_preset");
     }
-    else {
-        if (presetFromOption === undefined && !useDefaults && process.stdin.isTTY === true && process.stdout.isTTY === true) {
-            const wizardChoices = await runInitWizard(normalizedPrefix, SETTINGS_DEFAULTS.telemetry.enabled);
-            normalizedPrefix = wizardChoices.prefix;
-            chosenPreset = wizardChoices.preset;
-            chosenTelemetryEnabled = wizardChoices.telemetry_enabled;
-            wizardUsed = true;
-        }
-        const effectivePreset = chosenPreset ?? "minimal";
-        settings = cloneDefaults();
-        settings.id_prefix = normalizedPrefix;
-        applyGovernancePreset(settings, effectivePreset);
-        if (authorFromOption !== undefined) {
-            settings.author_default = authorFromOption;
-        }
-        if (chosenTelemetryEnabled !== undefined) {
-            settings.telemetry.enabled = chosenTelemetryEnabled;
-            settings.telemetry.first_run_prompt_completed = true;
-        }
-        await writeSettings(pmRoot, settings);
+    if (params.authorFromOption !== undefined && params.settings.author_default !== params.authorFromOption) {
+        pendingChanges.push("author_default");
     }
+    return pendingChanges;
+}
+function assertExistingSettingsUpdateAllowed(settingsPath, pendingChanges, force) {
+    if (pendingChanges.length === 0 || force) {
+        return;
+    }
+    throw new PmCliError(`Refusing to update existing tracker settings at ${settingsPath} without --force.`, EXIT_CODE.USAGE, {
+        code: "init_existing_settings_requires_force",
+        type: "urn:pm-cli:error:init_existing_settings_requires_force",
+        required: `--force for ${pendingChanges.join(", ")}`,
+        why: "pm init is safe to rerun, but changing id prefix, governance preset, or default author on an existing tracker can corrupt long-lived project context when an agent meant to initialize a sandbox path.",
+        examples: [
+            "pm init --yes",
+            "pm init ./sandbox-pm --yes",
+            "pm init acme --yes --force",
+        ],
+        nextSteps: [
+            "If you meant to initialize a sandbox tracker, pass a path-like positional such as ./sandbox-pm or /tmp/pm-test.",
+            "If you intentionally want to rewrite this existing tracker's init-managed settings, rerun with --force.",
+        ],
+    });
+}
+function applyExistingSettingsUpdates(params) {
+    let changed = false;
+    if (params.prefixArg !== undefined && params.settings.id_prefix !== params.normalizedPrefix) {
+        params.settings.id_prefix = params.normalizedPrefix;
+        params.warnings.push(`updated:id_prefix:${params.normalizedPrefix}`);
+        changed = true;
+    }
+    if (params.presetFromOption !== undefined && params.settings.governance.preset !== params.presetFromOption) {
+        applyGovernancePreset(params.settings, params.presetFromOption);
+        params.warnings.push(`updated:governance_preset:${params.presetFromOption}`);
+        changed = true;
+    }
+    if (params.authorFromOption !== undefined && params.settings.author_default !== params.authorFromOption) {
+        params.settings.author_default = params.authorFromOption;
+        params.warnings.push(`updated:author_default:${params.authorFromOption}`);
+        changed = true;
+    }
+    return changed;
+}
+async function loadExistingInitSettings(params) {
+    const settings = await readSettings(params.pmRoot);
+    params.warnings.push(`already_exists:${params.settingsPath}`);
+    const pendingChanges = collectExistingSettingsPendingChanges({
+        settings,
+        normalizedPrefix: params.normalizedPrefix,
+        prefixArg: params.prefixArg,
+        presetFromOption: params.normalizedOptions.presetFromOption,
+        authorFromOption: params.normalizedOptions.authorFromOption,
+    });
+    assertExistingSettingsUpdateAllowed(params.settingsPath, pendingChanges, params.options.force === true);
+    if (applyExistingSettingsUpdates({
+        settings,
+        normalizedPrefix: params.normalizedPrefix,
+        prefixArg: params.prefixArg,
+        presetFromOption: params.normalizedOptions.presetFromOption,
+        authorFromOption: params.normalizedOptions.authorFromOption,
+        warnings: params.warnings,
+    })) {
+        await writeSettings(params.pmRoot, settings);
+    }
+    return {
+        settings,
+        normalizedPrefix: params.normalizedPrefix,
+        chosenPreset: params.normalizedOptions.presetFromOption,
+        wizardUsed: false,
+    };
+}
+async function createNewInitSettings(params) {
+    let normalizedPrefix = params.normalizedPrefix;
+    let chosenPreset = params.normalizedOptions.presetFromOption;
+    let chosenTelemetryEnabled;
+    let wizardUsed = false;
+    if (params.normalizedOptions.presetFromOption === undefined &&
+        !params.normalizedOptions.useDefaults &&
+        process.stdin.isTTY === true &&
+        process.stdout.isTTY === true) {
+        const wizardChoices = await runInitWizard(normalizedPrefix, SETTINGS_DEFAULTS.telemetry.enabled);
+        normalizedPrefix = wizardChoices.prefix;
+        chosenPreset = wizardChoices.preset;
+        chosenTelemetryEnabled = wizardChoices.telemetry_enabled;
+        wizardUsed = true;
+    }
+    const effectivePreset = chosenPreset ?? "minimal";
+    const settings = cloneDefaults();
+    settings.id_prefix = normalizedPrefix;
+    applyGovernancePreset(settings, effectivePreset);
+    if (params.normalizedOptions.authorFromOption !== undefined) {
+        settings.author_default = params.normalizedOptions.authorFromOption;
+    }
+    if (chosenTelemetryEnabled !== undefined) {
+        settings.telemetry.enabled = chosenTelemetryEnabled;
+        settings.telemetry.first_run_prompt_completed = true;
+    }
+    await writeSettings(params.pmRoot, settings);
+    return {
+        settings,
+        normalizedPrefix,
+        chosenPreset,
+        wizardUsed,
+    };
+}
+async function resolveInitSettings(params) {
+    if (params.settingsExists) {
+        return await loadExistingInitSettings(params);
+    }
+    return await createNewInitSettings({
+        pmRoot: params.pmRoot,
+        normalizedPrefix: params.normalizedPrefix,
+        normalizedOptions: params.normalizedOptions,
+    });
+}
+async function applyInitAgentGuidance(params) {
     const agentGuidanceResult = await runInitAgentGuidance({
-        pm_root: pmRoot,
-        cwd,
-        mode: agentGuidanceMode,
+        pm_root: params.pmRoot,
+        cwd: params.cwd,
+        mode: params.agentGuidanceMode,
         interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
-        settings,
+        settings: params.settings,
     });
-    warnings.push(...agentGuidanceResult.warnings);
+    params.warnings.push(...agentGuidanceResult.warnings);
     if (agentGuidanceResult.settings_changed) {
-        await writeSettings(pmRoot, settings);
+        await writeSettings(params.pmRoot, params.settings);
     }
+    return {
+        ...agentGuidanceResult.summary,
+        next_steps: agentGuidanceResult.next_steps,
+    };
+}
+async function ensureInitRuntimeSchemaFiles(pmRoot, settings) {
+    const createdDirs = [];
+    const warnings = [];
     const runtimeSchemaScaffold = await ensureRuntimeSchemaFileScaffold(pmRoot, settings.schema);
     for (const createdPath of runtimeSchemaScaffold.created_paths) {
         createdDirs.push(createdPath);
@@ -431,67 +481,118 @@ export async function runInit(prefixArg, global, options = {}) {
             op: "init:runtime_schema_file",
         })));
     }
-    let registeredTypePreset;
-    if (typePreset !== undefined) {
-        registeredTypePreset = await registerInitTypePreset(pmRoot, settings, typePreset);
-        warnings.push(`registered_type_preset:${typePreset}`);
-        warnings.push(...(await runActiveOnWriteHooks({
-            path: registeredTypePreset.file,
-            scope: "project",
-            op: "init:type_preset",
-        })));
-        settings = await readSettings(pmRoot);
+    return { createdDirs, warnings };
+}
+async function maybeRegisterInitTypePreset(params) {
+    if (params.typePreset === undefined) {
+        return undefined;
     }
-    const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
-    for (const typeFolder of typeRegistry.folders) {
-        if (PM_REQUIRED_SUBDIRS.includes(typeFolder)) {
-            continue;
-        }
-        const target = path.join(pmRoot, typeFolder);
-        const existed = await pathExists(target);
-        await fs.mkdir(target, { recursive: true });
-        if (existed) {
-            warnings.push(`already_exists:${target}`);
-        }
-        else {
-            createdDirs.push(target);
-        }
-        warnings.push(...(await runActiveOnWriteHooks({
-            path: target,
-            scope: "project",
-            op: "init:ensure_dir",
-        })));
+    const registeredTypePreset = await registerInitTypePreset(params.pmRoot, params.settings, params.typePreset);
+    params.warnings.push(`registered_type_preset:${params.typePreset}`);
+    params.warnings.push(...(await runActiveOnWriteHooks({
+        path: registeredTypePreset.file,
+        scope: "project",
+        op: "init:type_preset",
+    })));
+    return registeredTypePreset;
+}
+async function ensureInitTypeDirectories(params) {
+    const typeRegistry = resolveItemTypeRegistry(params.settings, getActiveExtensionRegistrations());
+    const customTypeFolders = typeRegistry.folders.filter((folder) => !PM_REQUIRED_SUBDIRS.includes(folder));
+    const scaffold = await ensureInitDirectories(params.pmRoot, customTypeFolders);
+    params.createdDirs.push(...scaffold.createdDirs);
+    params.warnings.push(...scaffold.warnings);
+}
+async function maybeInstallInitBundledPackages(installBundledPackages, global, warnings) {
+    if (!installBundledPackages) {
+        return undefined;
     }
-    let installedPackages;
-    if (installBundledPackages) {
-        const packageInstallResult = await runExtension("all", { install: true, project: true }, global);
-        warnings.push(...packageInstallResult.warnings);
-        installedPackages = summarizeInstalledPackages(packageInstallResult);
-        if (!installedPackages.installed_all || installedPackages.packages.some((entry) => !entry.ok)) {
-            throw new PmCliError("pm init --with-packages did not install all bundled packages successfully.", EXIT_CODE.GENERIC_FAILURE);
-        }
+    const packageInstallResult = await runExtension("all", { install: true, project: true }, global);
+    warnings.push(...packageInstallResult.warnings);
+    const installedPackages = summarizeInstalledPackages(packageInstallResult);
+    if (!installedPackages.installed_all || installedPackages.packages.some((entry) => !entry.ok)) {
+        throw new PmCliError("pm init --with-packages did not install all bundled packages successfully.", EXIT_CODE.GENERIC_FAILURE);
     }
+    return installedPackages;
+}
+function buildInitNextSteps(params) {
     const nextSteps = [
         'Create your first item: pm create --type Task --title "<title>"',
         'List active items: pm list',
         'Get agent-friendly project context: pm context',
     ];
-    if (!installBundledPackages) {
+    if (!params.installBundledPackages) {
         nextSteps.push("Add optional packages for richer workflows: pm install calendar --project, pm install templates --project, pm install guide-shell --project");
         nextSteps.push("Or install everything bundled: pm init --with-packages (idempotent on re-run)");
     }
     else {
         nextSteps.push("Explore newly-available commands: pm cal, pm templates, pm guide");
     }
-    if (registeredTypePreset) {
-        nextSteps.push(`Inspect registered preset types: pm schema list, pm schema show ${registeredTypePreset.registered[0] ?? registeredTypePreset.updated[0]}`);
+    if (params.registeredTypePreset) {
+        nextSteps.push(`Inspect registered preset types: pm schema list, pm schema show ${params.registeredTypePreset.registered[0] ?? params.registeredTypePreset.updated[0]}`);
     }
     nextSteps.push("Set PM_AUTHOR=<your-agent-id> so mutations attribute to the right caller.");
-    for (const guidanceNextStep of agentGuidanceResult.next_steps) {
+    for (const guidanceNextStep of params.agentGuidanceNextSteps) {
         if (!nextSteps.includes(guidanceNextStep)) {
             nextSteps.push(guidanceNextStep);
         }
     }
+    return nextSteps;
+}
+/**
+ * Implements run init for the public runtime surface of this module.
+ */
+export async function runInit(prefixArg, global, options = {}) {
+    const cwd = process.cwd();
+    const invocation = resolveInitInvocation(cwd, global, prefixArg);
+    const pmRoot = invocation.pmRoot;
+    prefixArg = invocation.prefixArg;
+    await assertExplicitTrackerPathIsNotWorkspaceRoot(pmRoot, global, options.force === true);
+    const createdDirs = [];
+    const warnings = [];
+    const baseDirs = await ensureInitDirectories(pmRoot, PM_REQUIRED_SUBDIRS);
+    createdDirs.push(...baseDirs.createdDirs);
+    warnings.push(...baseDirs.warnings);
+    const settingsPath = path.join(pmRoot, "settings.json");
+    const settingsExists = await pathExists(settingsPath);
+    const normalizedOptions = normalizeInitCommandOptions(options);
+    let settingsResolution = await resolveInitSettings({
+        pmRoot,
+        settingsPath,
+        settingsExists,
+        normalizedPrefix: normalizePrefix(prefixArg),
+        prefixArg,
+        options,
+        normalizedOptions,
+        warnings,
+    });
+    let { settings } = settingsResolution;
+    const agentGuidance = await applyInitAgentGuidance({
+        pmRoot,
+        cwd,
+        agentGuidanceMode: normalizedOptions.agentGuidanceMode,
+        settings,
+        warnings,
+    });
+    const schemaFiles = await ensureInitRuntimeSchemaFiles(pmRoot, settings);
+    createdDirs.push(...schemaFiles.createdDirs);
+    warnings.push(...schemaFiles.warnings);
+    const registeredTypePreset = await maybeRegisterInitTypePreset({
+        pmRoot,
+        settings,
+        typePreset: normalizedOptions.typePreset,
+        warnings,
+    });
+    if (registeredTypePreset) {
+        settings = await readSettings(pmRoot);
+    }
+    await ensureInitTypeDirectories({ pmRoot, settings, createdDirs, warnings });
+    const installedPackages = await maybeInstallInitBundledPackages(normalizedOptions.installBundledPackages, global, warnings);
+    const nextSteps = buildInitNextSteps({
+        installBundledPackages: normalizedOptions.installBundledPackages,
+        registeredTypePreset,
+        agentGuidanceNextSteps: agentGuidance.next_steps,
+    });
     return {
         ok: true,
         path: pmRoot,
@@ -499,12 +600,12 @@ export async function runInit(prefixArg, global, options = {}) {
         created_dirs: createdDirs,
         warnings,
         governance_preset: settings.governance.preset,
-        wizard_used: wizardUsed,
+        wizard_used: settingsResolution.wizardUsed,
         ...(registeredTypePreset ? { registered_type_preset: registeredTypePreset } : {}),
         ...(installedPackages ? { installed_packages: installedPackages } : {}),
         next_steps: nextSteps,
-        agent_guidance: agentGuidanceResult.summary,
+        agent_guidance: agentGuidance,
     };
 }
 //# sourceMappingURL=init.js.map
-//# debugId=cfc0ecc2-1b5c-5332-8da2-deedda554690
+//# debugId=a0acfeba-010e-51e0-bc49-90e4854fe975