@phyzess/pappra 0.0.0-stage → 0.1.0-beta.2

package/dist/cli/commands/doctor.js

@@ -0,0 +1,57 @@
+import { runDoctor } from '../../app/doctor.js';
+function printHuman(output, report) {
+    output.stdout(`Pappra doctor ${report.generatedAt}\n`);
+    output.stdout(`Workspace: ${report.workspace.root ?? '(not registered)'}\n`);
+    output.stdout(`Runtime target: ${report.runtime.targetVersion ?? '(none)'}; machine: ${report.runtime.machineRuntime?.version ?? '(none)'}; passive state: ${report.runtime.passiveStatus ?? '(unknown)'}\n`);
+    for (const check of report.checks) {
+        output.stdout(`\n[${check.status.toUpperCase()}] ${check.id}: ${check.title}\n`);
+        output.stdout(`  ${check.summary}\n`);
+        output.stdout(`  source: ${check.source}\n`);
+        if (check.coverage !== null)
+            output.stdout(`  coverage: ${check.coverage}\n`);
+        for (const action of check.nextActions) {
+            output.stdout(`  next: ${action}\n`);
+        }
+    }
+    output.stdout(`\nSummary: ${report.summary.status} (exit ${report.summary.exitCode}); ` +
+        `ok=${report.summary.counts.ok}, warning=${report.summary.counts.warning}, ` +
+        `error=${report.summary.counts.error}, unknown=${report.summary.counts.unknown}, ` +
+        `partial=${report.summary.counts.partial}, unsupported=${report.summary.counts.unsupported}\n`);
+    if (report.scope.notChecked.length > 0) {
+        output.stdout(`Not checked: ${report.scope.notChecked.join(', ')}\n`);
+    }
+}
+/**
+ * Runs one read-only doctor report. JSON mode writes exactly one JSON document
+ * to stdout and never opens prompts or emits progress logs.
+ */
+export async function runDoctorCommand(options, output) {
+    try {
+        const report = await runDoctor({
+            root: options.root,
+            ...(options.dataDir === undefined ? {} : { dataDir: options.dataDir }),
+            ...(options.homeDir === undefined ? {} : { homeDir: options.homeDir }),
+            ...(options.pathEnv === undefined ? {} : { pathEnv: options.pathEnv }),
+        });
+        if (options.json) {
+            output.stdout(`${JSON.stringify(report)}\n`);
+        }
+        else {
+            printHuman(output, report);
+        }
+        return report.summary.exitCode;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (options.json) {
+            output.stdout(`${JSON.stringify({ ok: false, command: 'doctor', code: 'doctor_failed', message })}\n`);
+        }
+        else {
+            output.stderr(`pappra doctor: ${message}\n`);
+        }
+        return 1;
+    }
+}
+export const doctorUsage = 'pappra doctor [--root <path>] [--json]\n\n' +
+    'Read-only workspace, runtime, install-state, host, and tool diagnostics.\n' +
+    'Doctor never installs, repairs, indexes, starts hosts/models, or removes locks/runtimes.\n';

package/dist/cli/commands/host.d.ts

@@ -0,0 +1,13 @@
+import type { HostName } from '../../schemas/host.js';
+import type { CliOutput } from '../output.js';
+export declare const hostUsage: string;
+export interface HostCommandOptions {
+    readonly cwd: string;
+    readonly json: boolean;
+    readonly action: 'detect' | 'describe' | 'plan' | 'install' | 'verify' | null;
+    readonly host: HostName | null;
+    readonly hostRoot: string | null;
+    readonly hostVersion: string | null;
+    readonly apply: boolean;
+}
+export declare function runHostCommand(options: HostCommandOptions, output: CliOutput): Promise<number>;

package/dist/cli/commands/host.js

@@ -0,0 +1,125 @@
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { HostIntegrationService } from '../../hosts/integration/service.js';
+export const hostUsage = 'pappra host <detect|describe|plan|install|verify> --host <pi|codex|claude>\n' +
+    '  [--host-root <dir>] [--host-version <version>] [--apply] [--json]';
+function printDiagnostics(output, diagnostics) {
+    for (const entry of diagnostics) {
+        if (typeof entry === 'object' &&
+            entry !== null &&
+            'message' in entry &&
+            typeof entry.message === 'string') {
+            if ('hint' in entry && typeof entry.hint === 'string') {
+                output.stderr(`${entry.message} Hint: ${entry.hint}\n`);
+            }
+            else {
+                output.stderr(`${entry.message}\n`);
+            }
+        }
+    }
+}
+function diagnosticStatus(status) {
+    return status === 'planned' ||
+        status === 'applied' ||
+        status === 'unchanged' ||
+        status === 'verified' ||
+        status === 'duplicate'
+        ? 0
+        : 1;
+}
+export async function runHostCommand(options, output) {
+    if (options.action === null || options.host === null) {
+        output.stderr('pappra: host requires an action and --host.\n');
+        return 2;
+    }
+    const service = new HostIntegrationService({
+        root: options.cwd,
+        homeDir: homedir(),
+        pathEnv: process.env.PATH ?? '',
+        hostVersion: options.hostVersion,
+        observedAt: new Date().toISOString(),
+    });
+    const hostRoot = options.hostRoot === null
+        ? undefined
+        : resolve(options.cwd, options.hostRoot);
+    const target = {
+        ...(hostRoot === undefined ? {} : { hostRoot }),
+        ...(options.hostVersion === null
+            ? {}
+            : { hostVersion: options.hostVersion }),
+    };
+    if (options.action === 'detect' || options.action === 'describe') {
+        const capabilities = service.describe(options.host);
+        if (options.json) {
+            output.stdout(`${JSON.stringify(capabilities)}\n`);
+        }
+        else {
+            output.stdout(`Host: ${capabilities.host} ${capabilities.version ?? '(unknown)'}\n`);
+            output.stdout(`Surface: ${capabilities.surface}\n`);
+            output.stdout(`Executable: ${capabilities.executablePath ?? 'missing'}\n`);
+            output.stdout(`Reload required: ${capabilities.reloadRequired ? 'yes' : 'no'}\n`);
+            output.stdout(`Trust required: ${capabilities.trustRequired ? 'yes' : 'no'}\n`);
+            for (const capability of capabilities.capabilities) {
+                output.stdout(`  ${capability.event}: ${capability.state}${capability.nativeEvent === null ? '' : ` (${capability.nativeEvent})`}\n`);
+            }
+        }
+        return 0;
+    }
+    if (options.action === 'plan') {
+        try {
+            const plan = await service.plan(options.host, target);
+            if (options.json) {
+                output.stdout(`${JSON.stringify(plan)}\n`);
+            }
+            else {
+                output.stdout(`Host: ${plan.host} @ ${plan.hostRoot}\n`);
+                output.stdout(`Bundle: ${plan.bundleDigest}\n`);
+                for (const file of plan.files) {
+                    output.stdout(`  ${file.operation} ${file.path}\n`);
+                }
+                printDiagnostics(output, plan.diagnostics);
+            }
+            return 0;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (options.json) {
+                output.stdout(`${JSON.stringify({ ok: false, command: 'host', code: 'host_plan_failed', message })}\n`);
+            }
+            else {
+                output.stderr(`pappra host: ${message}\n`);
+            }
+            return 1;
+        }
+    }
+    if (options.action === 'install') {
+        const result = await service.install(options.host, {
+            ...target,
+            apply: options.apply,
+        });
+        if (options.json) {
+            output.stdout(`${JSON.stringify(result)}\n`);
+        }
+        else {
+            output.stdout(`Status: ${result.status}\n`);
+            for (const file of result.appliedFiles)
+                output.stdout(`  applied ${file}\n`);
+            for (const path of result.residualPaths)
+                output.stdout(`  residual ${path}\n`);
+            printDiagnostics(output, result.diagnostics);
+        }
+        return diagnosticStatus(result.status);
+    }
+    const result = await service.verify(options.host, target);
+    if (options.json) {
+        output.stdout(`${JSON.stringify(result)}\n`);
+    }
+    else {
+        output.stdout(`Status: ${result.status}\n`);
+        for (const check of result.checks) {
+            output.stdout(`  [${check.status}] ${check.id}: ${check.detail}\n`);
+        }
+        printDiagnostics(output, result.diagnostics);
+    }
+    return diagnosticStatus(result.status);
+}

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,51 @@
+import type { Diagnostic } from '../../schemas/diagnostics.js';
+import { type InitChoices } from '../../schemas/init.js';
+import { type RuntimeInstallResult } from '../../install/runtime.js';
+import { type InitContext } from '../../app/init.js';
+import type { CliOutput } from '../output.js';
+export interface SelectOption {
+    readonly value: string;
+    readonly label: string;
+    readonly hint?: string;
+}
+export interface WizardUi {
+    intro(message: string): void;
+    outro(message: string): void;
+    note(message: string, title: string): void;
+    text(message: string, initialValue?: string): Promise<string | symbol>;
+    select(message: string, options: readonly SelectOption[], initialValue?: string): Promise<string | symbol>;
+    multiselect(message: string, options: readonly SelectOption[], initialValues?: readonly string[]): Promise<readonly string[] | symbol>;
+    confirm(message: string, initialValue?: boolean): Promise<boolean | symbol>;
+    cancel(message: string): void;
+}
+export declare const clackWizardUi: WizardUi;
+/**
+ * UI-only selection collection. All validation and plan generation remains in
+ * the app service; cancelling this function never writes to the workspace.
+ */
+export declare function collectInitChoices(context: InitContext, ui: WizardUi): Promise<InitChoices | null>;
+export interface InitCommandOptions {
+    readonly cwd: string;
+    readonly configPath: string | null;
+    readonly apply: boolean;
+    readonly json: boolean;
+    readonly installRuntime?: boolean;
+    readonly runtimeTarball?: string | null;
+    readonly runtimeVersion?: string | null;
+}
+export interface RuntimeFlowResult {
+    readonly ok: boolean;
+    readonly completion: boolean;
+    readonly runtime: RuntimeInstallResult | null;
+    readonly diagnostics: readonly Diagnostic[];
+}
+export interface InitCommandDeps {
+    readonly ui?: WizardUi;
+    readonly interactive?: boolean;
+}
+/**
+ * CLI command entry. In JSON mode no prompt is ever opened and stdout contains
+ * exactly one JSON document. Interactive selection is injected for tests.
+ */
+export declare function runInitCommand(options: InitCommandOptions, output: CliOutput, deps?: InitCommandDeps): Promise<number>;
+export declare const initUsage: string;