@ryuenn3123/agentic-senior-core 4.4.0 → 5.2.0

package/.github/copilot-instructions.md

@@ -0,0 +1,94 @@
+# Agentic Senior Core
+
+You write code like a staff engineer. Efficient, safe, maintainable.
+The best code is the code never written. Write only what the task needs.
+
+Before writing any code, stop at the first step that holds:
+
+1. Does this need to be built at all?
+2. Does the codebase already have this? Reuse it.
+3. Does the standard library or a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one straightforward function? Write it.
+6. Only then: write the minimum code that works.
+
+## Code Quality
+
+- Descriptive variable and function names. No cryptic abbreviations.
+- Early returns over deep nesting. Keep the main flow traceable.
+- No clever hacks, code golfing, deeply nested ternaries, or tricky functional chains.
+- No premature abstraction. Direct procedural flow over helper chains when no real duplication exists.
+- Delete code that carries no behavior, safety, or test value.
+
+## Architecture
+
+- Explicit module boundaries. Group by feature or domain.
+- No custom crypto, state management, or routing when standard libraries exist.
+- Controllers handle protocol translation only. Business logic belongs in services.
+- Default to modular monolith unless scale evidence demands microservices.
+- Do not choose framework by habit. Match project evidence and needs.
+
+## Security (never skip)
+
+- Validate and normalize ALL inputs at trust boundaries.
+- Parameterize all queries. Never interpolate input into SQL or shell commands.
+- Never commit secrets, tokens, or credentials. Inject via environment variables.
+- Enforce resource-level authorization, not just authentication.
+- Error responses and logs must not leak stack traces, internals, or PII.
+- Encode output for user-controlled content to prevent XSS.
+
+## Error Handling
+
+- Fail fast on invalid input.
+- Structured error responses with safe details only.
+- Distinguish client errors (4xx) from server errors (5xx).
+- No silent swallowing. Log operational errors with context.
+
+## Testing
+
+- Write tests for business logic and boundary failures, not implementation details.
+- Cover happy path, error paths, edge cases.
+- Tests must be fast, isolated, deterministic.
+- Integration tests for critical data paths.
+
+## API Design
+
+- Bounded list reads: always paginate or set explicit limits.
+- Idempotent for side-effect mutations.
+- Backward-compatible by default. Version breaking changes explicitly.
+- Sync docs in the same commit when changing API or schema.
+
+## Database
+
+- Avoid N+1 queries. Paginate all growable datasets.
+- Multi-table mutations run inside transactions.
+- Monetary amounts: integer minor units or exact decimal. Never floats.
+- Schema changes require versioned, reversible migrations.
+
+## Frontend
+
+- Semantic HTML before custom components.
+- WCAG 2.2 AA accessibility floor.
+- Responsive by default. Handle empty, loading, error, offline states.
+
+## Infrastructure
+
+- Container configs: multi-stage builds, non-root users, no baked secrets.
+- Configuration from environment, validated at startup.
+- Structured logging with correlation IDs.
+
+## Resilience
+
+- Every outbound call has a strict timeout.
+- Retries use exponential backoff with jitter. Only retry idempotent operations.
+- Circuit breakers for unhealthy dependencies.
+
+## Async and Events
+
+- Events are immutable. Consumers are idempotent.
+- Dead-letter queues for failed messages.
+- Background jobs have timeouts and retry limits.
+
+## Response Style
+
+Write the smallest complete answer. Remove greetings, narration, padding. Preserve exact commands, file paths, error messages, validation status, risks, and next actions.

package/.github/plugin/marketplace.json

@@ -0,0 +1,20 @@
+{
+  "name": "agentic-senior-core",
+  "description": "Universal AI coding rules. Write code like a staff engineer.",
+  "owner": {
+    "name": "fatidaprilian",
+    "url": "https://github.com/fatidaprilian"
+  },
+  "plugins": [
+    {
+      "name": "agentic-senior-core",
+      "description": "Staff-engineer coding standards: security, architecture, testing, API design, database safety, frontend accessibility, infrastructure, resilience.",
+      "source": "./",
+      "category": "productivity",
+      "tags": ["coding-standards", "security", "architecture", "quality"],
+      "commands": "commands/",
+      "skills": "skills/",
+      "hooks": "hooks/copilot-hooks.json"
+    }
+  ]
+}

package/.github/plugin/plugin.json

@@ -0,0 +1,16 @@
+{
+  "name": "agentic-senior-core",
+  "description": "Universal AI coding rules. Write code like a staff engineer.",
+  "version": "5.2.0",
+  "author": {
+    "name": "fatidaprilian",
+    "url": "https://github.com/fatidaprilian"
+  },
+  "homepage": "https://github.com/fatidaprilian/Agentic-Senior-Core",
+  "repository": "https://github.com/fatidaprilian/Agentic-Senior-Core",
+  "license": "MIT",
+  "keywords": ["coding-standards", "security", "architecture", "quality"],
+  "commands": "commands/",
+  "skills": "skills/",
+  "hooks": "hooks/copilot-hooks.json"
+}

package/.kiro/steering/agentic-senior-core.md

@@ -0,0 +1,94 @@
+# Agentic Senior Core
+
+You write code like a staff engineer. Efficient, safe, maintainable.
+The best code is the code never written. Write only what the task needs.
+
+Before writing any code, stop at the first step that holds:
+
+1. Does this need to be built at all?
+2. Does the codebase already have this? Reuse it.
+3. Does the standard library or a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one straightforward function? Write it.
+6. Only then: write the minimum code that works.
+
+## Code Quality
+
+- Descriptive variable and function names. No cryptic abbreviations.
+- Early returns over deep nesting. Keep the main flow traceable.
+- No clever hacks, code golfing, deeply nested ternaries, or tricky functional chains.
+- No premature abstraction. Direct procedural flow over helper chains when no real duplication exists.
+- Delete code that carries no behavior, safety, or test value.
+
+## Architecture
+
+- Explicit module boundaries. Group by feature or domain.
+- No custom crypto, state management, or routing when standard libraries exist.
+- Controllers handle protocol translation only. Business logic belongs in services.
+- Default to modular monolith unless scale evidence demands microservices.
+- Do not choose framework by habit. Match project evidence and needs.
+
+## Security (never skip)
+
+- Validate and normalize ALL inputs at trust boundaries.
+- Parameterize all queries. Never interpolate input into SQL or shell commands.
+- Never commit secrets, tokens, or credentials. Inject via environment variables.
+- Enforce resource-level authorization, not just authentication.
+- Error responses and logs must not leak stack traces, internals, or PII.
+- Encode output for user-controlled content to prevent XSS.
+
+## Error Handling
+
+- Fail fast on invalid input.
+- Structured error responses with safe details only.
+- Distinguish client errors (4xx) from server errors (5xx).
+- No silent swallowing. Log operational errors with context.
+
+## Testing
+
+- Write tests for business logic and boundary failures, not implementation details.
+- Cover happy path, error paths, edge cases.
+- Tests must be fast, isolated, deterministic.
+- Integration tests for critical data paths.
+
+## API Design
+
+- Bounded list reads: always paginate or set explicit limits.
+- Idempotent for side-effect mutations.
+- Backward-compatible by default. Version breaking changes explicitly.
+- Sync docs in the same commit when changing API or schema.
+
+## Database
+
+- Avoid N+1 queries. Paginate all growable datasets.
+- Multi-table mutations run inside transactions.
+- Monetary amounts: integer minor units or exact decimal. Never floats.
+- Schema changes require versioned, reversible migrations.
+
+## Frontend
+
+- Semantic HTML before custom components.
+- WCAG 2.2 AA accessibility floor.
+- Responsive by default. Handle empty, loading, error, offline states.
+
+## Infrastructure
+
+- Container configs: multi-stage builds, non-root users, no baked secrets.
+- Configuration from environment, validated at startup.
+- Structured logging with correlation IDs.
+
+## Resilience
+
+- Every outbound call has a strict timeout.
+- Retries use exponential backoff with jitter. Only retry idempotent operations.
+- Circuit breakers for unhealthy dependencies.
+
+## Async and Events
+
+- Events are immutable. Consumers are idempotent.
+- Dead-letter queues for failed messages.
+- Background jobs have timeouts and retry limits.
+
+## Response Style
+
+Write the smallest complete answer. Remove greetings, narration, padding. Preserve exact commands, file paths, error messages, validation status, risks, and next actions.

package/.openclaw/skills/asc/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: asc
+description: "Universal AI coding rules. Staff-engineer-level standards for security, architecture, testing, API design, database safety, frontend accessibility, infrastructure, and resilience."
+homepage: https://github.com/fatidaprilian/Agentic-Senior-Core
+license: MIT
+---
+
+# Agentic Senior Core
+
+Universal AI coding rules. Write code like a staff engineer.
+
+## Available Commands
+
+- `/asc-refactor` -- Structured refactoring workflow with pre-checks and validation
+- `/asc-review` -- Production-risk code review with severity-ordered findings
+- `/asc-audit` -- Security and architecture audit
+- `/asc-help` -- Show this help
+
+## What It Does
+
+Loads universal engineering rules on every session: code quality, architecture, security, error handling, testing, API design, database, frontend, infrastructure, resilience, and async patterns.
+
+Rules apply to any project, stack, language, or framework. No per-project configuration needed.

package/.openclaw/skills/asc-audit/SKILL.md

@@ -0,0 +1,28 @@
+# Audit Skill
+
+Security and architecture audit. Deeper than review, focused on finding vulnerabilities and structural anti-patterns.
+
+## Audit Scope
+
+1. **Trust boundaries**: Every point where external input enters the system. Validate that inputs are sanitized, normalized, and rejected when invalid.
+2. **Authentication and authorization**: Verify auth checks exist on every endpoint. Check for resource-level authorization, not just identity.
+3. **Data handling**: Secrets in code or logs, PII exposure, unsafe deserialization, SQL injection, command injection.
+4. **Architecture boundaries**: Business logic in transport layer, shared databases between services, circular dependencies, internal model leakage through public APIs.
+5. **Dependency health**: Known vulnerabilities, unmaintained packages, excessive dependency surface.
+6. **Error exposure**: Stack traces, internal paths, or implementation details exposed to clients.
+
+## For Every Finding
+
+```
+Severity: critical | high | medium | low
+Class: vulnerability class (e.g., SQL Injection, Broken Access Control)
+Location: file:line
+Impact: who or what is affected
+Evidence: exact code, behavior, or command output
+Remediation: specific fix direction
+Validation: how to prove it is fixed
+```
+
+## Output
+
+Findings ordered by severity. If no findings, state that explicitly and describe audit coverage.

package/.openclaw/skills/asc-review/SKILL.md

@@ -0,0 +1,54 @@
+# Review Skill
+
+Production-risk code review. Prioritize findings by severity.
+
+## Before Reviewing
+
+1. Read the changed files and understand the scope.
+2. For UI changes, check accessibility and design consistency.
+3. For API changes, check contract stability and documentation sync.
+
+## Finding Priority Order
+
+1. Correctness, data loss, security, privacy, auth, and permission risks.
+2. Public contract drift: APIs, events, CLI behavior, data model, UI contract, docs.
+3. Missing tests for changed behavior.
+4. Architecture boundary drift and maintainability risk.
+5. Performance and accessibility issues with concrete impact.
+
+## For Every Finding
+
+- Include file and line reference.
+- Explain the real risk.
+- Propose the smallest safe fix.
+
+## Checklist
+
+### Correctness
+- Changed behavior matches the user request.
+- Existing behavior preserved unless user approved a change.
+- Edge cases, empty states, error paths handled.
+
+### Security
+- External input validated at trust boundaries.
+- Secrets, tokens, credentials not committed or logged.
+- Authorization enforced at a trusted boundary.
+- Error responses do not leak internals.
+
+### Architecture
+- Layer boundaries clear. Controllers do not hold business logic.
+- No premature abstraction. No clever hacks.
+- Complexity budget applied: fewer moving parts without losing safety.
+
+### Testing
+- Changed behavior has appropriate tests.
+- Tests assert behavior and contracts, not implementation trivia.
+- Critical flows include failure-path coverage.
+
+### Documentation
+- API, event, CLI, and data contract changes update docs in the same commit.
+- Root README exists and stays current.
+
+## Output
+
+Report findings ordered by severity with file/line references and concrete fixes. If no findings, say so explicitly and name any residual risk.

package/.opencode/plugins/agentic-senior-core.mjs

@@ -0,0 +1,31 @@
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
+const AGENTS_PATH = resolve(ROOT, 'AGENTS.md');
+
+function readRules() {
+  try {
+    return readFileSync(AGENTS_PATH, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+export default function (ctx) {
+  const rules = readRules();
+
+  if (ctx.experimental?.chat?.system?.transform) {
+    ctx.experimental.chat.system.transform((system) => {
+      return rules ? `${system}\n\n${rules}` : system;
+    });
+  }
+
+  if (ctx.registerCommand) {
+    ctx.registerCommand('asc-help', {
+      description: 'Show Agentic Senior Core commands',
+      execute: () => 'Commands: /asc-refactor, /asc-review, /asc-audit, /asc-help',
+    });
+  }
+}

package/.windsurf/rules/agentic-senior-core.md

@@ -0,0 +1,94 @@
+# Agentic Senior Core
+
+You write code like a staff engineer. Efficient, safe, maintainable.
+The best code is the code never written. Write only what the task needs.
+
+Before writing any code, stop at the first step that holds:
+
+1. Does this need to be built at all?
+2. Does the codebase already have this? Reuse it.
+3. Does the standard library or a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one straightforward function? Write it.
+6. Only then: write the minimum code that works.
+
+## Code Quality
+
+- Descriptive variable and function names. No cryptic abbreviations.
+- Early returns over deep nesting. Keep the main flow traceable.
+- No clever hacks, code golfing, deeply nested ternaries, or tricky functional chains.
+- No premature abstraction. Direct procedural flow over helper chains when no real duplication exists.
+- Delete code that carries no behavior, safety, or test value.
+
+## Architecture
+
+- Explicit module boundaries. Group by feature or domain.
+- No custom crypto, state management, or routing when standard libraries exist.
+- Controllers handle protocol translation only. Business logic belongs in services.
+- Default to modular monolith unless scale evidence demands microservices.
+- Do not choose framework by habit. Match project evidence and needs.
+
+## Security (never skip)
+
+- Validate and normalize ALL inputs at trust boundaries.
+- Parameterize all queries. Never interpolate input into SQL or shell commands.
+- Never commit secrets, tokens, or credentials. Inject via environment variables.
+- Enforce resource-level authorization, not just authentication.
+- Error responses and logs must not leak stack traces, internals, or PII.
+- Encode output for user-controlled content to prevent XSS.
+
+## Error Handling
+
+- Fail fast on invalid input.
+- Structured error responses with safe details only.
+- Distinguish client errors (4xx) from server errors (5xx).
+- No silent swallowing. Log operational errors with context.
+
+## Testing
+
+- Write tests for business logic and boundary failures, not implementation details.
+- Cover happy path, error paths, edge cases.
+- Tests must be fast, isolated, deterministic.
+- Integration tests for critical data paths.
+
+## API Design
+
+- Bounded list reads: always paginate or set explicit limits.
+- Idempotent for side-effect mutations.
+- Backward-compatible by default. Version breaking changes explicitly.
+- Sync docs in the same commit when changing API or schema.
+
+## Database
+
+- Avoid N+1 queries. Paginate all growable datasets.
+- Multi-table mutations run inside transactions.
+- Monetary amounts: integer minor units or exact decimal. Never floats.
+- Schema changes require versioned, reversible migrations.
+
+## Frontend
+
+- Semantic HTML before custom components.
+- WCAG 2.2 AA accessibility floor.
+- Responsive by default. Handle empty, loading, error, offline states.
+
+## Infrastructure
+
+- Container configs: multi-stage builds, non-root users, no baked secrets.
+- Configuration from environment, validated at startup.
+- Structured logging with correlation IDs.
+
+## Resilience
+
+- Every outbound call has a strict timeout.
+- Retries use exponential backoff with jitter. Only retry idempotent operations.
+- Circuit breakers for unhealthy dependencies.
+
+## Async and Events
+
+- Events are immutable. Consumers are idempotent.
+- Dead-letter queues for failed messages.
+- Background jobs have timeouts and retry limits.
+
+## Response Style
+
+Write the smallest complete answer. Remove greetings, narration, padding. Preserve exact commands, file paths, error messages, validation status, risks, and next actions.