autotype 0.1.0

data/native/autotype/src/solver.c

@@ -0,0 +1,296 @@
+#include "../include/stc.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+stc_solver *stc_solver_new(void) {
+  stc_solver *solver = calloc(1, sizeof(stc_solver));
+  return solver;
+}
+
+static void stc_free_capabilities(stc_capability *caps, size_t count) {
+  if (!caps) return;
+  for (size_t c = 0; c < count; c++) {
+    free(caps[c].args);
+  }
+  free(caps);
+}
+
+void stc_solver_free(stc_solver *solver) {
+  if (!solver) return;
+  for (size_t m = 0; m < solver->method_count; m++) {
+    stc_free_capabilities(solver->methods[m].capabilities, solver->methods[m].capability_count);
+  }
+  free(solver->methods);
+  free(solver->vars);
+  free(solver->subs);
+  if (solver->type_pool) {
+    for (size_t i = 0; i < solver->type_pool_count; i++) {
+      stc_type *type = solver->type_pool[i];
+      if (type->kind == STC_TY_GENERIC) free(type->as.generic.args);
+      if (type->kind == STC_TY_UNION) free(type->as.union_.members);
+      free(type);
+    }
+    free(solver->type_pool);
+  }
+  free(solver);
+}
+
+void stc_solver_load_flat(stc_solver *solver, stc_capability *capabilities, size_t capability_count) {
+  stc_method *method = calloc(1, sizeof(stc_method));
+  if (!method) return;
+  strncpy(method->name, "flat", STC_MAX_NAME - 1);
+  method->capabilities = capabilities;
+  method->capability_count = capability_count;
+  solver->methods = method;
+  solver->method_count = 1;
+}
+
+static bool stc_is_array(stc_solver *solver, stc_type *type) {
+  type = stc_dereference(solver, type);
+  return type && type->kind == STC_TY_GENERIC && strcmp(type->as.generic.name, "Array") == 0;
+}
+
+static bool stc_is_hash(stc_solver *solver, stc_type *type) {
+  type = stc_dereference(solver, type);
+  return type && type->kind == STC_TY_GENERIC && strcmp(type->as.generic.name, "Hash") == 0 &&
+         type->as.generic.arg_count == 2;
+}
+
+static bool stc_is_string(stc_solver *solver, stc_type *type) {
+  type = stc_dereference(solver, type);
+  return type && type->kind == STC_TY_NAMED && strcmp(type->as.named.name, "String") == 0;
+}
+
+static stc_type *stc_array_element(stc_solver *solver, stc_type *type) {
+  type = stc_dereference(solver, type);
+  if (!stc_is_array(solver, type)) return NULL;
+  return type->as.generic.args[0];
+}
+
+static stc_type *stc_enumerable_element(stc_solver *solver, stc_type *type) {
+  type = stc_dereference(solver, type);
+  if (!type) return NULL;
+  if (stc_is_array(solver, type)) return stc_array_element(solver, type);
+  if (stc_is_hash(solver, type)) return type->as.generic.args[1];
+  return NULL;
+}
+
+static stc_type *stc_nil(stc_solver *solver) {
+  return stc_type_named(solver, "nil");
+}
+
+static stc_type *stc_nullable(stc_solver *solver, stc_type *type) {
+  stc_type *nil = stc_nil(solver);
+  stc_type *members[] = { type, nil };
+  return stc_type_union(solver, members, 2);
+}
+
+static void stc_unify_array_elements(stc_solver *solver, stc_type *receiver, stc_type *argument) {
+  stc_type *element = stc_array_element(solver, receiver);
+  if (element) stc_unify(solver, element, argument);
+}
+
+void stc_apply_builtin(stc_solver *solver, stc_capability *capability) {
+  stc_type *receiver = stc_dereference(solver, capability->receiver);
+  stc_type *result = capability->result;
+  const char *message = capability->message;
+
+  if (strcmp(message, "to_s") == 0 || strcmp(message, "inspect") == 0 || strcmp(message, "String") == 0) {
+    stc_unify(solver, result, stc_type_named(solver, "String"));
+    return;
+  }
+  if (strcmp(message, "to_i") == 0 || strcmp(message, "ord") == 0 || strcmp(message, "Integer") == 0 ||
+      strcmp(message, "size") == 0 || strcmp(message, "length") == 0 || strcmp(message, "count") == 0) {
+    stc_unify(solver, result, stc_type_named(solver, "Integer"));
+    return;
+  }
+  if (strcmp(message, "to_f") == 0 || strcmp(message, "Float") == 0 || strcmp(message, "clock_gettime") == 0) {
+    stc_unify(solver, result, stc_type_named(solver, "Float"));
+    return;
+  }
+  if (strcmp(message, "to_sym") == 0) {
+    stc_unify(solver, result, stc_type_named(solver, "Symbol"));
+    return;
+  }
+  if (strcmp(message, "!") == 0 || strcmp(message, "present?") == 0 || strcmp(message, "blank?") == 0 ||
+      strcmp(message, "nil?") == 0 || strcmp(message, "empty?") == 0 || strcmp(message, "any?") == 0 ||
+      strcmp(message, "all?") == 0 || strcmp(message, "none?") == 0 || strcmp(message, "include?") == 0 ||
+      strcmp(message, "key?") == 0 || strcmp(message, "has_key?") == 0) {
+    stc_unify(solver, result, stc_type_named(solver, "bool"));
+    return;
+  }
+  if (strcmp(message, "puts") == 0 || strcmp(message, "print") == 0 || strcmp(message, "p") == 0) {
+    stc_unify(solver, result, stc_nil(solver));
+    return;
+  }
+  if (strcmp(message, "tap") == 0 || strcmp(message, "itself") == 0 || strcmp(message, "deep_dup") == 0 ||
+      strcmp(message, "dup") == 0 || strcmp(message, "clone") == 0 || strcmp(message, "freeze") == 0 ||
+      strcmp(message, "with") == 0) {
+    stc_unify(solver, result, receiver);
+    return;
+  }
+  if (strcmp(message, "presence") == 0) {
+    stc_unify(solver, result, stc_nullable(solver, receiver));
+    return;
+  }
+  if (strcmp(message, "[]") == 0) {
+    if (stc_is_hash(solver, receiver) && capability->arg_count >= 1) {
+      stc_type *value = receiver->as.generic.args[1];
+      stc_unify(solver, result, stc_nullable(solver, value));
+      return;
+    }
+    if (stc_is_array(solver, receiver) && capability->arg_count >= 1) {
+      stc_type *element = stc_array_element(solver, receiver);
+      if (element) stc_unify(solver, result, stc_nullable(solver, element));
+      return;
+    }
+  }
+  if ((strcmp(message, "<<") == 0 || strcmp(message, "push") == 0 || strcmp(message, "append") == 0 ||
+       strcmp(message, "unshift") == 0 || strcmp(message, "prepend") == 0) &&
+      stc_is_array(solver, receiver)) {
+    for (size_t i = 0; i < capability->arg_count; i++) {
+      stc_unify_array_elements(solver, receiver, capability->args[i]);
+    }
+    stc_unify(solver, result, receiver);
+    return;
+  }
+  if (strcmp(message, "<<") == 0 && stc_is_string(solver, receiver)) {
+    stc_unify(solver, result, receiver);
+    return;
+  }
+  if (strcmp(message, "concat") == 0) {
+    if (stc_is_array(solver, receiver)) {
+      for (size_t i = 0; i < capability->arg_count; i++) {
+        stc_unify(solver, receiver, capability->args[i]);
+      }
+      stc_unify(solver, result, receiver);
+      return;
+    }
+    if (stc_is_string(solver, receiver)) {
+      stc_unify(solver, result, receiver);
+      return;
+    }
+  }
+  if (strcmp(message, "keys") == 0 && stc_is_hash(solver, receiver)) {
+    stc_type *args[] = { receiver->as.generic.args[0] };
+    stc_unify(solver, result, stc_type_generic(solver, "Array", args, 1));
+    return;
+  }
+  if (strcmp(message, "values") == 0 && stc_is_hash(solver, receiver)) {
+    stc_type *args[] = { receiver->as.generic.args[1] };
+    stc_unify(solver, result, stc_type_generic(solver, "Array", args, 1));
+    return;
+  }
+  if (strcmp(message, "sort") == 0 || strcmp(message, "sort_by") == 0 || strcmp(message, "reverse") == 0 ||
+      strcmp(message, "take") == 0 || strcmp(message, "drop") == 0 || strcmp(message, "uniq") == 0 ||
+      strcmp(message, "shuffle") == 0 || strcmp(message, "rotate") == 0 || strcmp(message, "to_a") == 0 ||
+      strcmp(message, "each") == 0 || strcmp(message, "each_value") == 0 || strcmp(message, "each_key") == 0 ||
+      strcmp(message, "each_pair") == 0) {
+    if (stc_is_array(solver, receiver) || stc_is_hash(solver, receiver)) {
+      stc_unify(solver, result, receiver);
+      return;
+    }
+  }
+  if ((strcmp(message, "merge") == 0 || strcmp(message, "merge!") == 0 || strcmp(message, "except") == 0 ||
+       strcmp(message, "slice") == 0 || strcmp(message, "deep_symbolize_keys") == 0 ||
+       strcmp(message, "symbolize_keys") == 0 || strcmp(message, "with_indifferent_access") == 0) &&
+      stc_is_hash(solver, receiver)) {
+    stc_unify(solver, result, receiver);
+    return;
+  }
+  if (strcmp(message, "deep_stringify_keys") == 0 || strcmp(message, "stringify_keys") == 0) {
+    if (stc_is_hash(solver, receiver)) {
+      stc_type *args[] = { stc_type_named(solver, "String"), receiver->as.generic.args[1] };
+      stc_unify(solver, result, stc_type_generic(solver, "Hash", args, 2));
+      return;
+    }
+  }
+  if (strcmp(message, "to_h") == 0 || strcmp(message, "to_hash") == 0) {
+    if (stc_is_hash(solver, receiver)) {
+      stc_unify(solver, result, receiver);
+      return;
+    }
+  }
+  if (strcmp(message, "flatten") == 0 && stc_is_array(solver, receiver)) {
+    stc_type *element = stc_array_element(solver, receiver);
+    if (element) {
+      stc_type *inner = stc_array_element(solver, element);
+      stc_type *flat = inner ? inner : element;
+      stc_type *args[] = { flat };
+      stc_unify(solver, result, stc_type_generic(solver, "Array", args, 1));
+    }
+    return;
+  }
+  if ((strcmp(message, "first") == 0 || strcmp(message, "last") == 0 || strcmp(message, "min") == 0 ||
+       strcmp(message, "max") == 0 || strcmp(message, "find") == 0 || strcmp(message, "detect") == 0 ||
+       strcmp(message, "sample") == 0)) {
+    stc_type *element = stc_enumerable_element(solver, receiver);
+    if (element) stc_unify(solver, result, stc_nullable(solver, element));
+    return;
+  }
+  if (strcmp(message, "delete") == 0 && stc_is_hash(solver, receiver) && capability->arg_count >= 1) {
+    stc_type *value = receiver->as.generic.args[1];
+    stc_unify(solver, result, stc_nullable(solver, value));
+    return;
+  }
+  if (strcmp(message, "fetch") == 0 && stc_is_hash(solver, receiver)) {
+    stc_type *value = receiver->as.generic.args[1];
+    stc_unify(solver, result, value);
+    return;
+  }
+  if (strcmp(message, "dig") == 0 && stc_is_hash(solver, receiver)) {
+    stc_unify(solver, result, stc_type_named(solver, "Object"));
+    return;
+  }
+  if (strcmp(message, "join") == 0 && stc_is_array(solver, receiver)) {
+    stc_unify(solver, result, stc_type_named(solver, "String"));
+    return;
+  }
+  if (strcmp(message, "split") == 0 && stc_is_string(solver, receiver)) {
+    stc_type *args[] = { stc_type_named(solver, "String") };
+    stc_unify(solver, result, stc_type_generic(solver, "Array", args, 1));
+    return;
+  }
+  if (strcmp(message, "strip") == 0 || strcmp(message, "downcase") == 0 || strcmp(message, "upcase") == 0 ||
+      strcmp(message, "capitalize") == 0 || strcmp(message, "squeeze") == 0) {
+    if (stc_is_string(solver, receiver)) {
+      stc_unify(solver, result, receiver);
+      return;
+    }
+  }
+  if ((strcmp(message, "+") == 0 || strcmp(message, "-") == 0 || strcmp(message, "*") == 0 ||
+       strcmp(message, "/") == 0 || strcmp(message, "%") == 0) &&
+      receiver && receiver->kind == STC_TY_NAMED) {
+    const char *name = receiver->as.named.name;
+    if (strcmp(name, "Integer") == 0 || strcmp(name, "Float") == 0 || strcmp(name, "String") == 0) {
+      stc_unify(solver, result, receiver);
+      return;
+    }
+  }
+  if ((strcmp(message, "+") == 0 || strcmp(message, "-") == 0) && stc_is_array(solver, receiver)) {
+    stc_unify(solver, result, receiver);
+  }
+}
+
+void stc_solve_to_fixed_point(stc_solver *solver) {
+  for (int iteration = 0; iteration < STC_MAX_ITERATIONS; iteration++) {
+    solver->changed = 0;
+    for (size_t m = 0; m < solver->method_count; m++) {
+      stc_method *method = &solver->methods[m];
+      for (size_t c = 0; c < method->capability_count; c++) {
+        stc_apply_builtin(solver, &method->capabilities[c]);
+      }
+    }
+    solver->iterations = iteration + 1;
+    if (!solver->changed) {
+      solver->converged = 1;
+      break;
+    }
+  }
+}
+
+int stc_solver_run(stc_solver *solver) {
+  stc_solve_to_fixed_point(solver);
+  return solver->converged;
+}

data/native/autotype/src/type.c

@@ -0,0 +1,223 @@
+#include "../include/stc.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+static stc_type *stc_alloc_type(stc_solver *solver) {
+  stc_type *type = calloc(1, sizeof(stc_type));
+  if (!type) return NULL;
+
+  if (solver->type_pool_count >= solver->type_pool_cap) {
+    size_t new_cap = solver->type_pool_cap == 0 ? 256 : solver->type_pool_cap * 2;
+    stc_type **new_pool = realloc(solver->type_pool, new_cap * sizeof(stc_type *));
+    if (!new_pool) {
+      free(type);
+      return NULL;
+    }
+    solver->type_pool = new_pool;
+    solver->type_pool_cap = new_cap;
+  }
+
+  solver->type_pool[solver->type_pool_count++] = type;
+  return type;
+}
+
+stc_type *stc_type_named(stc_solver *solver, const char *name) {
+  stc_type *type = stc_alloc_type(solver);
+  if (!type) return NULL;
+  type->kind = STC_TY_NAMED;
+  strncpy(type->as.named.name, name, STC_MAX_NAME - 1);
+  return type;
+}
+
+stc_type *stc_type_var(stc_solver *solver, stc_var_id id, const char *hint) {
+  stc_type *type = stc_alloc_type(solver);
+  if (!type) return NULL;
+  type->kind = STC_TY_VAR;
+  type->as.var.id = id;
+  if (hint) strncpy(type->as.var.hint, hint, sizeof(type->as.var.hint) - 1);
+  return type;
+}
+
+stc_type *stc_type_generic(stc_solver *solver, const char *name, stc_type **args, size_t arg_count) {
+  stc_type *type = stc_alloc_type(solver);
+  if (!type) return NULL;
+  stc_type **owned_args = NULL;
+  if (arg_count > 0) {
+    owned_args = calloc(arg_count, sizeof(stc_type *));
+    if (!owned_args) return NULL;
+    memcpy(owned_args, args, arg_count * sizeof(stc_type *));
+  }
+  type->kind = STC_TY_GENERIC;
+  strncpy(type->as.generic.name, name, sizeof(type->as.generic.name) - 1);
+  type->as.generic.args = owned_args;
+  type->as.generic.arg_count = arg_count;
+  return type;
+}
+
+stc_type *stc_type_union(stc_solver *solver, stc_type **members, size_t member_count) {
+  stc_type *type = stc_alloc_type(solver);
+  if (!type) return NULL;
+  stc_type **owned_members = NULL;
+  if (member_count > 0) {
+    owned_members = calloc(member_count, sizeof(stc_type *));
+    if (!owned_members) return NULL;
+    memcpy(owned_members, members, member_count * sizeof(stc_type *));
+  }
+  type->kind = STC_TY_UNION;
+  type->as.union_.members = owned_members;
+  type->as.union_.member_count = member_count;
+  return type;
+}
+
+static stc_type *stc_find_sub(stc_solver *solver, stc_var_id var_id) {
+  for (size_t i = 0; i < solver->sub_count; i++) {
+    if (solver->subs[i].var_id == var_id) return solver->subs[i].type;
+  }
+  return NULL;
+}
+
+stc_type *stc_dereference(stc_solver *solver, stc_type *type) {
+  stc_var_id seen[64];
+  size_t seen_count = 0;
+
+  while (type && type->kind == STC_TY_VAR) {
+    for (size_t i = 0; i < seen_count; i++) {
+      if (seen[i] == type->as.var.id) return type;
+    }
+    if (seen_count < 64) seen[seen_count++] = type->as.var.id;
+
+    stc_type *next = stc_find_sub(solver, type->as.var.id);
+    if (!next) break;
+    type = next;
+  }
+  return type;
+}
+
+static bool stc_same_type(stc_type *left, stc_type *right) {
+  if (!left || !right) return left == right;
+  if (left->kind != right->kind) return false;
+  switch (left->kind) {
+    case STC_TY_NAMED:
+      return strcmp(left->as.named.name, right->as.named.name) == 0;
+    case STC_TY_VAR:
+      return left->as.var.id == right->as.var.id;
+    case STC_TY_GENERIC:
+      if (strcmp(left->as.generic.name, right->as.generic.name) != 0) return false;
+      if (left->as.generic.arg_count != right->as.generic.arg_count) return false;
+      for (size_t i = 0; i < left->as.generic.arg_count; i++) {
+        if (!stc_same_type(left->as.generic.args[i], right->as.generic.args[i])) return false;
+      }
+      return true;
+    case STC_TY_UNION:
+      if (left->as.union_.member_count != right->as.union_.member_count) return false;
+      for (size_t i = 0; i < left->as.union_.member_count; i++) {
+        if (!stc_same_type(left->as.union_.members[i], right->as.union_.members[i])) return false;
+      }
+      return true;
+    default:
+      return false;
+  }
+}
+
+static stc_type *stc_resolve_inner(stc_solver *solver, stc_type *type, stc_var_id *seen, size_t *seen_count, int depth);
+
+stc_type *stc_resolve(stc_solver *solver, stc_type *type) {
+  stc_var_id seen[64];
+  size_t seen_count = 0;
+  return stc_resolve_inner(solver, type, seen, &seen_count, 0);
+}
+
+static stc_type *stc_resolve_inner(stc_solver *solver, stc_type *type, stc_var_id *seen, size_t *seen_count, int depth) {
+  if (!type || depth > 24) return type;
+
+  if (type->kind == STC_TY_VAR) {
+    for (size_t i = 0; i < *seen_count; i++) {
+      if (seen[i] == type->as.var.id) return type;
+    }
+    if (*seen_count < 64) seen[(*seen_count)++] = type->as.var.id;
+  }
+
+  type = stc_dereference(solver, type);
+  if (!type) return NULL;
+
+  if (type->kind == STC_TY_GENERIC) {
+    stc_type **args = calloc(type->as.generic.arg_count, sizeof(stc_type *));
+    if (!args) return type;
+    for (size_t i = 0; i < type->as.generic.arg_count; i++) {
+      args[i] = stc_resolve_inner(solver, type->as.generic.args[i], seen, seen_count, depth + 1);
+    }
+    return stc_type_generic(solver, type->as.generic.name, args, type->as.generic.arg_count);
+  }
+
+  if (type->kind == STC_TY_UNION) {
+    stc_type **members = calloc(type->as.union_.member_count, sizeof(stc_type *));
+    if (!members) return type;
+    size_t out = 0;
+    for (size_t i = 0; i < type->as.union_.member_count; i++) {
+      stc_type *resolved = stc_resolve_inner(solver, type->as.union_.members[i], seen, seen_count, depth + 1);
+      if (!resolved) continue;
+      bool dup = false;
+      for (size_t j = 0; j < out; j++) {
+        if (stc_same_type(members[j], resolved)) { dup = true; break; }
+      }
+      if (!dup) members[out++] = resolved;
+    }
+    if (out == 0) return type;
+    if (out == 1) return members[0];
+    return stc_type_union(solver, members, out);
+  }
+
+  return type;
+}
+
+void stc_bind(stc_solver *solver, stc_var_id var_id, stc_type *type) {
+  stc_type *existing = stc_find_sub(solver, var_id);
+  if (existing && stc_same_type(existing, type)) return;
+
+  if (solver->sub_count >= solver->sub_cap) {
+    size_t new_cap = solver->sub_cap == 0 ? 256 : solver->sub_cap * 2;
+    stc_substitution *new_subs = realloc(solver->subs, new_cap * sizeof(stc_substitution));
+    if (!new_subs) return;
+    solver->subs = new_subs;
+    solver->sub_cap = new_cap;
+  }
+
+  /* Update in place if already bound. */
+  for (size_t i = 0; i < solver->sub_count; i++) {
+    if (solver->subs[i].var_id == var_id) {
+      solver->subs[i].type = type;
+      solver->changed = 1;
+      return;
+    }
+  }
+
+  solver->subs[solver->sub_count].var_id = var_id;
+  solver->subs[solver->sub_count].type = type;
+  solver->sub_count++;
+  if (type->kind != STC_TY_VAR) solver->changed = 1;
+}
+
+void stc_unify(stc_solver *solver, stc_type *left, stc_type *right) {
+  if (!left || !right) return;
+  left = stc_dereference(solver, left);
+  right = stc_dereference(solver, right);
+  if (stc_same_type(left, right)) return;
+
+  if (left->kind == STC_TY_VAR) {
+    stc_bind(solver, left->as.var.id, right);
+    return;
+  }
+  if (right->kind == STC_TY_VAR) {
+    stc_bind(solver, right->as.var.id, left);
+    return;
+  }
+
+  if (left->kind == STC_TY_GENERIC && right->kind == STC_TY_GENERIC &&
+      strcmp(left->as.generic.name, right->as.generic.name) == 0 &&
+      left->as.generic.arg_count == right->as.generic.arg_count) {
+    for (size_t i = 0; i < left->as.generic.arg_count; i++) {
+      stc_unify(solver, left->as.generic.args[i], right->as.generic.args[i]);
+    }
+  }
+}

data/spec/autotype_config_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "fileutils"
+
+RSpec.describe Autotype::TypeString do
+  it "parses named types" do
+    expect(described_class.parse("String")).to eq(Autotype::Named.new("String"))
+  end
+
+  it "parses generic types" do
+    type = described_class.parse("Array[String]")
+    expect(type).to eq(Autotype::Generic.new("Array", [Autotype::Named.new("String")]))
+  end
+
+  it "parses nested generics" do
+    type = described_class.parse("Hash[Symbol, Object]")
+    expect(type.name).to eq("Hash")
+    expect(type.arguments.map(&:name)).to eq(%w[Symbol Object])
+  end
+
+  it "parses unions" do
+    type = described_class.parse("String | nil")
+    expect(type).to be_a(Autotype::Union)
+    expect(type.members.map(&:name)).to eq(%w[String nil])
+  end
+end
+
+RSpec.describe Autotype::DiscoveryProfile do
+  let(:fixture_root) { File.expand_path("fixtures", __dir__) }
+
+  it "infers actor port wiring from handler methods" do
+    source = <<~RUBY
+      class DemoActor < Actor
+        input :prompts, type: Entities::Prompt
+
+        def process(prompt, from:)
+          prompt
+        end
+      end
+    RUBY
+
+    collector = Autotype::Collector.new("demo_actor.rb", profile: described_class.new)
+    Prism.parse(source).value.accept(collector)
+    profile = described_class.new
+    profile.finalize!([collector])
+
+    wiring = profile.port_wiring
+    expect(wiring.handler_method).to eq(:process)
+    expect(wiring.dispatch_param).to eq(:from)
+  end
+
+  it "locates entity files by constant name under the project tree" do
+    profile = described_class.new(root: fixture_root)
+    profile.prepare_search!([File.expand_path("fixtures/pipeline/actors/demo_actor.rb", __dir__)])
+
+    expect(profile.locate_type_file("App::Entities::ToolCall")).to eq(
+      File.expand_path("fixtures/entities/tool_call.rb", __dir__)
+    )
+  end
+
+  it "loads optional overrides from autotype.yml" do
+    Dir.mktmpdir do |dir|
+      config_path = File.join(dir, "autotype.yml")
+      File.write(config_path, <<~YAML)
+        skip:
+          - vendor/**
+        types:
+          members:
+            query: App::Entities::Query
+      YAML
+
+      profile = described_class.load_overrides(config_path)
+      expect(profile.skipped_files).to include("vendor/**")
+      expect(profile.member_type_hints[:query]).to eq(Autotype::Named.new("App::Entities::Query"))
+    end
+  end
+
+  it "discovers autotype.yml from nested directories" do
+    Dir.mktmpdir do |dir|
+      config_dir = File.join(dir, "project")
+      FileUtils.mkdir_p(config_dir)
+      File.write(File.join(config_dir, "autotype.yml"), "skip:\n  - vendor/**\n")
+
+      nested = File.join(config_dir, "app", "actors")
+      FileUtils.mkdir_p(nested)
+
+      expect(described_class.find(nested)).to eq(File.join(config_dir, "autotype.yml"))
+    end
+  end
+end

data/spec/autotype_native_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AutotypeNative do
+  it "loads the C extension and exposes solve_graph" do
+    expect(described_class.available?).to be(true)
+    expect(described_class).to respond_to(:solve_graph)
+  end
+
+  it "unifies array append capabilities via the native solver" do
+    described_class.load_extension!
+
+    graph = {
+      "capabilities" => [
+        {
+          "message" => "<<",
+          "receiver" => {
+            "k" => "generic",
+            "name" => "Array",
+            "args" => [{ "k" => "var", "id" => 100, "hint" => "element" }]
+          },
+          "result" => 200,
+          "args" => [{ "k" => "named", "name" => "String" }],
+          "line" => 1
+        }
+      ],
+      "bindings" => {}
+    }
+
+    result = described_class.solve_graph(graph)
+    bindings = result.fetch(:bindings).transform_keys(&:to_i).transform_values { _1.transform_keys(&:to_s) }
+
+    expect(result.fetch(:converged)).to be(true)
+    expect(bindings.fetch(100)).to eq("k" => "named", "name" => "String")
+    result_type = bindings.fetch(200)
+    expect(result_type.fetch("k")).to eq("generic")
+    expect(result_type.fetch("name")).to eq("Array")
+  end
+
+  it "round-trips through NativeBridge on a small inferencer graph" do
+    skip "NativeBridge unavailable" unless Autotype::NativeBridge.native_available?
+
+    source = <<~RUBY
+      class Demo
+        def push(item)
+          buffer = []
+          buffer << item
+          buffer
+        end
+      end
+    RUBY
+
+    result = Prism.parse(source)
+    collector = Autotype::Collector.new("demo.rb")
+    result.value.accept(collector)
+    inferencer = Autotype::FixedPointInferencer.new(
+      collector.methods,
+      constants: collector.constants,
+      includes: collector.includes,
+      metadata: Autotype::InferenceMetadata.empty
+    )
+    inferencer.apply_declared_annotations!
+    inferencer.send(:anchor_constructor_definitions)
+
+    Autotype::NativeBridge.prime!(inferencer)
+
+    renderer = Autotype::Renderer.new(inferencer.send(:resolved_method, collector.methods.first))
+    expect(renderer.text.lines.first).to include("-> Array[")
+  end
+end