@skastr0/prism-linux-x64 0.4.6 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skastr0/prism-linux-x64",
-  "version": "0.4.6",
+  "version": "0.5.1",
   "type": "module",
   "description": "Prism standalone CLI binary for Linux x64.",
   "license": "MIT",
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.15.13",
-    "@skastr0/prism-sdk": "0.4.6",
+    "@skastr0/prism-sdk": "0.5.1",
     "effect": "^3.21.1",
     "typescript": "^5.8.3",
     "zod": "4.4.3"

package/types/compile/errors.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Typed compile errors for the structured compile-language pipeline.
+ *
+ * These tags are members of the `PrismError` union in src/errors.ts; the CLI
+ * edge renders them via `renderPrismError`/`renderPrismCause`. The canonical
+ * `PluginManifestError` lives in src/errors.ts (type-only import here keeps
+ * the modules cycle-free at runtime).
+ */
+import { Schema } from "effect";
+import type { PluginManifestError } from "../errors.js";
+declare const SourceParseError_base: Schema.TaggedErrorClass<SourceParseError, "SourceParseError", {
+    readonly _tag: Schema.tag<"SourceParseError">;
+} & {
+    sourcePath: typeof Schema.String;
+    kind: Schema.Literal<["identity", "personality", "agent", "modelspace", "skillspace", "sop", "tool", "hook"]>;
+    message: typeof Schema.String;
+}>;
+export declare class SourceParseError extends SourceParseError_base {
+}
+declare const UnknownReferenceError_base: Schema.TaggedErrorClass<UnknownReferenceError, "UnknownReferenceError", {
+    readonly _tag: Schema.tag<"UnknownReferenceError">;
+} & {
+    agentName: typeof Schema.String;
+    sourcePath: typeof Schema.String;
+    field: Schema.Literal<["identity", "personality", "model", "skill", "phase.agent"]>;
+    referenceName: typeof Schema.String;
+}>;
+export declare class UnknownReferenceError extends UnknownReferenceError_base {
+}
+declare const UnknownDependencyError_base: Schema.TaggedErrorClass<UnknownDependencyError, "UnknownDependencyError", {
+    readonly _tag: Schema.tag<"UnknownDependencyError">;
+} & {
+    sourcePath: typeof Schema.String;
+    referenceName: typeof Schema.String;
+    depPrefix: typeof Schema.String;
+    declaredDeps: Schema.Array$<typeof Schema.String>;
+}>;
+export declare class UnknownDependencyError extends UnknownDependencyError_base {
+}
+declare const DependencyCycleError_base: Schema.TaggedErrorClass<DependencyCycleError, "DependencyCycleError", {
+    readonly _tag: Schema.tag<"DependencyCycleError">;
+} & {
+    cycle: Schema.Array$<typeof Schema.String>;
+}>;
+export declare class DependencyCycleError extends DependencyCycleError_base {
+}
+declare const UnknownTargetError_base: Schema.TaggedErrorClass<UnknownTargetError, "UnknownTargetError", {
+    readonly _tag: Schema.tag<"UnknownTargetError">;
+} & {
+    target: typeof Schema.String;
+    supportedTargets: Schema.Array$<typeof Schema.String>;
+}>;
+export declare class UnknownTargetError extends UnknownTargetError_base {
+}
+declare const InvalidTargetScopeError_base: Schema.TaggedErrorClass<InvalidTargetScopeError, "InvalidTargetScopeError", {
+    readonly _tag: Schema.tag<"InvalidTargetScopeError">;
+} & {
+    target: typeof Schema.String;
+    scope: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+export declare class InvalidTargetScopeError extends InvalidTargetScopeError_base {
+}
+declare const UnsupportedTargetCapabilityError_base: Schema.TaggedErrorClass<UnsupportedTargetCapabilityError, "UnsupportedTargetCapabilityError", {
+    readonly _tag: Schema.tag<"UnsupportedTargetCapabilityError">;
+} & {
+    target: typeof Schema.String;
+    capability: Schema.Literal<["compiled-agents", "hooks"]>;
+    message: typeof Schema.String;
+}>;
+export declare class UnsupportedTargetCapabilityError extends UnsupportedTargetCapabilityError_base {
+}
+declare const AgentValidationError_base: Schema.TaggedErrorClass<AgentValidationError, "AgentValidationError", {
+    readonly _tag: Schema.tag<"AgentValidationError">;
+} & {
+    sourcePath: typeof Schema.String;
+    agentName: typeof Schema.String;
+    field: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+export declare class AgentValidationError extends AgentValidationError_base {
+}
+declare const DuplicateNameError_base: Schema.TaggedErrorClass<DuplicateNameError, "DuplicateNameError", {
+    readonly _tag: Schema.tag<"DuplicateNameError">;
+} & {
+    kind: Schema.Literal<["identity", "personality", "agent", "modelspace", "skillspace", "sop", "tool", "hook"]>;
+    name: typeof Schema.String;
+    firstPath: typeof Schema.String;
+    secondPath: typeof Schema.String;
+}>;
+export declare class DuplicateNameError extends DuplicateNameError_base {
+}
+declare const AgentNameMismatchError_base: Schema.TaggedErrorClass<AgentNameMismatchError, "AgentNameMismatchError", {
+    readonly _tag: Schema.tag<"AgentNameMismatchError">;
+} & {
+    sourcePath: typeof Schema.String;
+    fileStem: typeof Schema.String;
+    agentName: typeof Schema.String;
+}>;
+export declare class AgentNameMismatchError extends AgentNameMismatchError_base {
+}
+declare const MissingTargetResolutionError_base: Schema.TaggedErrorClass<MissingTargetResolutionError, "MissingTargetResolutionError", {
+    readonly _tag: Schema.tag<"MissingTargetResolutionError">;
+} & {
+    agentName: typeof Schema.String;
+    referenceKind: Schema.Literal<["model-profile", "skill"]>;
+    referenceName: typeof Schema.String;
+    target: typeof Schema.String;
+}>;
+export declare class MissingTargetResolutionError extends MissingTargetResolutionError_base {
+}
+export type CompileError = SourceParseError | UnknownReferenceError | AgentValidationError | UnknownTargetError | InvalidTargetScopeError | UnsupportedTargetCapabilityError | DuplicateNameError | AgentNameMismatchError | MissingTargetResolutionError | UnknownDependencyError | DependencyCycleError | PluginManifestError;
+export declare const formatCompileError: (error: CompileError) => string;
+export {};

package/types/errors.d.ts

@@ -0,0 +1,107 @@
+/**
+ * PrismError — the single tagged-error vocabulary that survives the
+ * one-writer overhaul (docs/overhaul-one-writer-plan.md, WS2).
+ *
+ * Every failure Prism shows a human goes through this module:
+ *   - one `PrismError` union the CLI edge can exhaustively match,
+ *   - `renderPrismError` / `renderPrismCause` as the only renderers
+ *     (one-line headline, optional indented detail, a `hint:` line),
+ *   - never a stack trace.
+ *
+ * Compile-language errors keep living in `src/compile/errors.ts` (they are
+ * constructed throughout the compile pipeline); this module absorbs them into
+ * the union instead of duplicating them. New error families added by later
+ * workstreams (SnapshotDecodeError, RegionPatchError, BlockedTargetError,
+ * TokenStoreError, …) join the union here.
+ */
+import { Schema } from "effect";
+import { type CompileError } from "./compile/errors.js";
+declare const PluginManifestError_base: Schema.TaggedErrorClass<PluginManifestError, "PluginManifestError", {
+    readonly _tag: Schema.tag<"PluginManifestError">;
+} & {
+    pluginPath: typeof Schema.String;
+    manifestPath: typeof Schema.String;
+    pluginLabel: typeof Schema.String;
+    summary: typeof Schema.String;
+    details: Schema.Array$<typeof Schema.String>;
+}>;
+export declare class PluginManifestError extends PluginManifestError_base {
+    /**
+     * Build a manifest error from just a plugin path + summary, deriving the
+     * manifest path and plugin label.
+     */
+    static forPlugin(pluginPath: string, summary: string, details?: ReadonlyArray<string>, options?: {
+        readonly pluginName?: string;
+    }): PluginManifestError;
+    get message(): string;
+}
+declare const PrismConfigError_base: Schema.TaggedErrorClass<PrismConfigError, "PrismConfigError", {
+    readonly _tag: Schema.tag<"PrismConfigError">;
+} & {
+    message: typeof Schema.String;
+}>;
+export declare class PrismConfigError extends PrismConfigError_base {
+}
+declare const BundleBuildError_base: Schema.TaggedErrorClass<BundleBuildError, "BundleBuildError", {
+    readonly _tag: Schema.tag<"BundleBuildError">;
+} & {
+    bundleKind: typeof Schema.String;
+    diagnostics: typeof Schema.String;
+}>;
+export declare class BundleBuildError extends BundleBuildError_base {
+    get message(): string;
+}
+declare const BlockedTargetError_base: Schema.TaggedErrorClass<BlockedTargetError, "BlockedTargetError", {
+    readonly _tag: Schema.tag<"BlockedTargetError">;
+} & {
+    targetPath: typeof Schema.String;
+    plugin: typeof Schema.String;
+    hint: typeof Schema.String;
+}>;
+export declare class BlockedTargetError extends BlockedTargetError_base {
+    get message(): string;
+}
+declare const PathConflictError_base: Schema.TaggedErrorClass<PathConflictError, "PathConflictError", {
+    readonly _tag: Schema.tag<"PathConflictError">;
+} & {
+    targetPath: typeof Schema.String;
+    firstPlugin: typeof Schema.String;
+    secondPlugin: typeof Schema.String;
+}>;
+export declare class PathConflictError extends PathConflictError_base {
+    get message(): string;
+}
+/**
+ * Every typed error Prism may surface to a human. `CompileError` (which
+ * includes `PluginManifestError`) is defined in src/compile/errors.ts.
+ */
+export type PrismError = CompileError | PrismConfigError | BundleBuildError | BlockedTargetError | PathConflictError;
+export declare const PRISM_ERROR_TAGS: ReadonlySet<string>;
+export declare const isPrismError: (value: unknown) => value is PrismError;
+export interface PrismErrorRender {
+    /** One line; never multi-line, never a stack frame. */
+    readonly headline: string;
+    /** Optional extra lines, rendered indented under the headline. */
+    readonly detail?: ReadonlyArray<string>;
+    /** Remediation; rendered as a trailing `hint: …` line. */
+    readonly hint: string;
+    /** Filesystem path the error is about, when it has one. */
+    readonly path?: string;
+}
+export declare const describePrismError: (error: PrismError) => PrismErrorRender;
+/** Render a PrismError for humans: headline, indented detail, hint line. */
+export declare const renderPrismError: (error: PrismError) => string;
+export interface PrismCauseDescription {
+    readonly headline: string;
+    readonly detail?: ReadonlyArray<string>;
+    readonly hint?: string;
+    readonly path?: string;
+}
+/**
+ * Walk an Effect Cause (or any thrown value) and describe the first Prism
+ * error found. Unknown defects render name + message only — never `.stack`.
+ */
+export declare const describePrismCause: (cause: unknown) => PrismCauseDescription;
+/** Render a whole Cause for humans. The single edge renderer. */
+export declare const renderPrismCause: (cause: unknown) => string;
+export {};

package/types/harness-types-discover.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Fail-soft discovery of installed workflow-harness models.
+ * Cache reads and CLI lists never throw; empty means "leave this worker as string".
+ */
+import { type DiscoveredHarnessModels, type HarnessModelOption, type RefreshHarnessTypesResult } from "./harness-types.js";
+export type HarnessTypesReadText = (path: string) => string | undefined;
+export type HarnessTypesCommandRunner = (command: string, args: readonly string[]) => Promise<string>;
+export interface DiscoverHarnessTypesOptions {
+    readonly home?: string;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly readText?: HarnessTypesReadText;
+    readonly runCommand?: HarnessTypesCommandRunner;
+}
+export declare const parseClaudeModelCache: (raw: string) => {
+    readonly models: HarnessModelOption[];
+    readonly error?: string;
+};
+export declare const readClaudeModels: (home: string, readText: HarnessTypesReadText) => DiscoveredHarnessModels;
+export declare const parseCodexDebugModels: (stdout: string) => {
+    readonly models: HarnessModelOption[];
+    readonly error?: string;
+};
+export declare const parseGrokModelsCache: (raw: string) => {
+    readonly models: HarnessModelOption[];
+    readonly error?: string;
+};
+export declare const parseGrokModelsCli: (stdout: string) => HarnessModelOption[];
+export declare const parseHermesProviderModelsCache: (raw: string) => {
+    readonly models: HarnessModelOption[];
+    readonly error?: string;
+};
+export declare const parseOpenCodeModels: (stdout: string) => HarnessModelOption[];
+export declare const parseCursorModelsList: (stdout: string) => {
+    readonly models: HarnessModelOption[];
+    readonly error?: string;
+};
+export declare const parseAgyModelsList: (stdout: string) => {
+    readonly models: HarnessModelOption[];
+    readonly error?: string;
+};
+export declare const parseDevinModelsList: (stdout: string) => {
+    readonly models: HarnessModelOption[];
+    readonly error?: string;
+};
+/** Canonical OMP `--model` pin is `selector` (`provider/id`). */
+export declare const parseOmpModelsJson: (raw: string) => {
+    readonly models: HarnessModelOption[];
+    readonly error?: string;
+};
+/** `modelRoles.default` from ~/.omp/agent/config.yml, without a trailing :thinking suffix. */
+export declare const parseOmpConfigDefaultModel: (raw: string) => string | undefined;
+export declare const readOmpConfigDefaultModel: (home: string, readText?: HarnessTypesReadText) => string | undefined;
+export declare const parseKimiProviderList: (stdout: string) => HarnessModelOption[];
+/** Built-in `--mode` dial from `amp --help` (`low, medium, high, ultra, or a plugin mode…`). */
+export declare const parseAmpModeHelp: (stdout: string) => HarnessModelOption[];
+/** Plugin-registered `--mode` keys from `amp plugins list` (`agent mode: grok45`). */
+export declare const parseAmpPluginListModes: (stdout: string) => HarnessModelOption[];
+/** Curated `provider/model` catalog from `amp plugins show-agent-options --json`. */
+export declare const parseAmpAgentOptions: (raw: string) => {
+    readonly models: HarnessModelOption[];
+    readonly error?: string;
+};
+export declare const discoverWorkflowHarnessModels: (options?: DiscoverHarnessTypesOptions) => Promise<readonly DiscoveredHarnessModels[]>;
+export declare const refreshHarnessTypes: (prismHome: string, options?: DiscoverHarnessTypesOptions) => Promise<RefreshHarnessTypesResult>;
+export declare const renderHarnessTypesRefreshHuman: (result: RefreshHarnessTypesResult) => string;

package/types/harness-types.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Global (machine-wide) harness model types for plugin-free workflow authoring.
+ *
+ * Written by `prism workflow refresh-harness-types` to
+ * `<PRISM_HOME>/state/harness-types/`. Not project-keyed — harnesses are
+ * installed on the machine, not per repo.
+ */
+import type { WorkflowWorkerId } from "./workflows.js";
+export declare const HARNESS_TYPES_DIRNAME = "harness-types";
+export declare const HARNESS_MODELS_FILENAME = "harness-models.ts";
+export declare const HARNESS_DISCOVERED_FILENAME = "discovered.json";
+export declare const harnessTypesDir: (prismHome: string) => string;
+export declare const harnessModelsModulePath: (prismHome: string) => string;
+export declare const harnessDiscoveredPath: (prismHome: string) => string;
+export declare const harnessTypesExist: (prismHome: string) => boolean;
+export type HarnessModelSource = "cache" | "aliases" | "command" | "static" | "empty";
+export interface HarnessModelOption {
+    readonly id: string;
+    readonly label?: string;
+    readonly efforts?: readonly string[];
+    readonly provider?: string;
+    /** Amp: dial / plugin-mode / curated model. Other harnesses omit this. */
+    readonly kind?: "dial" | "plugin-mode" | "model";
+}
+export interface DiscoveredHarnessModels {
+    readonly harness: WorkflowWorkerId;
+    readonly models: readonly HarnessModelOption[];
+    readonly source: HarnessModelSource;
+    readonly error?: string;
+}
+export interface HarnessTypesSnapshot {
+    readonly generatedAt: string;
+    readonly harnesses: readonly DiscoveredHarnessModels[];
+}
+export interface RefreshHarnessTypesResult {
+    readonly modelsPath: string;
+    readonly discoveredPath: string;
+    readonly snapshot: HarnessTypesSnapshot;
+}
+/**
+ * Render the generated `prism/harnesses` module. A worker appears only
+ * when discovery returned at least one model id.
+ */
+export declare const renderHarnessModelsModule: (snapshot: HarnessTypesSnapshot) => string;
+export declare const writeHarnessTypesSnapshot: (prismHome: string, snapshot: HarnessTypesSnapshot) => RefreshHarnessTypesResult;