Arandu Module Generator

What it does

When your agent uses it

• Adding a new database-backed resource to an Arandu application
• Scaffolding CRUD for a new domain object with access rules
• Checking a module specification before generating its code

Example prompts

• “Add an invoices module with the standard CRUD actions to this Arandu app.”
• “Check my posts.yaml specification before generating the module.”
• “Scaffold a module for comments where only the author can edit their own.”

Requirements

• The `aru` CLI

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

1. 1Generate the resource. `aru make:module note --fields
2. 2Or write a specification when the module needs permissions or a
3. 3Change a table with a new migration, never by editing one that ran
4. 4Put the entity's rules in the entity. A transition is a method on the
5. 5Order the use case in the service: validate the request, read the row
6. 6Run aru model:build after any change to an entity, and never edit what

What it can do on your machine

Read from SKILL.md and the folder at commit b8a4273. It shows what the files ask for, not the result of running them.

• Tool permissions

  Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

  From allowed-tools in the SKILL.md frontmatter.

• Runs code

  Shell commands in SKILL.md call:

  • go
  • bash

  From the folder's file list and the shell code blocks in SKILL.md.

• Network

  No URLs in SKILL.md.

  From URLs in SKILL.md, links to its own repository left out.

• Credentials

  Names no API keys, tokens, secrets or passwords.

  From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Arandu Module Generator loads about 2.4k tokens when it runs. Until then it costs about 169 tokens; SKILL.md has 1,003 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it

~169

When it runs · the whole SKILL.md, loaded when a task matches

~2.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from arandu-io/arandu at commit b8a4273, republished under its MIT licence (© arandu-io). 1,003 words, ~2,429 tokens.

name

arandu-module

description

The model and data of an Arandu (Go) application -- an entity, its table, the generated query, migrations, factories, seeders, scopes, relations, the rules of the entity itself and the service that orders a use case over them. Use when the request is to "create a model", "add a table", "add a column", "scaffold CRUD", "add invoices", "a record under another record", "add a state transition", "write a seeder", or when a query, a migration or `model:build` is involved. Covers aru make:module (with --tenant and --parent), aru generate and its specification, make:model, make:migration, make:service, model:build and the custom blocks that survive regeneration.

license

MIT

package example

import (
	"context"
	"time"

	"github.com/arandu-io/hesape/auth"
	"github.com/arandu-io/hesape/database"

	models "<module>/app/Models"
	policies "<module>/app/Policies"
)

// PinnedDrafts reads the tenant's pinned drafts, newest first, one page at a
// time: the generated query, finished by a terminal that takes the Grant.
func PinnedDrafts(ctx context.Context, db *database.DB, g auth.Grant) (models.NoteCollection, error) {
	if err := g.Check(policies.NoteList); err != nil {
		return nil, err
	}
	return models.Notes(db).Where("pinned", true).WhereNull("published_at").
		Latest().Limit(25).Get(ctx, g)
}

// PublishAt applies the entity's transition and saves the row with the Grant
// the policy issued for it.
func PublishAt(ctx context.Context, g auth.Grant, note *models.Note, at time.Time) error {
	if err := note.Publish(at); err != nil {
		return err
	}
	_, err := note.Save(ctx, g)
	return err
}

// routes/web.go, the field on Deps
Note *controllers.NoteController
// bootstrap/app.go, in the routes.Deps literal
Note: controllers.NewNoteController(services.NewNoteService(db)),

export GOWORK=off
aru model:build --check
aru view:build
gofmt -l $(find . -name '*.go' -not -path '*/testdata/*' -not -name '*.kyse.go')
go vet ./...
bash tests/test-layout-guard.sh
go test -race ./...
go build ./...
aru doctor

<!-- arandu:begin custom -->

<!-- arandu:end custom -->

© arandu-io, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/arandu-module of arandu-io/arandu.

Open the folder on GitHubat commit b8a4273