feat: implement Phase 1 progressive-disclosure codegen pipeline

Implement the core mylangiser functionality: manifest parsing for API
endpoints, weighted complexity scoring (param count, optional ratio,
type complexity, required count), disclosure level assignment
(beginner/intermediate/expert), and layered wrapper code generation
with smart defaults for omitted parameters.

- manifest/mod.rs: Rewritten for endpoint-based API manifest schema
- codegen/parser.rs: Parse param definitions with types and optionality
- codegen/scorer.rs: Weighted 0-100 complexity scoring algorithm
- codegen/layer_gen.rs: Generate beginner/intermediate/expert wrappers
- abi/mod.rs: DisclosureLevel, ComplexityScore, APIEndpoint, SmartDefault, LayeredWrapper
- tests/integration_test.rs: 8 integration tests covering full pipeline
- examples/simplified-api/mylangiser.toml: Example manifest

48 tests passing (20 unit lib + 20 unit bin + 8 integration).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

Cargo.lock

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+# mylangiser manifest — progressive-disclosure interface for a user management API.
+#
+# This example demonstrates how mylangiser analyses endpoint complexity and
+# generates layered wrappers:
+#   - Beginner:      create_user(username, email) — 2 required params, smart defaults
+#   - Intermediate:  create_user(username, email, role?, mfa?, locale?) — adds common optionals
+#   - Expert:        create_user(username, email, role?, permissions?, mfa?, locale?) — full API
+
+[project]
+name = "simplified-api"
+description = "Progressive-disclosure wrapper for a user management and search API"
+
+[[endpoints]]
+name = "create_user"
+description = "Create a new user account with progressive parameter disclosure"
+params = [
+    "username: string",
+    "email: string",
+    "role?: string",
+    "permissions?: list",
+    "mfa?: bool",
+    "locale?: string",
+]
+required = ["username", "email"]
+
+[[endpoints]]
+name = "search"
+description = "Search with progressive filter disclosure"
+params = [
+    "query: string",
+    "filters?: map",
+    "sort?: string",
+    "page?: int",
+    "limit?: int",
+    "cursor?: string",
+    "facets?: list",
+]
+required = ["query"]
+
+[[endpoints]]
+name = "get_user"
+description = "Simple user lookup — always beginner-level"
+params = [
+    "user_id: string",
+]
+required = ["user_id"]
+
+[levels]
+beginner-threshold = 30
+expert-threshold = 70
+
+[defaults]
+role = "user"
+limit = 20
+page = 1
+locale = "en-GB"

examples/simplified-api/mylangiser.toml

@@ -1,3 +1,127 @@
 // SPDX-License-Identifier: PMPL-1.0-or-later
 // Copyright (c) 2026 Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
-// ABI module for mylangiser — Idris2 proof types for My-Lang interface correctness.
+//
+// ABI module for mylangiser — core types representing the progressive-disclosure
+// interface model. These types mirror the Idris2 formal proofs in src/interface/abi/
+// and provide the Rust-side representations used throughout the codegen pipeline.
+//
+// The Idris2 ABI (Types.idr, Layout.idr, Foreign.idr) provides formal verification
+// of these type relationships; this module is the Rust counterpart used at runtime.
+
+use serde::{Deserialize, Serialize};
+
+/// Disclosure level for a function/endpoint, determined by its complexity score.
+///
+/// - `Beginner`: Simple functions with few required params (score 0-30).
+///   Only required parameters are exposed; all optionals get smart defaults.
+/// - `Intermediate`: Moderate complexity (score 30-70). Required params plus
+///   commonly-used optional params (scalar types, those with known defaults).
+/// - `Expert`: Full API surface (score 70-100). Every parameter exposed,
+///   no smart defaults applied.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum DisclosureLevel {
+    /// Simplified view: required params only, smart defaults for the rest.
+    Beginner,
+    /// Balanced view: required + commonly-used optional params.
+    Intermediate,
+    /// Full view: all parameters exposed, no defaults applied.
+    Expert,
+}
+
+/// A complexity score in the range 0-100, representing how complex an
+/// API endpoint is. The score is calculated from weighted factors:
+/// parameter count, optional ratio, type complexity, and required count.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ComplexityScore {
+    /// The numeric complexity value (0 = trivial, 100 = maximally complex).
+    pub value: u32,
+}
+
+impl ComplexityScore {
+    /// Create a new complexity score, clamping to the valid 0-100 range.
+    pub fn new(value: u32) -> Self {
+        Self {
+            value: value.min(100),
+        }
+    }
+}
+
+impl std::fmt::Display for ComplexityScore {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}/100", self.value)
+    }
+}
+
+/// An API endpoint with its parsed metadata, complexity score, and
+/// assigned disclosure level.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct APIEndpoint {
+    /// The endpoint/function name.
+    pub name: String,
+    /// Total number of parameters.
+    pub param_count: usize,
+    /// Number of required parameters.
+    pub required_count: usize,
+    /// Number of optional parameters.
+    pub optional_count: usize,
+    /// Calculated complexity score.
+    pub complexity: ComplexityScore,
+    /// Assigned disclosure level based on complexity thresholds.
+    pub level: DisclosureLevel,
+}
+
+/// A smart default value applied to an optional parameter when it is
+/// omitted at lower disclosure levels. The parameter name maps to the
+/// default value (as a string representation).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SmartDefault {
+    /// The parameter name this default applies to.
+    pub param_name: String,
+    /// The default value as a display string (e.g., `"user"`, `20`, `true`).
+    pub default_value: String,
+}
+
+/// A layered wrapper for a single endpoint, containing the function
+/// signatures and generated code for each disclosure level.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LayeredWrapper {
+    /// The original endpoint name.
+    pub endpoint_name: String,
+    /// Beginner-level parameter list (required params only).
+    pub beginner_signature: Vec<String>,
+    /// Intermediate-level parameter list (required + common optional).
+    pub intermediate_signature: Vec<String>,
+    /// Expert-level parameter list (all params).
+    pub expert_signature: Vec<String>,
+    /// Smart defaults applied at beginner/intermediate levels.
+    pub smart_defaults: Vec<SmartDefault>,
+    /// Generated wrapper code for beginner level.
+    pub beginner_code: String,
+    /// Generated wrapper code for intermediate level.
+    pub intermediate_code: String,
+    /// Generated wrapper code for expert level.
+    pub expert_code: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_complexity_score_clamped() {
+        let score = ComplexityScore::new(150);
+        assert_eq!(score.value, 100);
+    }
+
+    #[test]
+    fn test_complexity_score_display() {
+        let score = ComplexityScore::new(42);
+        assert_eq!(format!("{}", score), "42/100");
+    }
+
+    #[test]
+    fn test_disclosure_level_equality() {
+        assert_eq!(DisclosureLevel::Beginner, DisclosureLevel::Beginner);
+        assert_ne!(DisclosureLevel::Beginner, DisclosureLevel::Expert);
+    }
+}