@enjoys/context-engine 1.1.1 → 1.1.2

package/data/implementation/go.json

@@ -1,9 +1,46 @@
 {
   "language": "go",
-  "implementationPatterns": [],
+  "implementationPatterns": [
+    {
+      "interface": "Interface",
+      "implementationKeyword": "func",
+      "pattern": "func\\s+\\(\\w+\\s+\\*?(\\w+)\\)\\s+\\w+\\s*\\(",
+      "description": "Method on struct (implicit interface satisfaction)"
+    },
+    {
+      "interface": "InterfaceDecl",
+      "implementationKeyword": "interface",
+      "pattern": "type\\s+(\\w+)\\s+interface\\s*\\{",
+      "description": "Interface type declaration"
+    },
+    {
+      "interface": "StructDecl",
+      "implementationKeyword": "struct",
+      "pattern": "type\\s+(\\w+)\\s+struct\\s*\\{",
+      "description": "Struct type declaration (implements interfaces implicitly)"
+    },
+    {
+      "interface": "Embedding",
+      "implementationKeyword": "embed",
+      "pattern": "type\\s+(\\w+)\\s+struct\\s*\\{[^}]*\\n\\s+\\w+\\b",
+      "description": "Struct embedding (composition / interface delegation)"
+    },
+    {
+      "interface": "TypeAssertion",
+      "implementationKeyword": ".(type)",
+      "pattern": "\\w+\\.\\((\\w+)\\)",
+      "description": "Type assertion checking interface satisfaction"
+    }
+  ],
   "keywords": {
     "interface": [
-      "interface"
+      "interface",
+      "type"
+    ],
+    "implementation": [
+      "struct",
+      "func (receiver)",
+      "type assertion"
     ]
   }
 }

package/data/implementation/hcl.json

@@ -1,7 +1,42 @@
 {
   "language": "hcl",
-  "implementationPatterns": [],
+  "implementationPatterns": [
+    {
+      "interface": "Resource",
+      "implementationKeyword": "resource",
+      "pattern": "resource\\s+\"(\\w+)\"\\s+\"(\\w+)\"\\s*\\{",
+      "description": "Resource block implementation"
+    },
+    {
+      "interface": "Module",
+      "implementationKeyword": "module",
+      "pattern": "module\\s+\"(\\w+)\"\\s*\\{",
+      "description": "Module block instantiation"
+    },
+    {
+      "interface": "Variable",
+      "implementationKeyword": "variable",
+      "pattern": "variable\\s+\"(\\w+)\"\\s*\\{",
+      "description": "Variable definition"
+    },
+    {
+      "interface": "Output",
+      "implementationKeyword": "output",
+      "pattern": "output\\s+\"(\\w+)\"\\s*\\{",
+      "description": "Output definition"
+    }
+  ],
   "keywords": {
-    "note": "This language does not have explicit interface/implementation constructs"
+    "interface": [
+      "variable",
+      "output"
+    ],
+    "implementation": [
+      "resource",
+      "module",
+      "data",
+      "provider",
+      "locals"
+    ]
   }
 }

package/data/implementation/html.json

@@ -1,7 +1,38 @@
-{
-  "language": "html",
-  "implementationPatterns": [],
-  "keywords": {
-    "note": "This language does not have explicit interface/implementation constructs"
-  }
-}
+{
+  "language": "html",
+  "implementationPatterns": [
+    {
+      "pattern": "<(\\w[\\w-]*)(?:\\s|>|/)",
+      "captureGroup": 1,
+      "type": "element",
+      "description": "HTML element implementation"
+    },
+    {
+      "pattern": "id=[\"'](\\w[\\w-]*)[\"']",
+      "captureGroup": 1,
+      "type": "id",
+      "description": "Element ID implementation"
+    },
+    {
+      "pattern": "class=[\"']([^\"']+)[\"']",
+      "captureGroup": 1,
+      "type": "class",
+      "description": "CSS class implementation"
+    },
+    {
+      "pattern": "<script[^>]*>",
+      "captureGroup": 0,
+      "type": "script",
+      "description": "Script block implementation"
+    },
+    {
+      "pattern": "<style[^>]*>",
+      "captureGroup": 0,
+      "type": "style",
+      "description": "Style block implementation"
+    }
+  ],
+  "keywords": {
+    "note": "HTML is a markup language with no interface/implementation constructs."
+  }
+}

package/data/implementation/ini.json

@@ -1,7 +1,26 @@
-{
-  "language": "ini",
-  "implementationPatterns": [],
-  "keywords": {
-    "note": "This language does not have explicit interface/implementation constructs"
-  }
-}
+{
+  "language": "ini",
+  "implementationPatterns": [
+    {
+      "pattern": "^\\[([^\\]]+)\\]",
+      "captureGroup": 1,
+      "type": "section",
+      "description": "INI section implementation"
+    },
+    {
+      "pattern": "^(\\w[\\w.-]*)\\s*=",
+      "captureGroup": 1,
+      "type": "property",
+      "description": "INI property implementation"
+    },
+    {
+      "pattern": "^(\\w[\\w.-]*)\\s*=\\s*(.+)",
+      "captureGroup": 1,
+      "type": "assignment",
+      "description": "INI key-value implementation"
+    }
+  ],
+  "keywords": {
+    "note": "INI is a configuration file format with no interface/implementation constructs."
+  }
+}

package/data/implementation/json.json

@@ -1,7 +1,26 @@
-{
-  "language": "json",
-  "implementationPatterns": [],
-  "keywords": {
-    "note": "This language does not have explicit interface/implementation constructs"
-  }
-}
+{
+  "language": "json",
+  "implementationPatterns": [
+    {
+      "pattern": "\"(\\w+)\"\\s*:",
+      "captureGroup": 1,
+      "type": "property",
+      "description": "JSON property implementation"
+    },
+    {
+      "pattern": "\"\\$ref\"\\s*:\\s*\"([^\"]+)\"",
+      "captureGroup": 1,
+      "type": "reference",
+      "description": "JSON Schema reference implementation"
+    },
+    {
+      "pattern": "\"type\"\\s*:\\s*\"(\\w+)\"",
+      "captureGroup": 1,
+      "type": "type",
+      "description": "JSON Schema type implementation"
+    }
+  ],
+  "keywords": {
+    "note": "JSON is a data serialization format with no interface/implementation constructs."
+  }
+}

package/data/implementation/julia.json

@@ -0,0 +1,48 @@
+{
+  "language": "julia",
+  "implementationPatterns": [
+    {
+      "interface": "AbstractType",
+      "implementationKeyword": "abstract type",
+      "pattern": "abstract\\s+type\\s+(\\w+)(?:\\s*<:\\s*(\\w+))?\\s+end",
+      "description": "Abstract type declaration"
+    },
+    {
+      "interface": "StructSubtype",
+      "implementationKeyword": "<:",
+      "pattern": "(?:mutable\\s+)?struct\\s+(\\w+)\\s*<:\\s*(\\w+)",
+      "description": "Struct subtyping abstract type"
+    },
+    {
+      "interface": "MethodDispatch",
+      "implementationKeyword": "function",
+      "pattern": "function\\s+(\\w+)\\((?:[^:]+)::(\\w+)",
+      "description": "Method with type dispatch (multiple dispatch)"
+    },
+    {
+      "interface": "StructDef",
+      "implementationKeyword": "struct",
+      "pattern": "(?:mutable\\s+)?struct\\s+(\\w+)",
+      "description": "Struct definition"
+    },
+    {
+      "interface": "MacroDef",
+      "implementationKeyword": "macro",
+      "pattern": "macro\\s+(\\w+)\\s*\\(",
+      "description": "Macro implementation"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "abstract type",
+      "<:",
+      "function (generic)"
+    ],
+    "implementation": [
+      "struct",
+      "mutable struct",
+      "function (dispatch)",
+      "macro"
+    ]
+  }
+}

package/data/implementation/less.json

@@ -0,0 +1,40 @@
+{
+  "language": "less",
+  "implementationPatterns": [
+    {
+      "interface": "Mixin",
+      "implementationKeyword": ".",
+      "pattern": "\\.(\\w[\\w-]*)\\s*\\([^)]*\\)\\s*\\{",
+      "description": "Mixin definition (parametric)"
+    },
+    {
+      "interface": "MixinCall",
+      "implementationKeyword": ".",
+      "pattern": "\\.(\\w[\\w-]*)\\s*\\(",
+      "description": "Mixin inclusion (call)"
+    },
+    {
+      "interface": "Extend",
+      "implementationKeyword": ":extend",
+      "pattern": "&:extend\\(\\.(\\w[\\w-]*)\\)",
+      "description": "Extending another ruleset"
+    },
+    {
+      "interface": "Variable",
+      "implementationKeyword": "@",
+      "pattern": "@(\\w[\\w-]*)\\s*:",
+      "description": "Variable definition"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "mixin definition",
+      "@variable"
+    ],
+    "implementation": [
+      ".mixin()",
+      "&:extend()",
+      "when (guard)"
+    ]
+  }
+}

package/data/implementation/lexon.json

@@ -0,0 +1,33 @@
+{
+  "language": "lexon",
+  "implementationPatterns": [
+    {
+      "interface": "Clause",
+      "implementationKeyword": "CLAUSE",
+      "pattern": "CLAUSE:\\s+(\\w[\\w\\s]*)",
+      "description": "Contract clause implementation"
+    },
+    {
+      "interface": "Term",
+      "implementationKeyword": "TERMS",
+      "pattern": "TERMS:\\s*",
+      "description": "Terms section"
+    },
+    {
+      "interface": "Covenant",
+      "implementationKeyword": "LEX",
+      "pattern": "LEX\\s+(\\w[\\w\\s]*)",
+      "description": "Legal contract (LEX) declaration"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "LEX",
+      "TERMS"
+    ],
+    "implementation": [
+      "CLAUSE",
+      "TERMS"
+    ]
+  }
+}

package/data/implementation/liquid.json

@@ -0,0 +1,40 @@
+{
+  "language": "liquid",
+  "implementationPatterns": [
+    {
+      "interface": "Block",
+      "implementationKeyword": "{% block",
+      "pattern": "\\{%[-\\s]*block\\s+(\\w+)",
+      "description": "Block definition (for template inheritance)"
+    },
+    {
+      "interface": "Render",
+      "implementationKeyword": "{% render",
+      "pattern": "\\{%[-\\s]*render\\s+['\"]([^'\"]+)['\"]",
+      "description": "Rendering a partial/snippet"
+    },
+    {
+      "interface": "Capture",
+      "implementationKeyword": "{% capture",
+      "pattern": "\\{%[-\\s]*capture\\s+(\\w+)",
+      "description": "Capture block output to variable"
+    },
+    {
+      "interface": "Section",
+      "implementationKeyword": "{% section",
+      "pattern": "\\{%[-\\s]*section\\s+['\"]([^'\"]+)['\"]",
+      "description": "Section inclusion"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "{% block %}",
+      "snippet/partial"
+    ],
+    "implementation": [
+      "{% render %}",
+      "{% capture %}",
+      "{% section %}"
+    ]
+  }
+}

package/data/implementation/lua.json

@@ -1,7 +1,48 @@
 {
   "language": "lua",
-  "implementationPatterns": [],
+  "implementationPatterns": [
+    {
+      "interface": "Metatable",
+      "implementationKeyword": "setmetatable",
+      "pattern": "setmetatable\\s*\\(\\s*(\\w+)",
+      "description": "Setting metatable (OOP via metatables)"
+    },
+    {
+      "interface": "MethodDef",
+      "implementationKeyword": "function",
+      "pattern": "function\\s+(\\w+):(\\w+)\\s*\\(",
+      "description": "Method definition on table (colon syntax)"
+    },
+    {
+      "interface": "ClassNew",
+      "implementationKeyword": "function",
+      "pattern": "function\\s+(\\w+)\\.new\\s*\\(",
+      "description": "Constructor function (prototype pattern)"
+    },
+    {
+      "interface": "Module",
+      "implementationKeyword": "return",
+      "pattern": "local\\s+(\\w+)\\s*=\\s*\\{\\}",
+      "description": "Module table (returned from file)"
+    },
+    {
+      "interface": "Prototype",
+      "implementationKeyword": "__index",
+      "pattern": "(\\w+)\\.__index\\s*=\\s*\\1",
+      "description": "Prototype setup via __index metamethod"
+    }
+  ],
   "keywords": {
-    "note": "This language does not have explicit interface/implementation constructs"
+    "interface": [
+      "metatable",
+      "__index",
+      "module"
+    ],
+    "implementation": [
+      "setmetatable",
+      "function T:method",
+      "T.new",
+      "__index"
+    ]
   }
 }

package/data/implementation/m3.json

@@ -0,0 +1,48 @@
+{
+  "language": "m3",
+  "implementationPatterns": [
+    {
+      "interface": "Interface",
+      "implementationKeyword": "INTERFACE",
+      "pattern": "INTERFACE\\s+(\\w+)",
+      "description": "Interface module declaration"
+    },
+    {
+      "interface": "Module",
+      "implementationKeyword": "MODULE",
+      "pattern": "MODULE\\s+(\\w+)",
+      "description": "Implementation module"
+    },
+    {
+      "interface": "RevealType",
+      "implementationKeyword": "REVEAL",
+      "pattern": "REVEAL\\s+(\\w+)",
+      "description": "Opaque type revelation"
+    },
+    {
+      "interface": "ObjectType",
+      "implementationKeyword": "OBJECT",
+      "pattern": "(\\w+)\\s*=\\s*\\w+\\s+OBJECT",
+      "description": "Object type (OOP subtyping)"
+    },
+    {
+      "interface": "Subtype",
+      "implementationKeyword": "<:",
+      "pattern": "(\\w+)\\s*<:\\s*(\\w+)",
+      "description": "Subtype relationship"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "INTERFACE",
+      "OBJECT",
+      "METHODS"
+    ],
+    "implementation": [
+      "MODULE",
+      "REVEAL",
+      "OBJECT",
+      "OVERRIDES"
+    ]
+  }
+}

package/data/implementation/makefile.json

@@ -1,7 +1,40 @@
 {
   "language": "makefile",
-  "implementationPatterns": [],
+  "implementationPatterns": [
+    {
+      "interface": "Target",
+      "implementationKeyword": ":",
+      "pattern": "^([\\w.-]+)\\s*:(?!=)",
+      "description": "Make target implementation"
+    },
+    {
+      "interface": "PatternRule",
+      "implementationKeyword": "%",
+      "pattern": "^%\\.(\\w+)\\s*:\\s*%\\.(\\w+)",
+      "description": "Pattern rule implementation"
+    },
+    {
+      "interface": "PhonyTarget",
+      "implementationKeyword": ".PHONY",
+      "pattern": "\\.PHONY\\s*:\\s*([\\w\\s.-]+)",
+      "description": "Phony target declaration"
+    },
+    {
+      "interface": "Function",
+      "implementationKeyword": "define",
+      "pattern": "define\\s+(\\w+)",
+      "description": "Multi-line variable/function definition"
+    }
+  ],
   "keywords": {
-    "note": "This language does not have explicit interface/implementation constructs"
+    "interface": [
+      ".PHONY",
+      "target name"
+    ],
+    "implementation": [
+      "target: dependencies",
+      "define",
+      "%.o: %.c"
+    ]
   }
 }

package/data/implementation/markdown.json

@@ -1,7 +1,26 @@
-{
-  "language": "markdown",
-  "implementationPatterns": [],
-  "keywords": {
-    "note": "This language does not have explicit interface/implementation constructs"
-  }
-}
+{
+  "language": "markdown",
+  "implementationPatterns": [
+    {
+      "pattern": "^#{1,6}\\s+(.+)",
+      "captureGroup": 1,
+      "type": "heading",
+      "description": "Markdown heading implementation"
+    },
+    {
+      "pattern": "\\[([^\\]]+)\\]\\(([^)]+)\\)",
+      "captureGroup": 1,
+      "type": "link",
+      "description": "Markdown link implementation"
+    },
+    {
+      "pattern": "^\\[([^\\]]+)\\]:\\s*(\\S+)",
+      "captureGroup": 1,
+      "type": "reference",
+      "description": "Reference link implementation"
+    }
+  ],
+  "keywords": {
+    "note": "Markdown is a text formatting language with no interface/implementation constructs."
+  }
+}

package/data/implementation/mdx.json

@@ -0,0 +1,24 @@
+{
+  "language": "mdx",
+  "implementationPatterns": [
+    {
+      "name": "Import",
+      "pattern": "^import\\s+.*from\\s+'([^']+)'",
+      "captureGroup": 1,
+      "type": "module"
+    },
+    {
+      "name": "Export",
+      "pattern": "^export\\s+(?:default\\s+)?(?:function|const|class)\\s+(\\w+)",
+      "captureGroup": 1,
+      "type": "variable"
+    },
+    {
+      "name": "Heading",
+      "pattern": "^(#{1,6})\\s+(.+)$",
+      "captureGroup": 2,
+      "type": "string"
+    }
+  ],
+  "keywords": {}
+}

package/data/implementation/mips.json

@@ -0,0 +1,34 @@
+{
+  "language": "mips",
+  "implementationPatterns": [
+    {
+      "interface": "Label",
+      "implementationKeyword": ":",
+      "pattern": "^(\\w+)\\s*:",
+      "description": "Label definition (jump target / function entry)"
+    },
+    {
+      "interface": "TextSection",
+      "implementationKeyword": ".text",
+      "pattern": "\\.text",
+      "description": "Code section declaration"
+    },
+    {
+      "interface": "GlobalDef",
+      "implementationKeyword": ".globl",
+      "pattern": "\\.globl\\s+(\\w+)",
+      "description": "Global symbol export"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      ".globl",
+      ".extern"
+    ],
+    "implementation": [
+      "label:",
+      ".text",
+      "jal (call)"
+    ]
+  }
+}

package/data/implementation/msdax.json

@@ -0,0 +1,35 @@
+{
+  "language": "msdax",
+  "implementationPatterns": [
+    {
+      "interface": "Measure",
+      "implementationKeyword": "MEASURE",
+      "pattern": "(?:MEASURE|DEFINE\\s+MEASURE)\\s+(?:[\\w\\[\\]]+\\[)?(\\w+)\\]?\\s*=",
+      "description": "Measure definition"
+    },
+    {
+      "interface": "CalculatedColumn",
+      "implementationKeyword": "COLUMN",
+      "pattern": "DEFINE\\s+COLUMN\\s+(?:[\\w\\[\\]]+\\[)?(\\w+)\\]?\\s*=",
+      "description": "Calculated column definition"
+    },
+    {
+      "interface": "Table",
+      "implementationKeyword": "TABLE",
+      "pattern": "DEFINE\\s+TABLE\\s+(\\w+)\\s*=",
+      "description": "Calculated table definition"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "MEASURE name",
+      "TABLE name"
+    ],
+    "implementation": [
+      "DEFINE MEASURE",
+      "DEFINE COLUMN",
+      "DEFINE TABLE",
+      "EVALUATE"
+    ]
+  }
+}

package/data/implementation/mysql.json

@@ -0,0 +1,24 @@
+{
+  "language": "mysql",
+  "implementationPatterns": [
+    {
+      "name": "Table",
+      "pattern": "CREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?`?(\\w+)`?",
+      "captureGroup": 1,
+      "type": "class"
+    },
+    {
+      "name": "Procedure",
+      "pattern": "CREATE\\s+PROCEDURE\\s+`?(\\w+)`?",
+      "captureGroup": 1,
+      "type": "function"
+    },
+    {
+      "name": "Function",
+      "pattern": "CREATE\\s+FUNCTION\\s+`?(\\w+)`?",
+      "captureGroup": 1,
+      "type": "function"
+    }
+  ],
+  "keywords": {}
+}