@jetrabbits/agentic 0.0.1

package/extensions/opencode/opencode.json

@@ -0,0 +1,93 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    "model-checker",
+    "sound-notification",
+    "telegram-notification"
+  ],
+  "agent": {
+    "product-owner": {
+      "description": "Main coordinator for feature development workflow",
+      "mode": "primary",
+      "model": "google/antigravity-claude-sonnet-4-6",
+      "fallback": [
+        "openai/gpt-5.4",
+        "opencode/minimax-m2.5-free"
+      ],
+      "permission": {
+        "task": {
+          "pm": "allow",
+          "team-lead": "allow",
+          "designer": "allow",
+          "developer": "allow",
+          "qa": "allow"
+        }
+      }
+    },
+    "pm": {
+      "description": "Project Manager - coordinates workflow",
+      "mode": "subagent",
+      "model": "google/antigravity-claude-sonnet-4-6",
+      "fallback": [
+        "openai/gpt-5.4",
+        "opencode/minimax-m2.5-free"
+      ],
+      "permission": {
+        "task": {
+          "team-lead": "allow",
+          "designer": "allow",
+          "developer": "allow",
+          "qa": "allow"
+        }
+      }
+    },
+    "team-lead": {
+      "description": "Team Lead - planning and code review",
+      "mode": "subagent",
+      "model": "google/antigravity-claude-opus-4-6-thinking",
+      "fallback": [
+        "openai/gpt-5.3-codex"
+      ],
+      "permission": {
+        "task": {
+          "developer": "allow",
+          "qa": "allow"
+        }
+      }
+    },
+    "developer": {
+      "description": "Developer - implements code",
+      "mode": "subagent",
+      "model": "google/antigravity-claude-opus-4-6-thinking",
+      "fallback": [
+        "openai/gpt-5.3-codex"
+      ]
+    },
+    "devops-engineer": {
+      "description": "DevOps Engineer - infrastructure, CI/CD, and platform reliability",
+      "mode": "subagent",
+      "model": "google/antigravity-claude-opus-4-6-thinking",
+      "fallback": [
+        "openai/gpt-5.3-codex"
+      ]
+    },
+    "qa": {
+      "description": "QA Engineer - runs tests",
+      "mode": "subagent",
+      "model": "google/antigravity-gemini-3-flash",
+      "fallback": [
+        "opencode/minimax-m2.5-free",
+        "openai/gpt-5.4"
+      ]
+    },
+    "designer": {
+      "description": "Designer - UI/UX validation",
+      "mode": "subagent",
+      "model": "google/antigravity-claude-sonnet-4-6",
+      "fallback": [
+        "opencode/minimax-m2.5-free",
+        "openai/gpt-5.4"
+      ]
+    }
+  }
+}

package/extensions/opencode/plugins/model-checker.json

@@ -0,0 +1,14 @@
+{
+  "models": [
+    "openai/gpt-5.3-codex",
+    "openai/gpt-5.4",
+    "opencode/big-pickle",
+    "opencode/minimax-m2.5-free",
+    "google/antigravity-claude-opus-4-6-thinking",
+    "google/antigravity-claude-sonnet-4-6",
+    "google/antigravity-gemini-3-flash",
+    "google/antigravity-gemini-3.1-pro"
+  ],
+  "timeoutMs": 10000,
+  "concurrency": 10
+}

package/extensions/opencode/plugins/model-checker.ts

@@ -0,0 +1,279 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { spawn } from "node:child_process"
+
+interface ModelResult {
+  model: string
+  status: "passed" | "failed"
+  error?: string
+}
+
+interface ModelCheckerConfig {
+  models: string[]
+  timeoutMs: number
+  concurrency: number
+  prompt: string
+  probeDir: string
+}
+
+type CommandResult = {
+  code: number | null
+  output: string
+  timedOut: boolean
+  durationMs: number
+}
+
+async function readModelsJson(projectDir: string): Promise<ModelCheckerConfig> {
+  const defaults: ModelCheckerConfig = {
+    models: [],
+    timeoutMs: 10000,
+    concurrency: 3,
+    prompt: "Reply with exactly: OK",
+    probeDir: tmpdir(),
+  }
+
+  try {
+    const filePath = join(projectDir, ".opencode", "plugins", "model-checker.json")
+    const content = await readFile(filePath, "utf-8")
+    const data = JSON.parse(content)
+    if (!Array.isArray(data.models)) return defaults
+
+    const models = [...new Set(data.models.map(String).filter(Boolean))]
+    const timeoutMs = Number.isFinite(data.timeoutMs)
+      ? Math.min(120000, Math.max(1000, Number(data.timeoutMs)))
+      : defaults.timeoutMs
+    const concurrency = Number.isFinite(data.concurrency)
+      ? Math.min(10, Math.max(1, Number(data.concurrency)))
+      : defaults.concurrency
+    const prompt = typeof data.prompt === "string" && data.prompt.trim() ? data.prompt.trim() : defaults.prompt
+    const probeDir = typeof data.probeDir === "string" && data.probeDir.trim() ? data.probeDir.trim() : defaults.probeDir
+
+    return {
+      models,
+      timeoutMs,
+      concurrency,
+      prompt,
+      probeDir,
+    }
+  } catch {
+    return defaults
+  }
+}
+
+async function runModelProbe(model: string, prompt: string, timeoutMs: number, probeDir: string): Promise<CommandResult> {
+  return await new Promise((resolve) => {
+    const startedAt = Date.now()
+    const child = spawn("opencode", ["run", prompt, "-m", model, "--dir", probeDir, "--log-level", "ERROR"], {
+      cwd: probeDir,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        OPENCODE_MODEL_CHECKER_ACTIVE: "1",
+      },
+    })
+
+    let stdout = ""
+    let stderr = ""
+    let timedOut = false
+
+    const timer = setTimeout(() => {
+      timedOut = true
+      child.kill("SIGKILL")
+    }, timeoutMs)
+
+    child.stdout.on("data", (chunk: Buffer | string) => {
+      stdout += chunk.toString()
+    })
+
+    child.stderr.on("data", (chunk: Buffer | string) => {
+      stderr += chunk.toString()
+    })
+
+    child.on("close", (code) => {
+      clearTimeout(timer)
+      resolve({
+        code,
+        timedOut,
+        output: `${stdout}\n${stderr}`.toLowerCase(),
+        durationMs: Date.now() - startedAt,
+      })
+    })
+
+    child.on("error", (error) => {
+      clearTimeout(timer)
+      resolve({
+        code: 1,
+        timedOut,
+        output: String(error).toLowerCase(),
+        durationMs: Date.now() - startedAt,
+      })
+    })
+  })
+}
+
+async function runModelChecks(
+  models: string[],
+  prompt: string,
+  timeoutMs: number,
+  concurrency: number,
+  probeDir: string,
+): Promise<CommandResult[]> {
+  const workers = Math.min(concurrency, models.length)
+  const results: CommandResult[] = new Array(models.length)
+  let cursor = 0
+
+  await Promise.all(
+    Array.from({ length: workers }, async () => {
+      while (true) {
+        const index = cursor++
+        if (index >= models.length) return
+        results[index] = await runModelProbe(models[index], prompt, timeoutMs, probeDir)
+      }
+    }),
+  )
+
+  return results
+}
+
+function classifyResult(model: string, probe: CommandResult): ModelResult {
+  if (probe.timedOut) return { model, status: "failed", error: "timeout" }
+
+  if (probe.output.includes("quota") || probe.output.includes("insufficient") || probe.output.includes("429")) {
+    return { model, status: "failed", error: "quota" }
+  }
+
+  if (probe.code !== 0) {
+    if (/(\b4\d\d\b|\b5\d\d\b)/.test(probe.output)) {
+      return { model, status: "failed", error: "provider error" }
+    }
+    return { model, status: "failed", error: `exit code ${probe.code ?? "null"}` }
+  }
+
+  if (!probe.output.includes("ok")) {
+    return { model, status: "failed", error: "unexpected response" }
+  }
+
+  return { model, status: "passed" }
+}
+
+function printLists(passed: ModelResult[], failed: ModelResult[]) {
+  console.log("\npassed_models:")
+  for (const model of passed) {
+    console.log(`- ${model.model}`)
+  }
+
+  console.log("\nfailed_models:")
+  for (const model of failed) {
+    console.log(`- ${model.model}${model.error ? ` (${model.error})` : ""}`)
+  }
+}
+
+function formatTelegramMessage(passed: ModelResult[], failed: ModelResult[], selected: string): string {
+  const passedText = passed.length ? passed.map((x) => `• ${x.model}`).join("\n") : "(none)"
+  const failedText = failed.length
+    ? failed.map((x) => `• ${x.model}${x.error ? ` (${x.error})` : ""}`).join("\n")
+    : "(none)"
+
+  return [
+    "<b>LLM availability check</b>",
+    "",
+    `<b>passed_models (${passed.length})</b>`,
+    passedText,
+    "",
+    `<b>failed_models (${failed.length})</b>`,
+    failedText,
+    "",
+    `<b>selected model:</b> ${selected}`,
+  ].join("\n")
+}
+
+async function sendTelegram(message: string) {
+  const token = process.env.OPENCODE_TELEGRAM_BOT_TOKEN
+  const chatID = process.env.OPENCODE_TELEGRAM_CHAT_ID
+  if (!token || !chatID) return
+
+  try {
+    await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        chat_id: chatID,
+        text: message,
+        parse_mode: "HTML",
+      }),
+    })
+  } catch {
+    // no-op
+  }
+}
+
+async function regenerateOpencodeJson(projectDir: string, selected: string, passed: string[]) {
+  const filePath = join(projectDir, ".opencode", "opencode.json")
+  try {
+    const content = await readFile(filePath, "utf-8")
+    const config = JSON.parse(content)
+
+    if (!config.agent || typeof config.agent !== "object") return
+
+    for (const [agentName, agentConfig] of Object.entries<any>(config.agent)) {
+      if (!agentConfig || typeof agentConfig !== "object") continue
+      if (agentConfig.mode !== "subagent") continue
+
+      config.agent[agentName].model = selected
+    }
+
+    await writeFile(filePath, `${JSON.stringify(config, null, 2)}\n`, "utf-8")
+  } catch {
+    // no-op
+  }
+}
+
+export const ModelCheckerPlugin: Plugin = async ({ directory }) => {
+  if (process.env.OPENCODE_MODEL_CHECKER_ACTIVE === "1") {
+    return {}
+  }
+
+  if (process.argv[2] === "run") {
+    return {}
+  }
+
+  async function runChecks() {
+    const config = await readModelsJson(directory)
+    const { models, prompt, timeoutMs, concurrency, probeDir } = config
+    if (!models.length) return
+
+    await mkdir(probeDir, { recursive: true })
+
+    console.log("\nStarting LLM model availability check...")
+    console.log(`- models: ${models.length}, concurrency: ${Math.min(concurrency, models.length)}, timeout: ${timeoutMs}ms`)
+    const results: ModelResult[] = []
+    const probes = await runModelChecks(models, prompt, timeoutMs, concurrency, probeDir)
+    for (const [index, model] of models.entries()) {
+      const probe = probes[index]
+      const result = classifyResult(model, probe)
+      results.push(result)
+      console.log(
+        `- checking ${model}... ${result.status === "passed" ? "OK" : `FAIL (${result.error})`} (${probe.durationMs}ms)`,
+      )
+    }
+
+    const passedModels = results.filter((x) => x.status === "passed")
+    const failedModels = results.filter((x) => x.status === "failed")
+    const selected = passedModels[0]?.model ?? "none"
+
+    printLists(passedModels, failedModels)
+    console.log(`\nselected_model: ${selected}`)
+
+    if (selected !== "none") {
+      await regenerateOpencodeJson(directory, selected, passedModels.map((x) => x.model))
+    }
+
+    await sendTelegram(formatTelegramMessage(passedModels, failedModels, selected))
+  }
+
+  await runChecks()
+
+  return {}
+}

package/extensions/opencode/plugins/sound-notification.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from "@opencode-ai/plugin"
+
+export const SoundNotificationPlugin: Plugin = async ({ $ }) => {
+  return {
+    event: async ({ event }) => {
+      if (event.type === "session.idle") {
+        try {
+          await $`afplay /System/Library/Sounds/Glass.aiff`
+        } catch {}
+      }
+    },
+  }
+}

package/extensions/opencode/plugins/telegram-notification.ts

@@ -0,0 +1,86 @@
+import type { Plugin } from "@opencode-ai/plugin"
+
+export const TelegramNotificationPlugin: Plugin = async ({ $, client, directory }) => {
+  return {
+    event: async ({ event }) => {
+      if (event.type === "session.idle") {
+        const botToken = process.env.OPENCODE_TELEGRAM_BOT_TOKEN
+        const chatId = process.env.OPENCODE_TELEGRAM_CHAT_ID
+
+        if (!botToken || !chatId) return
+
+        const sessionID = event.properties.sessionID
+        let messageText = "✅ Задача завершена"
+        let fullText = ""
+
+        try {
+          const sessionResult = await client.session.get({ path: { id: sessionID } })
+          const session = sessionResult.data
+
+          if (!sessionResult.error && session) {
+            messageText = `✅ ${session.title || "Задача завершена"}`
+
+            if (session.summary) {
+              messageText += `\n📊 +${session.summary.additions} -${session.summary.deletions} в ${session.summary.files} файл(ах)`
+            }
+
+            const messagesResult = await client.session.messages({ path: { id: sessionID } })
+            if (!messagesResult.error && messagesResult.data?.length) {
+              const lastMessage = messagesResult.data[messagesResult.data.length - 1]
+              const textParts = lastMessage.parts?.filter(p => p.type === "text") || []
+              fullText = textParts.map(p => (p as any).text).join("")
+            }
+          }
+        } catch (e) {
+          await $`echo "Error: ${e}" >> ${directory}/.opencode/telegram-debug.log`
+        }
+
+        try {
+          if (fullText.length >= 4096) {
+            const formData = new FormData()
+            formData.append("chat_id", chatId)
+            formData.append(
+              "document",
+              new Blob([fullText], { type: "text/markdown" }),
+              `response-${sessionID.slice(0, 8)}.md`
+            )
+
+            await fetch(
+              `https://api.telegram.org/bot${botToken}/sendDocument`,
+              { method: "POST", body: formData }
+            )
+
+            const shortText = fullText.slice(0, 3000)
+            await fetch(
+              `https://api.telegram.org/bot${botToken}/sendMessage`,
+              {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                  chat_id: chatId,
+                  text: `${messageText}\n\n📎 Полный ответ в attachment (${fullText.length} символов):\n\n${shortText}...`
+                })
+              }
+            )
+          } else {
+            const textToSend = fullText
+              ? `${messageText}\n\n${fullText}`
+              : messageText
+
+            await fetch(
+              `https://api.telegram.org/bot${botToken}/sendMessage`,
+              {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                  chat_id: chatId,
+                  text: textToSend.slice(0, 4096)
+                })
+              }
+            )
+          }
+        } catch {}
+      }
+    },
+  }
+}

package/extensions/opencode/skills/code_review_expert/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: code_review_expert
+description: "Code Review Expert for static analysis, security auditing, architecture review, and ensuring code quality standards."
+metadata:
+  model: inherit
+  risk: unknown
+  source: community
+---
+
+## Purpose
+Expert code reviewer specializing in static analysis, security auditing, architecture review, and ensuring code quality for Flutter/Dart applications. Validates that code meets team standards and is production-ready.
+
+## Use this skill when
+- Performing code reviews
+- Conducting security audits
+- Reviewing architecture decisions
+- Running static analysis tools
+- Validating code quality standards
+- Checking code for vulnerabilities
+
+## Do not use this skill when
+- Writing new code (use flutter_expert for that)
+- Only unit testing (use qa_expert for that)
+
+## Capabilities
+
+### Static Analysis
+- **flutter analyze**: Dart static analysis
+- **dart analyze**: Type checking and linting
+- **Custom lints**: Team-specific rules
+- **Dead code detection**: Unused imports, variables
+- **Performance anti-patterns**: Inefficient patterns
+
+### Security Auditing
+- **OWASP Mobile Top 10**: Security vulnerability detection
+- **Secret detection**: API keys, tokens in code
+- **Input validation**: User input sanitization
+- **Authentication flows**: Security validation
+- **Data storage**: Secure storage practices
+- **Network security**: Certificate pinning, HTTPS
+
+### Architecture Review
+- **Clean Architecture**: Layer separation validation
+- **SOLID principles**: Code design compliance
+- **Dependency injection**: Proper usage
+- **State management**: Appropriate pattern usage
+- **Error handling**: Consistent error management
+
+### Code Quality Standards
+- **Code style**: Flutter/Dart conventions
+- **Documentation**: Public API docs
+- **Naming conventions**: Clear, consistent names
+- **Complexity**: Cyclomatic complexity limits
+- **Testability**: Code testability assessment
+
+### Build & Deployment Validation
+- **Build verification**: `flutter build apk --debug`
+- **Lint checks**: `flutter analyze`
+- **Test execution**: `flutter test`
+- **Bundle size**: APK size validation
+
+## Behavioral Traits
+- Provides constructive, actionable feedback
+- Focuses on critical issues first
+- Validates security from the start
+- Ensures code is maintainable
+- Approves only production-ready code
+
+## Response Approach
+1. **Run static analysis** - flutter analyze
+2. **Review code structure** - architecture compliance
+3. **Check security** - vulnerability scan
+4. **Validate tests** - test quality and coverage
+5. **Check build** - ensure compilation success
+6. **Provide verdict** - approve or request changes
+
+## Code Review Checklist
+
+### Critical (Must Fix)
+- [ ] Security vulnerabilities
+- [ ] Crashes or runtime errors
+- [ ] Memory leaks
+- [ ] Data loss risks
+
+### Major (Should Fix)
+- [ ] Code style violations
+- [ ] Missing documentation
+- [ ] Performance issues
+- [ ] Test coverage < 80%
+
+### Minor (Nice to Fix)
+- [ ] Naming improvements
+- [ ] Code simplifications
+- [ ] Comment improvements
+
+## Security Checkpoints
+
+```dart
+// ❌ BAD: Hardcoded secrets
+const apiKey = 'sk-1234567890';
+
+// ✅ GOOD: Environment variables
+final apiKey = const String.fromEnvironment('API_KEY');
+
+// ❌ BAD: Insecure storage
+SharedPreferences.setMockInitialValues({});
+final prefs = await SharedPreferences.getInstance();
+prefs.setString('token', token);
+
+// ✅ GOOD: Secure storage
+final secureStorage = SecureStorage();
+await secureStorage.write(key: 'token', value: token);
+```
+
+## Verdict Format
+
+### Code Review Report
+```
+| Check | Status | Notes |
+|-------|--------|-------|
+| Static Analysis | ✅/❌ | X warnings, Y errors |
+| Security Audit | ✅/❌ | X vulnerabilities found |
+| Architecture | ✅/❌ | Clean Architecture compliant |
+| Code Quality | ✅/❌ | Team standards met |
+| Tests | ✅/❌ | X tests, XX% coverage |
+| Build | ✅/❌ | Builds successfully |
+
+### Final Verdict
+[APPROVED / REQUEST_CHANGES]
+
+Comments:
+- Issue 1: ...
+- Issue 2: ...
+
+### Feature Feasibility
+[FEASIBLE / NOT_FEASIBLE]
+
+Reasoning:
+- Design is implementable: Yes/No
+- Technical constraints: ...
+- Risks: ...
+```
+
+Always provide clear approval or rejection with detailed reasoning.

package/extensions/opencode/skills/design_expert/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: design_expert
+description: "Expert UI/UX design intelligence for creating distinctive, high-craft, and mobile-first interfaces. Focuses on premium aesthetics, touch-first ergonomics, and Flutter performance."
+metadata:
+  model: inherit
+---
+
+# Design Expert UX/UI (Distinctive, Production-Grade)
+
+You are a **designer-engineer** specializing in high-end, memorable interfaces that feel premium and intentional. Your goal is to move beyond generic layouts and "AI design" tropes.
+
+## 1. Core Mandates
+- **Intentional Aesthetic**: Every design must have a named direction (e.g., *luxury minimal*, *industrial utilitarian*, *editorial brutalism*).
+- **Visual Memorability**: Include at least one element or interaction that defines the project's identity.
+- **Cohesive Restraint**: No random decoration. Every flourish must serve the aesthetic thesis.
+
+## 2. Mobile & UX Psychology
+- **Finger != Cursor**: Minimum touch targets 44-48px.
+- **Thumb Zone**: Primary actions must be easily reachable by thumbs.
+- **Fitts’ Law**: Reachability matters more than precision. Destructive actions should be harder to reach accidentally.
+
+## 3. Flutter Performance Doctrine
+- **`const` Everywhere**: Use constant constructors to minimize widget rebuilds.
+- **Targeted Rebuilds**: Use specialized providers (Riverpod/Bloc) to rebuild only what's necessary.
+- **ListView.builder**: Never use `ScrollView` for long lists; always use builders for lazy rendering.
+
+## 4. Aesthetic Execution Tools
+- **Typography Strategy**: Use one expressive display font for headlines and one restrained body font. Avoid system defaults.
+- **Spatial Composition**: White space is a design element, not "empty" space. Break the grid occasionally for emphasis.
+- **Texture & Depth**: Use noise, grain, layered translucency, or custom shadows with narrative intent.
+
+## 5. Required Design Thinking Phase
+Before writing code, define:
+1. **Purpose**: What is the core user feeling this interface should evoke? (Trust, excitement, calm).
+2. **Differentiation Anchor**: "If the logo were removed, how would a user recognize this design?"
+3. **Tone**: Choose one dominant direction (Luxury, Brutalist, Playful, etc.). Do not blend more than two.
+
+## 6. Anti-Patterns (Immediate Failure)
+❌ Purple-on-white SaaS gradients.
+❌ Generic "AI-generated" symmetrical layouts.
+❌ Inter/Roboto/System fonts without a specific reason.
+❌ Decoration without intent.