@launchsecure/launch-kit 0.0.8 → 0.0.10

package/dist/server/graph/queries/db-calls.scm

@@ -0,0 +1,8 @@
+; db.user.findUnique(...), db.session.create(...), etc.
+; Matches any <ident>.<model>.<method>() — no hardcoded DB identifier
+(call_expression
+  function: (member_expression
+    object: (member_expression
+      object: (identifier) @db.identifier
+      property: (property_identifier) @db.model)
+    property: (property_identifier) @db.method))

package/dist/server/graph/queries/deep/conditions.scm

@@ -0,0 +1,10 @@
+; if (condition) { ... }
+(if_statement
+  condition: (parenthesized_expression (_) @cond.test)
+  consequence: (_) @cond.consequence)
+
+; Ternary: condition ? a : b
+(ternary_expression
+  condition: (_) @ternary.test
+  consequence: (_) @ternary.then
+  alternative: (_) @ternary.else) @ternary.expr

package/dist/server/graph/queries/deep/jsx-semantic.scm

@@ -0,0 +1,21 @@
+; Self-closing JSX elements with props: <Input type="email" placeholder="..." />
+(jsx_self_closing_element
+  name: (identifier) @el.tag
+  (jsx_attribute
+    (property_identifier) @el.prop.name
+    [(string (string_fragment) @el.prop.value.str)
+     (jsx_expression (_) @el.prop.value.expr)])) @el.self
+
+; Opening JSX elements with props: <Button variant="destructive">
+(jsx_opening_element
+  name: (identifier) @el.tag
+  (jsx_attribute
+    (property_identifier) @el.prop.name
+    [(string (string_fragment) @el.prop.value.str)
+     (jsx_expression (_) @el.prop.value.expr)])) @el.open
+
+; JSX text content (direct text inside elements)
+(jsx_element
+  (jsx_opening_element
+    name: (identifier) @el.text.tag)
+  (jsx_text) @el.text.content)

package/dist/server/graph/queries/deep/request-params.scm

@@ -0,0 +1,24 @@
+; const { email, password } = await req.json()
+(lexical_declaration
+  (variable_declarator
+    name: (object_pattern
+      (shorthand_property_identifier_pattern) @param.name)
+    value: (await_expression
+      (call_expression
+        function: (member_expression
+          object: (identifier) @_req
+          property: (property_identifier) @_method)
+        (#match? @_req "^(req|request)$")
+        (#eq? @_method "json")))))
+
+; const body = await req.json() (whole body capture)
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @param.body
+    value: (await_expression
+      (call_expression
+        function: (member_expression
+          object: (identifier) @_req2
+          property: (property_identifier) @_method2)
+        (#match? @_req2 "^(req|request)$")
+        (#eq? @_method2 "json")))))

package/dist/server/graph/queries/deep/responses.scm

@@ -0,0 +1,26 @@
+; NextResponse.json(body, { status: N })
+(call_expression
+  function: (member_expression
+    object: (identifier) @_nr
+    property: (property_identifier) @_json)
+  arguments: (arguments
+    (_) @resp.body
+    .
+    (object
+      (pair
+        key: (property_identifier) @_status_key
+        value: (number) @resp.status)))
+  (#eq? @_nr "NextResponse")
+  (#eq? @_json "json")
+  (#eq? @_status_key "status"))
+
+; NextResponse.json(body) — no explicit status (defaults to 200)
+(call_expression
+  function: (member_expression
+    object: (identifier) @_nr2
+    property: (property_identifier) @_json2)
+  arguments: (arguments
+    .
+    (_) @resp.body.default)
+  (#eq? @_nr2 "NextResponse")
+  (#eq? @_json2 "json"))

package/dist/server/graph/queries/deep/state-hooks.scm

@@ -0,0 +1,23 @@
+; useState with array destructuring: const [value, setValue] = useState(init)
+(lexical_declaration
+  (variable_declarator
+    name: (array_pattern
+      (identifier) @hook.var
+      (identifier) @hook.setter)
+    value: (call_expression
+      function: (identifier) @hook.fn
+      arguments: (arguments . (_) @hook.init)
+      (#match? @hook.fn "^use[A-Z]"))))
+
+; useReducer: const [state, dispatch] = useReducer(reducer, init)
+(lexical_declaration
+  (variable_declarator
+    name: (array_pattern
+      (identifier) @reducer.var
+      (identifier) @reducer.dispatch)
+    value: (call_expression
+      function: (identifier) @_useReducer
+      arguments: (arguments
+        (_) @reducer.fn
+        (_) @reducer.init)
+      (#eq? @_useReducer "useReducer"))))

package/dist/server/graph/queries/deep/variables.scm

@@ -0,0 +1,17 @@
+; const name = expression
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @var.name
+    value: (_) @var.init)) @var.decl
+
+; Destructured object: const { a, b } = expression
+(lexical_declaration
+  (variable_declarator
+    name: (object_pattern) @var.destructured.obj
+    value: (_) @var.destructured.init)) @var.destructured
+
+; Destructured array: const [a, b] = expression
+(lexical_declaration
+  (variable_declarator
+    name: (array_pattern) @var.array.pattern
+    value: (_) @var.array.init)) @var.array

package/dist/server/graph/queries/exports.scm

@@ -0,0 +1,66 @@
+; export default function Foo() {}
+(export_statement
+  "default"
+  declaration: (function_declaration
+    name: (identifier) @export.default.func))
+
+; export default class Foo {}
+(export_statement
+  "default"
+  declaration: (class_declaration
+    name: (type_identifier) @export.default.class))
+
+; export default <identifier>
+(export_statement
+  "default"
+  value: (identifier) @export.default.value)
+
+; export function Foo() {}
+(export_statement
+  declaration: (function_declaration
+    name: (identifier) @export.named.func))
+
+; export class Foo {}
+(export_statement
+  declaration: (class_declaration
+    name: (type_identifier) @export.named.class))
+
+; export const Foo = ...
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @export.named.const)))
+
+; export type Foo = ...
+(export_statement
+  declaration: (type_alias_declaration
+    name: (type_identifier) @export.named.type))
+
+; export interface Foo {}
+(export_statement
+  declaration: (interface_declaration
+    name: (type_identifier) @export.named.interface))
+
+; export enum Foo {}
+(export_statement
+  declaration: (enum_declaration
+    name: (identifier) @export.named.enum))
+
+; export { A, B } from 'x' (re-exports with names)
+(export_statement
+  (export_clause
+    (export_specifier
+      name: (identifier) @reexport.name))
+  source: (string (string_fragment) @reexport.source))
+
+; export * from 'x' (wildcard re-export — tree-sitter represents * as literal)
+(export_statement
+  "*"
+  source: (string (string_fragment) @reexport.wildcard.source))
+
+; export { A, B } (bare named exports, no source)
+(export_statement
+  (export_clause
+    (export_specifier
+      name: (identifier) @export.bare.name))
+  !source)

package/dist/server/graph/queries/fetch-calls.scm

@@ -0,0 +1,57 @@
+; fetch('/api/foo')
+(call_expression
+  function: (identifier) @_fetch
+  arguments: (arguments
+    .
+    (string (string_fragment) @fetch.url.literal))
+  (#eq? @_fetch "fetch"))
+
+; fetch(`/api/foo/${id}`)
+(call_expression
+  function: (identifier) @_fetch2
+  arguments: (arguments
+    .
+    (template_string) @fetch.url.template)
+  (#eq? @_fetch2 "fetch"))
+
+; client.get('/api/foo') — direct call (no await, no type args)
+(call_expression
+  function: (member_expression
+    object: (identifier) @fetch.client
+    property: (property_identifier) @fetch.method)
+  arguments: (arguments
+    .
+    (string (string_fragment) @fetch.client.url.literal))
+  (#match? @fetch.method "^(get|post|put|patch|delete|head|options)$"))
+
+; client.get(`/api/foo/${id}`) — template, direct call
+(call_expression
+  function: (member_expression
+    object: (identifier) @fetch.client2
+    property: (property_identifier) @fetch.method.template)
+  arguments: (arguments
+    .
+    (template_string) @fetch.client.url.template)
+  (#match? @fetch.method.template "^(get|post|put|patch|delete|head|options)$"))
+
+; await client.post('/api/foo') — await wraps the member_expression
+(call_expression
+  function: (await_expression
+    (member_expression
+      object: (identifier) @fetch.await.client
+      property: (property_identifier) @fetch.await.method))
+  arguments: (arguments
+    .
+    (string (string_fragment) @fetch.await.url.literal))
+  (#match? @fetch.await.method "^(get|post|put|patch|delete|head|options)$"))
+
+; await client.post(`/api/foo/${id}`) — await + template
+(call_expression
+  function: (await_expression
+    (member_expression
+      object: (identifier) @fetch.await.client2
+      property: (property_identifier) @fetch.await.method.template))
+  arguments: (arguments
+    .
+    (template_string) @fetch.await.url.template)
+  (#match? @fetch.await.method.template "^(get|post|put|patch|delete|head|options)$"))

package/dist/server/graph/queries/imports.scm

@@ -0,0 +1,14 @@
+; All import statements (used to find import nodes for direct AST walking)
+(import_statement
+  source: (string (string_fragment) @import.source)) @import.statement
+
+; Type-only imports: import type { X } from 'x'
+(import_statement
+  "type"
+  source: (string (string_fragment) @import.type_only_source)) @import.type_only
+
+; Dynamic imports: import('x')
+(call_expression
+  function: (import)
+  arguments: (arguments
+    (string (string_fragment) @import.dynamic)))

package/dist/server/graph/queries/jsx-elements.scm

@@ -0,0 +1,14 @@
+; JSX opening elements: <Foo ...>
+(jsx_opening_element
+  name: (identifier) @jsx.tag)
+
+; JSX self-closing elements: <Foo ... />
+(jsx_self_closing_element
+  name: (identifier) @jsx.tag)
+
+; JSX member expression elements: <Foo.Bar>
+(jsx_opening_element
+  name: (member_expression) @jsx.member_tag)
+
+(jsx_self_closing_element
+  name: (member_expression) @jsx.member_tag)

package/dist/server/graph/queries/navigations.scm

@@ -0,0 +1,85 @@
+; router.push('...')
+(call_expression
+  function: (member_expression
+    object: (identifier) @_router
+    property: (property_identifier) @nav.method)
+  arguments: (arguments
+    .
+    (string (string_fragment) @nav.target.literal))
+  (#eq? @_router "router")
+  (#match? @nav.method "^(push|replace)$"))
+
+; router.push(`...`)
+(call_expression
+  function: (member_expression
+    object: (identifier) @_router2
+    property: (property_identifier) @nav.method.template)
+  arguments: (arguments
+    .
+    (template_string) @nav.target.template)
+  (#eq? @_router2 "router")
+  (#match? @nav.method.template "^(push|replace)$"))
+
+; <Link href="..."> — scoped to Link elements only
+(jsx_opening_element
+  name: (identifier) @_link_tag
+  attribute: (jsx_attribute
+    (property_identifier) @_href
+    (string (string_fragment) @nav.link.literal))
+  (#eq? @_link_tag "Link")
+  (#eq? @_href "href"))
+
+; <Link href="..."> — self-closing
+(jsx_self_closing_element
+  name: (identifier) @_link_tag2
+  attribute: (jsx_attribute
+    (property_identifier) @_href2
+    (string (string_fragment) @nav.link.literal.self))
+  (#eq? @_link_tag2 "Link")
+  (#eq? @_href2 "href"))
+
+; <Link href={`...`}> — template
+(jsx_opening_element
+  name: (identifier) @_link_tag3
+  attribute: (jsx_attribute
+    (property_identifier) @_href3
+    (jsx_expression
+      (template_string) @nav.link.template))
+  (#eq? @_link_tag3 "Link")
+  (#eq? @_href3 "href"))
+
+; <Link href={`...`}> — template, self-closing
+(jsx_self_closing_element
+  name: (identifier) @_link_tag4
+  attribute: (jsx_attribute
+    (property_identifier) @_href4
+    (jsx_expression
+      (template_string) @nav.link.template.self))
+  (#eq? @_link_tag4 "Link")
+  (#eq? @_href4 "href"))
+
+; window.location.href = '...'
+(assignment_expression
+  left: (member_expression
+    object: (member_expression
+      object: (identifier) @_win
+      property: (property_identifier) @_loc)
+    property: (property_identifier) @_href5)
+  right: (string (string_fragment) @nav.window.literal)
+  (#eq? @_win "window")
+  (#eq? @_loc "location")
+  (#eq? @_href5 "href"))
+
+; window.location.assign('...')
+(call_expression
+  function: (member_expression
+    object: (member_expression
+      object: (identifier) @_win2
+      property: (property_identifier) @_loc2)
+    property: (property_identifier) @nav.window.method)
+  arguments: (arguments
+    .
+    (string (string_fragment) @nav.window.assign.target))
+  (#eq? @_win2 "window")
+  (#eq? @_loc2 "location")
+  (#match? @nav.window.method "^(assign|replace)$"))

package/dist/server/graph/queries/wrappers.scm

@@ -0,0 +1,8 @@
+; export const GET = withAuth(async (req) => { ... })
+; Captures any function wrapping an exported const
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @wrapper.export_name
+      value: (call_expression
+        function: (identifier) @wrapper.fn_name))))