💎 Dicas avançadas

Toda string visível no app passa por useT(). Não existe string hard-coded em JSX, label=, placeholder= ou aria-label=. Adicionar uma chave é mais trabalhoso do que parece — e o CI vai pegar se você esquecer.

const t = useT();
<button aria-label={t('chat.send')}>
  {t('chat.send_label')}
</button>

<button aria-label="Send">
  Send
</button>
// CI: i18n violation

import(), React.lazy(() => import(...)) e await import(...) são banidos em app/src de produção. Bundle precisa ser previsível — sem chunk loading runtime que pode falhar offline.

// ❌ Dynamic import direto
const mod = await import('./heavy');

// ❌ React.lazy
const Heavy = React.lazy(
  () => import('./Heavy')
);

// ❌ Lazy route
const Settings = lazy(
  () => import('./Settings')
);

// ✅ Static import
import { Heavy } from './Heavy';

// ✅ Guard em runtime
try {
  Heavy.maybeInit();
} catch { /* opt-out */ }

// ✅ import type sempre OK
import type { Foo } from './types';

Filosofia Unix do projeto: módulos pequenos com responsabilidade afiada compostos por boundaries claros. Acima de ~500 linhas, dividir. Cada arquivo deve caber na cabeça.

src/openhuman/memory/
├── mod.rs        # só declara módulos + re-exports (light!)
├── types.rs      # structs, enums, traits
├── store.rs      # persistência
├── ops.rs        # operações (lógica)
├── rpc.rs        # handlers JSON-RPC
├── schemas.rs    # ControllerSchema
└── bus.rs        # EventHandler subscribers

Para expor features ao CLI e JSON-RPC, registre via controller registry. Branches manuais em src/core/cli.rs ou src/core/jsonrpc.rs são proibidos — reintroduzem o acoplamento que controllers vieram resolver.

// src/openhuman/cron/mod.rs
mod ops;
mod rpc;
mod schemas;
mod store;
mod types;
mod bus;

pub use schemas::{
    all_controller_schemas as all_cron_controller_schemas,
    all_registered_controllers as all_cron_registered_controllers,
};

// src/core/dispatch.rs
match method {
    "openhuman.cron_list" => handle_cron_list(...),  // ❌ NUNCA
    "openhuman.cron_create" => handle_cron_create(...), // ❌ NUNCA
    // ...
}

Regra: mod.rs declara módulos e re-exports. Nada mais. Lógica vai em ops.rs, store.rs, types.rs. Novos arquivos em src/openhuman/ root também são proibidos — tudo em subdiretório dedicado.

// src/openhuman/skills/mod.rs
mod inject;
mod ops_create;
mod ops_discover;
mod ops_install;
mod ops_parse;
mod schemas;
mod types;

pub use types::*;
pub use schemas::*;

mod helpers;

pub struct Skill { ... }     // ❌
pub fn install(...) { ... }  // ❌
async fn do_thing() { ... }  // ❌
// 400 linhas misturadas

Tipos passados pelo event bus precisam ser Send + 'static e owned — Arc, mpsc::Sender, oneshot::Sender, owned fields. Não Serialize (é in-process, não JSON-RPC), não borrows (lifetimes não vivem em canal).

// 1. Tipos owned, sem borrows
pub struct SendMessageRequest {
    pub channel_id: ChannelId,           // owned
    pub text: String,                    // owned
    pub reply: oneshot::Sender<Result>,  // owned
}

// 2. Registrar no startup
register_native_global("channel.send", Arc::new(ChannelSendHandler::new()));

// 3. Chamar de qualquer lugar
let (tx, rx) = oneshot::channel();
request_native_global("channel.send", SendMessageRequest {
    channel_id, text, reply: tx
}).await?;
let result = rx.await?;

Webviews CEF que carregam origens de terceiros (whatsapp, slack, telegram, discord, browserscan) não recebem nenhum JavaScript novo. Tudo via CDP nativo. Esta regra é intencional — surface de ataque + fragilidade de scraping.

// app/src-tauri/src/lib.rs
tauri::Builder::default()
    .plugin(
        tauri_plugin_opener::Builder::new()
            .open_js_links_on_click(false)  // ✅ opt-out
            .build()
    )