@haaaiawd/second-nature 0.1.18 → 0.1.20

package/runtime/connectors/base/manifest.js

@@ -1,86 +1,86 @@
-import { z } from "zod";
-import { CAPABILITY_INTENTS, CHANNEL_TYPES } from "./contract.js";
-const sourceRefPolicySchema = z
-    .object({
-    minSourceRefs: z.number().int().min(0).default(1),
-    rejectInlineSensitivePayload: z.boolean().optional(),
-})
-    .optional();
-const connectorManifestSchema = z.object({
-    platformId: z.string().min(1),
-    supportedCapabilities: z.array(z.enum(CAPABILITY_INTENTS)).min(1),
-    channelPriority: z.array(z.enum(CHANNEL_TYPES)).min(1),
-    credentialTypes: z.array(z.string().min(1)).min(1),
-    degradedChannels: z.array(z.enum(CHANNEL_TYPES)).optional(),
-    sourceRefPolicy: sourceRefPolicySchema,
-});
-export class CapabilityContractRegistry {
-    byPlatform = new Map();
-    register(manifest) {
-        const parsed = connectorManifestSchema.parse(manifest);
-        this.byPlatform.set(parsed.platformId, parsed);
-    }
-    loadManifest(platformId) {
-        const found = this.byPlatform.get(platformId);
-        if (!found) {
-            throw new Error(`connector_manifest_not_found:${platformId}`);
-        }
-        return found;
-    }
-    listRegisteredPlatformIds() {
-        return [...this.byPlatform.keys()];
-    }
-    hasCapability(platformId, intent) {
-        const manifest = this.loadManifest(platformId);
-        return manifest.supportedCapabilities.includes(intent);
-    }
-    listCapabilities(platformId) {
-        return [...this.loadManifest(platformId).supportedCapabilities];
-    }
-    listChannels(platformId) {
-        return [...this.loadManifest(platformId).channelPriority];
-    }
-}
-/** T3.1.1 contract name for manifest-first registry. */
-export const ConnectorManifestRegistry = CapabilityContractRegistry;
-export function describeConnector(registry, platformId) {
-    return registry.loadManifest(platformId);
-}
-export function checkConnector(registry, platformId) {
-    const errors = [];
-    try {
-        const manifest = registry.loadManifest(platformId);
-        if (manifest.supportedCapabilities.length === 0) {
-            errors.push("capability_list_empty");
-        }
-        if (manifest.channelPriority.length === 0) {
-            errors.push("channel_priority_empty");
-        }
-        if (manifest.credentialTypes.length === 0) {
-            errors.push("credential_types_empty");
-        }
-        const degraded = manifest.degradedChannels ?? [];
-        for (const channel of degraded) {
-            if (!manifest.channelPriority.includes(channel)) {
-                errors.push(`degraded_channel_not_in_priority:${channel}`);
-            }
-        }
-    }
-    catch (error) {
-        errors.push(error instanceof Error ? error.message : String(error));
-    }
-    return { ok: errors.length === 0, errors };
-}
-export function discoverCapabilities(registry) {
-    return registry.listRegisteredPlatformIds().map((platformId) => {
-        const manifest = registry.loadManifest(platformId);
-        return {
-            platformId,
-            capabilities: [...manifest.supportedCapabilities],
-            degradedChannels: manifest.degradedChannels,
-        };
-    });
-}
-export function parseConnectorManifest(input) {
-    return connectorManifestSchema.parse(input);
-}
+import { z } from "zod";
+import { CAPABILITY_INTENTS, CHANNEL_TYPES } from "./contract.js";
+const sourceRefPolicySchema = z
+    .object({
+    minSourceRefs: z.number().int().min(0).default(1),
+    rejectInlineSensitivePayload: z.boolean().optional(),
+})
+    .optional();
+const connectorManifestSchema = z.object({
+    platformId: z.string().min(1),
+    supportedCapabilities: z.array(z.enum(CAPABILITY_INTENTS)).min(1),
+    channelPriority: z.array(z.enum(CHANNEL_TYPES)).min(1),
+    credentialTypes: z.array(z.string().min(1)).min(1),
+    degradedChannels: z.array(z.enum(CHANNEL_TYPES)).optional(),
+    sourceRefPolicy: sourceRefPolicySchema,
+});
+export class CapabilityContractRegistry {
+    byPlatform = new Map();
+    register(manifest) {
+        const parsed = connectorManifestSchema.parse(manifest);
+        this.byPlatform.set(parsed.platformId, parsed);
+    }
+    loadManifest(platformId) {
+        const found = this.byPlatform.get(platformId);
+        if (!found) {
+            throw new Error(`connector_manifest_not_found:${platformId}`);
+        }
+        return found;
+    }
+    listRegisteredPlatformIds() {
+        return [...this.byPlatform.keys()];
+    }
+    hasCapability(platformId, intent) {
+        const manifest = this.loadManifest(platformId);
+        return manifest.supportedCapabilities.includes(intent);
+    }
+    listCapabilities(platformId) {
+        return [...this.loadManifest(platformId).supportedCapabilities];
+    }
+    listChannels(platformId) {
+        return [...this.loadManifest(platformId).channelPriority];
+    }
+}
+/** T3.1.1 contract name for manifest-first registry. */
+export const ConnectorManifestRegistry = CapabilityContractRegistry;
+export function describeConnector(registry, platformId) {
+    return registry.loadManifest(platformId);
+}
+export function checkConnector(registry, platformId) {
+    const errors = [];
+    try {
+        const manifest = registry.loadManifest(platformId);
+        if (manifest.supportedCapabilities.length === 0) {
+            errors.push("capability_list_empty");
+        }
+        if (manifest.channelPriority.length === 0) {
+            errors.push("channel_priority_empty");
+        }
+        if (manifest.credentialTypes.length === 0) {
+            errors.push("credential_types_empty");
+        }
+        const degraded = manifest.degradedChannels ?? [];
+        for (const channel of degraded) {
+            if (!manifest.channelPriority.includes(channel)) {
+                errors.push(`degraded_channel_not_in_priority:${channel}`);
+            }
+        }
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+    }
+    return { ok: errors.length === 0, errors };
+}
+export function discoverCapabilities(registry) {
+    return registry.listRegisteredPlatformIds().map((platformId) => {
+        const manifest = registry.loadManifest(platformId);
+        return {
+            platformId,
+            capabilities: [...manifest.supportedCapabilities],
+            degradedChannels: manifest.degradedChannels,
+        };
+    });
+}
+export function parseConnectorManifest(input) {
+    return connectorManifestSchema.parse(input);
+}

package/runtime/connectors/base/map-life-evidence.d.ts

@@ -1,16 +1,16 @@
-/**
- * Maps normalized connector success results to `LifeEvidenceCandidate` (T3.1.2).
- * Returns null when evidence cannot be source-backed (no refs, wrong intent, or failure).
- */
-import type { CapabilityIntent, ConnectorResult } from "./contract.js";
-import type { LifeEvidenceCandidate, Sensitivity } from "../../storage/life-evidence/types.js";
-/**
- * Produce a single life-evidence candidate from a connector outcome, or null if not mappable.
- */
-export declare function mapLifeEvidence(input: {
-    platformId: string;
-    intent: CapabilityIntent;
-    result: ConnectorResult<unknown>;
-    observedAt?: string;
-    sensitivityOverride?: Sensitivity;
-}): LifeEvidenceCandidate | null;
+/**
+ * Maps normalized connector success results to `LifeEvidenceCandidate` (T3.1.2).
+ * Returns null when evidence cannot be source-backed (no refs, wrong intent, or failure).
+ */
+import type { CapabilityIntent, ConnectorResult } from "./contract.js";
+import type { LifeEvidenceCandidate, Sensitivity } from "../../storage/life-evidence/types.js";
+/**
+ * Produce a single life-evidence candidate from a connector outcome, or null if not mappable.
+ */
+export declare function mapLifeEvidence(input: {
+    platformId: string;
+    intent: CapabilityIntent;
+    result: ConnectorResult<unknown>;
+    observedAt?: string;
+    sensitivityOverride?: Sensitivity;
+}): LifeEvidenceCandidate | null;

package/runtime/connectors/base/map-life-evidence.js

@@ -1,79 +1,79 @@
-function extractSourceRefs(platformId, data, observedAt) {
-    if (data && typeof data === "object") {
-        const record = data;
-        if (Array.isArray(record.sourceRefs)) {
-            const out = [];
-            for (const item of record.sourceRefs) {
-                if (item && typeof item === "object" && "uri" in item && "id" in item) {
-                    const ref = item;
-                    out.push({
-                        id: String(ref.id),
-                        kind: ref.kind ?? "platform_item",
-                        uri: String(ref.uri),
-                        excerptHash: ref.excerptHash !== undefined ? String(ref.excerptHash) : undefined,
-                        observedAt: ref.observedAt !== undefined ? String(ref.observedAt) : observedAt,
-                    });
-                }
-            }
-            if (out.length > 0)
-                return out;
-        }
-        if (Array.isArray(record.items)) {
-            return record.items.map((item, index) => {
-                const id = item && typeof item === "object" && "id" in item
-                    ? String(item.id)
-                    : `${platformId}-item-${index}`;
-                return {
-                    id,
-                    kind: "platform_item",
-                    uri: `platform://${platformId}/item/${encodeURIComponent(id)}`,
-                    observedAt,
-                };
-            });
-        }
-    }
-    return [];
-}
-function resolveEvidenceType(intent) {
-    if (intent === "feed.read")
-        return "platform_browse";
-    if (intent === "work.discover")
-        return "task_discovery";
-    return null;
-}
-function resolveSensitivity(intent, explicit) {
-    if (explicit)
-        return explicit;
-    if (intent === "message.send" || intent === "comment.reply")
-        return "private";
-    return "public";
-}
-/**
- * Produce a single life-evidence candidate from a connector outcome, or null if not mappable.
- */
-export function mapLifeEvidence(input) {
-    if (input.result.status !== "success") {
-        return null;
-    }
-    if (input.intent === "message.send") {
-        return null;
-    }
-    const evidenceType = resolveEvidenceType(input.intent);
-    if (!evidenceType) {
-        return null;
-    }
-    const observedAt = input.observedAt ?? new Date().toISOString();
-    const refs = extractSourceRefs(input.platformId, input.result.data, observedAt);
-    if (refs.length === 0) {
-        return null;
-    }
-    return {
-        timestamp: observedAt,
-        evidenceType,
-        platformId: input.platformId,
-        summary: `${input.platformId}:${input.intent}`,
-        sourceRefs: refs,
-        sensitivity: resolveSensitivity(input.intent, input.sensitivityOverride),
-        producer: "connector-system",
-    };
-}
+function extractSourceRefs(platformId, data, observedAt) {
+    if (data && typeof data === "object") {
+        const record = data;
+        if (Array.isArray(record.sourceRefs)) {
+            const out = [];
+            for (const item of record.sourceRefs) {
+                if (item && typeof item === "object" && "uri" in item && "id" in item) {
+                    const ref = item;
+                    out.push({
+                        id: String(ref.id),
+                        kind: ref.kind ?? "platform_item",
+                        uri: String(ref.uri),
+                        excerptHash: ref.excerptHash !== undefined ? String(ref.excerptHash) : undefined,
+                        observedAt: ref.observedAt !== undefined ? String(ref.observedAt) : observedAt,
+                    });
+                }
+            }
+            if (out.length > 0)
+                return out;
+        }
+        if (Array.isArray(record.items)) {
+            return record.items.map((item, index) => {
+                const id = item && typeof item === "object" && "id" in item
+                    ? String(item.id)
+                    : `${platformId}-item-${index}`;
+                return {
+                    id,
+                    kind: "platform_item",
+                    uri: `platform://${platformId}/item/${encodeURIComponent(id)}`,
+                    observedAt,
+                };
+            });
+        }
+    }
+    return [];
+}
+function resolveEvidenceType(intent) {
+    if (intent === "feed.read")
+        return "platform_browse";
+    if (intent === "work.discover")
+        return "task_discovery";
+    return null;
+}
+function resolveSensitivity(intent, explicit) {
+    if (explicit)
+        return explicit;
+    if (intent === "message.send" || intent === "comment.reply")
+        return "private";
+    return "public";
+}
+/**
+ * Produce a single life-evidence candidate from a connector outcome, or null if not mappable.
+ */
+export function mapLifeEvidence(input) {
+    if (input.result.status !== "success") {
+        return null;
+    }
+    if (input.intent === "message.send") {
+        return null;
+    }
+    const evidenceType = resolveEvidenceType(input.intent);
+    if (!evidenceType) {
+        return null;
+    }
+    const observedAt = input.observedAt ?? new Date().toISOString();
+    const refs = extractSourceRefs(input.platformId, input.result.data, observedAt);
+    if (refs.length === 0) {
+        return null;
+    }
+    return {
+        timestamp: observedAt,
+        evidenceType,
+        platformId: input.platformId,
+        summary: `${input.platformId}:${input.intent}`,
+        sourceRefs: refs,
+        sensitivity: resolveSensitivity(input.intent, input.sensitivityOverride),
+        producer: "connector-system",
+    };
+}

package/runtime/connectors/base/policy-layer.d.ts

@@ -1,29 +1,29 @@
-import { type FailureClass } from "./failure-taxonomy.js";
-import { type EffectCommitLedgerPort } from "./execution-policy.js";
-import type { CapabilityIntent, ConnectorRequest, ConnectorResult, ExecutionPlan, ExecutionRunner, RoutePlanner } from "./contract.js";
-import type { ExecutionTelemetry } from "../../observability/services/execution-telemetry.js";
-export interface RetryPolicy {
-    maxRetries: number;
-    baseDelayMs: number;
-    maxDelayMs: number;
-    jitter: boolean;
-}
-export interface CooldownPort {
-    isBlocked(platformId: string, intent: CapabilityIntent): Promise<{
-        blocked: boolean;
-        retryAfterMs?: number;
-    }>;
-    markFailure(platformId: string, intent: CapabilityIntent, failureClass: FailureClass, retryAfterMs?: number): Promise<void>;
-}
-export interface ConnectorPolicyContext {
-    routePlanner: RoutePlanner;
-    executionRunner: ExecutionRunner;
-    telemetry?: ExecutionTelemetry;
-    cooldownPort?: CooldownPort;
-    retryPolicy?: Partial<RetryPolicy>;
-    allowDegradedFallback?: (plan: ExecutionPlan, request: ConnectorRequest) => boolean;
-    effectCommitLedger?: EffectCommitLedgerPort;
-}
-export declare function createConnectorPolicyLayer(ctx: ConnectorPolicyContext): {
-    executeWithPolicy(intent: CapabilityIntent, request: ConnectorRequest): Promise<ConnectorResult<unknown>>;
-};
+import { type FailureClass } from "./failure-taxonomy.js";
+import { type EffectCommitLedgerPort } from "./execution-policy.js";
+import type { CapabilityIntent, ConnectorRequest, ConnectorResult, ExecutionPlan, ExecutionRunner, RoutePlanner } from "./contract.js";
+import type { ExecutionTelemetry } from "../../observability/services/execution-telemetry.js";
+export interface RetryPolicy {
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    jitter: boolean;
+}
+export interface CooldownPort {
+    isBlocked(platformId: string, intent: CapabilityIntent): Promise<{
+        blocked: boolean;
+        retryAfterMs?: number;
+    }>;
+    markFailure(platformId: string, intent: CapabilityIntent, failureClass: FailureClass, retryAfterMs?: number): Promise<void>;
+}
+export interface ConnectorPolicyContext {
+    routePlanner: RoutePlanner;
+    executionRunner: ExecutionRunner;
+    telemetry?: ExecutionTelemetry;
+    cooldownPort?: CooldownPort;
+    retryPolicy?: Partial<RetryPolicy>;
+    allowDegradedFallback?: (plan: ExecutionPlan, request: ConnectorRequest) => boolean;
+    effectCommitLedger?: EffectCommitLedgerPort;
+}
+export declare function createConnectorPolicyLayer(ctx: ConnectorPolicyContext): {
+    executeWithPolicy(intent: CapabilityIntent, request: ConnectorRequest): Promise<ConnectorResult<unknown>>;
+};