Get Stellify Framework API reference with full type signatures. Import from "stellify-framework".

Returns composables (useForm, useAuth, etc.) with options/returns, utilities (Http, Collection, etc.) with methods/staticMethods, and validation rules.

Each item includes summary, type signatures, and JSDoc descriptions. Collection is iterable with v-for.

Get active project. Returns uuid, name, branches, and directories array.

Create an empty file shell in a Stellify project. Returns file UUID.

For PHP: type='class', 'model', 'controller', or 'middleware'. For Vue: type='js', extension='vue'. Auto-creates app.js and template route.

Pass 'includes' array for framework class dependencies (auto-resolved to UUIDs). Use 'models' array in save_file for project models.

IMPORTANT - Check appJs response for Vue components:

• If appJs.action_required === "create_or_select_mount_file": No mount file exists. You MUST ask the user if they want to create a new app.js mount file before proceeding.

• If appJs.action_required === "register_component": Mount file exists but component isn't registered. Call save_file on the mount file to add the component UUID to its includes array.

Create a method in a file. Pass 'body' to include implementation. Async auto-detected from await. For significant methods, include context fields.

Append code to an existing method. Use this when you need to ADD MORE code to a method that already has statements.

For new methods: Use create_method with the body parameter instead - it creates the method with code in one call.

Nested code is handled correctly. The parser tracks brace/bracket/paren depth and only splits on semicolons at the top level. Arrow functions with block bodies, computed properties, and other nested constructs work as single statements.

Pass 'types' to specify TypeScript types for variables declared in the code.

IMPORTANT: This APPENDS to existing method statements. To REPLACE a method's code entirely:

1. Create a NEW method with create_method (with body parameter)

2. Update the file's 'data' array to include new method UUID (remove old one)

3. Update any element click handlers to reference the new method UUID

4. Delete the old method with delete_method

Update a method's properties. Use add_method_body to append code.

For significant changes, include context fields: summary, rationale, references, decisions.

Search for methods in the project by name or within a specific file

Search for available PHP 8 attributes in Laravel. Returns attribute suggestions with descriptions, namespaces, targets (class/method/property/parameter), and expected arguments.

Use this before adding attributes to files or methods to find the correct attribute name and syntax.

Three modes of operation:

1. List categories (no params): Returns all available attribute categories

   • Call with no arguments to discover categories like "eloquent", "queue", "routing"

2. List category attributes (category only): Returns all attributes in a category

   • Example: category="eloquent" → returns Fillable, Hidden, ObservedBy, etc.

3. Search by query (query provided): Searches attribute names

   • Example: query="fill" → finds Fillable attribute

   • Can combine with category to search within a specific category

Analyze PHP 8 attribute usage across a Stellify project. Useful for auditing, finding missing attributes, and searching attribute values.

Three modes:

1. usage (default): List all attributes used in the project with counts

   • Optional: file_type to filter (e.g., "model", "controller")

   • Returns: attribute names, counts, and files using each

2. missing: Find files of a specific type missing a required attribute

   • Required: file_type (e.g., "model", "class")

   • Required: attribute name (e.g., "Fillable", "FailOnUnknownFields")

   • Returns: files missing vs having the attribute

3. search: Find files where an attribute contains a specific value

   • Required: attribute name

   • Optional: value to search for in attribute args

   • Optional: file_type to filter

   • Returns: matching files with their attribute values

Example queries:

• "Find every FormRequest missing FailOnUnknownFields": mode=missing, file_type=class, attribute=FailOnUnknownFields

• "Find models where 'email' is fillable": mode=search, attribute=Fillable, value=email

• "List all attributes used": mode=usage

Delete a method from a file by UUID. This permanently removes the method and all its code. Requires both the file UUID and method UUID.

Get a method by UUID. Returns the method data including its parameters and body.

Search for files in the project by name or type

Create a route/page. For API routes, you MUST pass BOTH controller AND controller_method UUIDs to wire execution.

IMPORTANT: Both 'controller' (file UUID) and 'controller_method' (method UUID) are required together for API routes to execute code. Without both, the route won't run any code.

Route params like {id} auto-inject into controller method parameters when names match.

Get a route/page by UUID. Returns route details including name, path, and attached elements.

Use this to look up a route you created or to find existing routes in the project.

Update a route/page. Wire to controller with both controller and controller_method UUIDs. For significant routes, include context fields.

Delete a route/page from the project by UUID. This permanently removes the route.

WARNING: This is destructive and cannot be undone. Any elements attached to this route will be deleted also.

Search for routes/pages in the project by name. Use this to find existing routes before creating new ones.

Returns paginated results with route details including UUID, name, path, and type. Use the returned UUID with html_to_elements (page parameter) or get_route for full details.

Create a UI element. Provide page (route UUID) for root elements, or parent (element UUID) for children.

Update a UI element. Data object: tag, classes, text, event handlers (method UUIDs), classBindings. Set 'name' on root elements to create Blade views (e.g., name="notes.index" for view('notes.index')).

For elements inside @foreach loops (SSR/Blade): Use these attributes to reference the loop variable (defaults to $item):

• textField: Field name for text content → outputs {{ $item->fieldName }}

• hrefField: Field name for href → outputs href="{{ $item->fieldName }}" (field value ONLY, no prefix)

• srcField: Field name for src → outputs src="{{ $item->fieldName }}"

For hrefs with path prefixes (IMPORTANT): hrefField outputs ONLY the field value. There is NO hrefPrefix attribute. For links like /post/slug-here, you MUST use hrefExpression:

• hrefExpression: "/post/{{ $item->slug }}" → outputs href="/post/{{ $item->slug }}"

• hrefExpression: "/category/{{ $item->slug }}" → outputs href="/category/{{ $item->slug }}"

For complex Blade expressions in attributes: Use expression attributes when you need more than simple field access:

• hrefExpression: Blade expression for href → outputs href="..." with the expression

• srcExpression: Blade expression for src → outputs src="..." with the expression

• altExpression: Blade expression for alt → outputs alt="..." with the expression

Examples:

• Path prefix: hrefExpression: "/post/{{ $item->slug }}"

• Route helper: hrefExpression: "{{ route('posts.show', $item->slug) }}"

For Blade text content: Use the statements array with statement UUIDs containing Blade code. The statement's code property will be output directly for Blade to evaluate.

Get a single element by UUID. Returns the element data with all its attributes.

Get an element with all its descendants (children, grandchildren, etc.) as a hierarchical tree structure.

Delete an element and all its children (CASCADE). Returns the count of deleted elements.

Search for elements in the project. Useful for finding elements by name, type, or content.

Note: To reorder elements, use update_element to modify the parent element's 'data' array with the new order of child UUIDs.

Convert HTML to Stellify elements.

IMPORTANT - Choose the right approach:

For SSR/Blade Pages (WordPress imports, static content, layouts):

• MUST pass 'page' (route UUID) - elements attach to the route for server-side rendering

• This is the most common use case

For Vue Components (client-side interactivity):

• Omit 'page' - elements are standalone, referenced by file's template array

• Returns UUIDs to use in save_file's template array

Where elements go:

• Pass 'page' (route UUID): Elements attached to the route for SSR rendering

• Pass 'selection' (element UUID): Elements attached as children of existing element

• Omit both: Elements are standalone (Vue components only) - use returned UUIDs in save_file's template array

⚠️ CRITICAL: Multiple Root Elements Limitation When HTML contains multiple root-level elements (e.g., , , ), only the FIRST root element gets attached to the route. Other elements become orphaned!

WRONG: html_to_elements(page: routeUUID, elements: "<header>...</header><main>...</main><footer>...</footer>") → Only attaches to route. and are orphaned!

CORRECT: Make separate calls for each root element:

1. html_to_elements(page: routeUUID, elements: "<header>...</header>")

2. html_to_elements(page: routeUUID, elements: "<main>...</main>")

3. html_to_elements(page: routeUUID, elements: "<footer>...</footer>")

OR wrap all elements in a single container div.

@click auto-wiring: Pass 'file' UUID to auto-resolve @click="methodName" handlers. Methods must exist in the file first.

Blade Syntax Handling: For SSR/Blade pages, do NOT pass raw Blade expressions in text or attributes. The HTML parser stores them literally which causes rendering issues. Instead:

1. For static HTML: Pass clean HTML without Blade syntax, then use update_element to add dynamic behavior

2. For loop content: After creating elements, use update_element with:

   • textField, hrefField, srcField for simple field access (outputs {{ $item->field }})

   • hrefExpression, srcExpression, altExpression for paths with prefixes or complex expressions

   • statements array with statement UUIDs for text content with Blade code

3. For conditionals: Use s-directive elements as siblings (see update_element docs)

IMPORTANT - Links with path prefixes: hrefField outputs ONLY the field value with no prefix. There is NO hrefPrefix attribute. For links like /post/my-slug, use hrefExpression: "/post/{{ $item->slug }}" instead.

Loop variable: Inside @foreach loops created with s-directive, the default loop variable is $item. Use textField: "title" to output {{ $item->title }}.

Prefer SVG icons over emoji (encoding issues).

Get a statement by UUID. Returns the statement data including its clauses (code tokens).

Create empty statement (step 1 of 2). Call add_statement_code next. Prefer create_statement_with_code for single call.

Create a statement with code in one call. Preferred over two-step create_statement + add_statement_code.

Pass 'types' to specify TypeScript types for variables. The assembler infers the full type from code structure:

• ref([]) + type "Todo" → outputs const todos: Ref<Todo[]>

• ref(0) + type "number" → outputs const count: Ref<number>

• reactive({}) + type "State" → outputs const state: State

Add code to an existing statement. This is step 2 of 2 - call this AFTER create_statement.

ALTERNATIVE: Use create_statement_with_code for a single-call approach that combines both steps.

The statement must already exist (created via create_statement). This parses and stores the code.

Examples:

• PHP: "use Illuminate\Http\Request;" or "private $items = [];"

• JS/Vue: "const count = ref(0);" or "import { ref } from 'vue';"

Delete a statement from a file by UUID. This permanently removes the statement (import, variable, ref, etc.).

Update an existing statement. Use this to modify statement properties after creation.

Finalize a file. Full replacement - call get_file first to update existing files.

Required: uuid, name, type. For significant changes, include context fields: summary, rationale, references, decisions.

Get a file by UUID with all its metadata, methods, and statements.

Delete a file from the project by UUID. This permanently removes the file and all its methods/statements.

WARNING: This is destructive and cannot be undone. Make sure the file is not referenced elsewhere before deleting.

Get a directory by UUID to see its contents.

Use this to inspect directories returned by get_project. The project's data array contains directory UUIDs. Returns the directory name and list of files/subdirectories inside it.

Create a new directory for organizing files.

Common directories:

• 'js' for JavaScript/Vue files

• 'css' for stylesheets

• 'components' for reusable components

IMPORTANT: Check existing directories first using get_project and get_directory before creating new ones.

Update an existing directory. Use this to rename or modify directory properties.

Push real-time UI updates via WebSocket. Use for SHOW/DISPLAY/DEMONSTRATE requests.

Actions: update (modify element), create (ephemeral element), batch (multiple updates), delete.

Changes are EPHEMERAL (not saved). For persistent changes, use update_element or html_to_elements.

Scaffold Model, Controller, Service, and Migration. Routes are NOT auto-wired - use create_route after.

Execute a method in sandboxed environment. Requires file and method UUIDs. Returns output, success, error, and optional benchmark data.

Log a missing framework-level capability. Creates a ticket in the Stellify backlog.

Install a foundation package into the current project. Creates routes and other resources defined in the package manifest.

Returns success with installed counts, or error with code:

• PACKAGE_NOT_FOUND: Package name doesn't exist

• PACKAGE_NOT_INSTALLABLE: Package is disabled

• ALREADY_INSTALLED: Package routes already exist in project

• UNKNOWN_MANIFEST_KEY: Package requires newer platform version

• INSTALL_FAILED: Transaction failed

Analyze execution performance from logs. Types: full, slow_methods, high_query_methods, high_memory_methods, failure_rates, trend.

Analyze Laravel code for quality issues. Types: full, relationships, fillables, casts, routes. Returns actionable suggestions.

Get a setting profile by name. Returns key-value pairs accessible via config() in code.

Create or update a setting profile. Data is merged with existing values. Access via config('name.key') in code.

Delete a setting profile from the tenant's settings table.

WARNING: This permanently removes the entire setting profile and all its values. This cannot be undone.

EXAMPLE: { "name": "vote" }

This removes the "vote" setting profile entirely.

Get a UI pattern checklist (accordion, modal, tabs, dropdown, toast). Returns best practices and common pitfalls.

Save or update a UI pattern checklist.

Use this to add new patterns or update existing ones based on lessons learned.

EXAMPLE: { "name": "accordion", "description": "Collapsible content panels", "checklist": [ "Use v-show for visibility toggle", "Store open state as boolean" ], "example": "const panels = ref([...]);" }

List all available UI pattern checklists.

Returns an array of pattern names and descriptions. Use this to discover what patterns are available before building UI components.

Get the assembled source code for a file. Returns the actual Vue SFC or PHP class as it would be rendered.

Use this after save_file to verify the component was built correctly:

• Check that all methods are included

• Verify @click handlers are wired to methods

• Confirm imports and reactive state are present

• Spot any missing pieces before deployment