feat(ipuaro): add interface fields and type alias definitions to context

- Add interface field display in initial context: interface User { id: string, name: string }
- Add type alias definition display: type UserId = string
- Support readonly fields, extends, union/intersection types
- Add definition field to TypeAliasInfo in FileAST
- Update ASTParser to extract type alias definitions
- Add formatInterfaceSignature() and formatTypeAliasSignature() helpers
- Truncate long type definitions at 80 characters
- Translate ROADMAP.md from Russian to English
- Add 18 new tests for interface fields and type aliases

packages/ipuaro/src/infrastructure/indexer/ASTParser.ts

@@ -554,10 +554,14 @@ export class ASTParser {
             return
         }
 
+        const valueNode = node.childForFieldName(FieldName.VALUE)
+        const definition = valueNode?.text
+
         ast.typeAliases.push({
             name: nameNode.text,
             line: node.startPosition.row + 1,
             isExported,
+            definition,
         })
     }
 

packages/ipuaro/src/infrastructure/llm/prompts.ts

@@ -203,6 +203,54 @@ function formatFunctionSignature(fn: FileAST["functions"][0]): string {
     return `${asyncPrefix}${fn.name}(${params})${returnType}`
 }
 
+/**
+ * Format an interface signature with fields.
+ * Example: "interface User extends Base { id: string, name: string, email?: string }"
+ */
+function formatInterfaceSignature(iface: FileAST["interfaces"][0]): string {
+    const extList = iface.extends ?? []
+    const ext = extList.length > 0 ? ` extends ${extList.join(", ")}` : ""
+
+    if (iface.properties.length === 0) {
+        return `interface ${iface.name}${ext}`
+    }
+
+    const fields = iface.properties
+        .map((p) => {
+            const readonly = p.isReadonly ? "readonly " : ""
+            const optional = p.name.endsWith("?") ? "" : ""
+            const type = p.type ? `: ${p.type}` : ""
+            return `${readonly}${p.name}${optional}${type}`
+        })
+        .join(", ")
+
+    return `interface ${iface.name}${ext} { ${fields} }`
+}
+
+/**
+ * Format a type alias signature with definition.
+ * Example: "type UserId = string" or "type Handler = (event: Event) => void"
+ */
+function formatTypeAliasSignature(type: FileAST["typeAliases"][0]): string {
+    if (!type.definition) {
+        return `type ${type.name}`
+    }
+
+    const definition = truncateDefinition(type.definition, 80)
+    return `type ${type.name} = ${definition}`
+}
+
+/**
+ * Truncate long type definitions for display.
+ */
+function truncateDefinition(definition: string, maxLength: number): string {
+    const normalized = definition.replace(/\s+/g, " ").trim()
+    if (normalized.length <= maxLength) {
+        return normalized
+    }
+    return `${normalized.slice(0, maxLength - 3)}...`
+}
+
 /**
  * Format a single file's AST summary.
  * When includeSignatures is true, shows full function signatures.
@@ -239,15 +287,13 @@ function formatFileSummary(
 
     if (ast.interfaces.length > 0) {
         for (const iface of ast.interfaces) {
-            const extList = iface.extends ?? []
-            const ext = extList.length > 0 ? ` extends ${extList.join(", ")}` : ""
-            lines.push(`- interface ${iface.name}${ext}`)
+            lines.push(`- ${formatInterfaceSignature(iface)}`)
         }
     }
 
     if (ast.typeAliases.length > 0) {
         for (const type of ast.typeAliases) {
-            lines.push(`- type ${type.name}`)
+            lines.push(`- ${formatTypeAliasSignature(type)}`)
         }
     }