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

package/dist/hosts/integration/pi-extension-runtime.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Minimal structural surface used by the generated Pi extension. The host SDK
+ * remains the authority for exact event payloads; this runtime validates the
+ * normalized fields before any local write.
+ */
+export interface PiExtensionLike {
+    on(event: string, handler: (event: unknown, context: unknown) => Promise<void> | void): void;
+    registerCommand(name: string, options: {
+        readonly description: string;
+        readonly handler: (args: string, context: unknown) => Promise<void> | void;
+    }): void;
+}
+/**
+ * Registers only bounded local lifecycle observations. It deliberately does
+ * not start processes, read transcripts, call models, fetch, index or continue
+ * a session.
+ */
+export declare function createPiExtension(pi: PiExtensionLike): void;

package/dist/hosts/integration/pi-extension-runtime.js

@@ -0,0 +1,89 @@
+import { runHostHook } from './hook.js';
+function contextCwd(context) {
+    if (typeof context === 'object' &&
+        context !== null &&
+        'cwd' in context &&
+        typeof context.cwd === 'string') {
+        return context.cwd;
+    }
+    return null;
+}
+function contextSessionId(context) {
+    if (typeof context !== 'object' || context === null)
+        return null;
+    if ('sessionManager' in context &&
+        typeof context.sessionManager === 'object' &&
+        context.sessionManager !== null) {
+        const manager = context.sessionManager;
+        if ('getSessionId' in manager &&
+            typeof manager.getSessionId === 'function') {
+            const value = manager.getSessionId();
+            if (typeof value === 'string')
+                return value;
+        }
+    }
+    return null;
+}
+function notifyContext(context, message) {
+    if (typeof context !== 'object' || context === null)
+        return;
+    if ('ui' in context &&
+        typeof context.ui === 'object' &&
+        context.ui !== null &&
+        'notify' in context.ui &&
+        typeof context.ui.notify === 'function') {
+        context.ui.notify(message, 'info');
+    }
+}
+async function observe(event, context, taskId = null) {
+    const cwd = contextCwd(context);
+    if (cwd === null)
+        return;
+    const input = {
+        schema: 'pappra/host-hook-input/1',
+        host: 'pi',
+        event,
+        nativeEvent: event === 'startup'
+            ? 'session_start'
+            : event === 'compact'
+                ? 'session_before_compact'
+                : 'pappra-checkpoint',
+        eventId: null,
+        sessionId: contextSessionId(context),
+        cwd,
+        root: null,
+        taskId,
+        source: 'pi-extension',
+        observedAt: new Date().toISOString(),
+    };
+    try {
+        const result = await runHostHook(input);
+        if (result.context !== null)
+            notifyContext(context, result.context);
+    }
+    catch {
+        // A hook failure must not replace the host's own lifecycle failure.
+    }
+}
+/**
+ * Registers only bounded local lifecycle observations. It deliberately does
+ * not start processes, read transcripts, call models, fetch, index or continue
+ * a session.
+ */
+export function createPiExtension(pi) {
+    pi.on('session_start', async (_event, context) => {
+        await observe('startup', context);
+    });
+    pi.on('session_before_compact', async (_event, context) => {
+        await observe('compact', context);
+    });
+    pi.registerCommand('pappra-checkpoint', {
+        description: 'Record a bounded Pappra checkpoint request; manual pappra checkpoint/resume remains required.',
+        handler: async (_args, context) => {
+            const taskId = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(_args.trim())
+                ? _args.trim()
+                : null;
+            await observe('checkpoint-request', context, taskId);
+        },
+    });
+}

package/dist/hosts/integration/pi-template.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+/** Typechecked native-template shape; renderHostTemplate emits the same surface. */
+export default function (pi: ExtensionAPI): void;

package/dist/hosts/integration/pi-template.js

@@ -0,0 +1,5 @@
+import { createPiExtension } from './pi-extension-runtime.js';
+/** Typechecked native-template shape; renderHostTemplate emits the same surface. */
+export default function (pi) {
+    createPiExtension(pi);
+}

package/dist/hosts/integration/service.d.ts

@@ -0,0 +1,41 @@
+import type { HostCapabilities, HostInstallManifest, HostIntegrationPlan, HostIntegrationResult, HostName, HostVerification } from '../../schemas/host.js';
+export interface HostIntegrationOptions {
+    readonly root: string;
+    readonly homeDir: string;
+    readonly pathEnv: string;
+    readonly runtimeEntry?: string;
+    readonly hostVersion?: string | null;
+    readonly selectedHosts?: readonly HostName[];
+    readonly observedAt?: string;
+}
+export interface HostTargetOptions {
+    readonly hostRoot?: string;
+    readonly runtimeEntry?: string;
+    readonly hostVersion?: string | null;
+}
+export interface HostPlanBundle {
+    readonly plan: HostIntegrationPlan;
+    readonly contents: ReadonlyMap<string, Buffer>;
+}
+export declare class HostIntegrationService {
+    #private;
+    constructor(options: HostIntegrationOptions);
+    detect(): readonly HostCapabilities[];
+    describe(host: HostName): HostCapabilities;
+    adapter(host: HostName): HostAdapter;
+    plan(host: HostName, options?: HostTargetOptions): Promise<HostIntegrationPlan>;
+    install(host: HostName, options: HostTargetOptions & {
+        readonly apply: boolean;
+    }): Promise<HostIntegrationResult>;
+    verify(host: HostName, options?: HostTargetOptions): Promise<HostVerification>;
+    readManifest(hostRoot: string): Promise<HostInstallManifest | null>;
+}
+export declare class HostAdapter {
+    #private;
+    readonly host: HostName;
+    constructor(service: HostIntegrationService, host: HostName);
+    detect(): HostCapabilities;
+    describeCapabilities(): HostCapabilities;
+    planIntegration(options?: HostTargetOptions): Promise<HostIntegrationPlan>;
+    verifyIntegration(options?: HostTargetOptions): Promise<HostVerification>;
+}