@rockysoft/opencode-hybrid-workflow 0.0.0-stage → 0.3.2-beta.1

package/sidebar/settings.mjs

@@ -0,0 +1,99 @@
+import {SettingsRPC} from '../lib/settings-rpc.mjs';
+const unwrap=value=>value?.data??value;
+const label=lane=>lane?`${lane.adapter==='opencode'?lane.providerID:lane.adapter} / ${lane.model} / ${lane.variant??lane.effort??'default'}`:'Disabled';
+export function createSettingsUI(context,onSaved=()=>{}){
+ const rpc=context.client.rpc(SettingsRPC);let open=false,disposed=false;
+ const select=(title,options,current)=>context.ui.dialog.select({title,current,options});
+ const alert=(title,message)=>context.ui.dialog.alert({title,message});
+ async function invoke(method,input={}){const response=await rpc[method](input),value=unwrap(response);const error=response?.error??value?.error;if(error)throw Error(typeof error==='string'?error:error.message??'OpenCode could not complete this settings operation.');return value;}
+ function dispatch(name){
+  const commands=context.keymap.commands();
+  const command=commands.find(c=>c.slash?.name===name||c.slash?.aliases?.includes(name));
+  if(!command)throw Error(`OpenCode's ${name} menu is unavailable in this version.`);
+  context.keymap.dispatch(command.id);
+ }
+ async function reviewer(who,state,current){
+  const connection=await select(`Reviewer ${who==='astra'?1:2}: connection`,[{title:'OpenCode connected provider',value:'opencode',description:'Use an account already connected to OpenCode'},{title:'External CLI',value:'cli',description:'Codex CLI or Claude Code CLI login'}],!state.configured||current?.adapter==='opencode'?'opencode':'cli');
+  if(!connection)return;
+  if(connection==='opencode'){
+   const providers=[...new Set(state.catalog.map(m=>m.providerID))];
+   if(!providers.length){await alert('Connect a provider','No connected tool-capable models are available. Use Connect provider in Hybrid settings, then try again.');return;}
+   const provider=await select('Provider',providers.map(id=>({title:id,value:id})),current?.providerID);if(!provider)return;
+   const model=await select('Reviewer model',state.catalog.filter(m=>m.providerID===provider).map(m=>({title:m.name??m.id,value:m.id,description:m.id+(m.vision?' · images supported':' · text only')})),current?.model);if(!model)return;
+   const chosen=state.catalog.find(m=>m.providerID===provider&&m.id===model);
+   const variant=await select('Reasoning effort',[{title:'Provider default',value:'__default'},...chosen.variants.map(v=>({title:v,value:v}))],current?.variant??'__default');if(!variant)return;
+   return {adapter:'opencode',providerID:provider,model,...(variant==='__default'?{}:{variant})};
+  }
+  const adapter=await select('External CLI',[{title:'Codex CLI',value:'codex-cli'},{title:'Claude Code CLI',value:'claude-cli'}],current?.adapter);if(!adapter)return;
+  const model=await context.ui.dialog.prompt({title:'CLI model',placeholder:current?.adapter===adapter?current.model:adapter==='codex-cli'?'gpt-6-astra':'opus',value:current?.adapter===adapter?current.model:adapter==='codex-cli'?'gpt-6-astra':'opus'});if(!model?.trim())return;
+  const effort=await select('CLI reasoning effort',['low','medium','high','xhigh','max'].map(v=>({title:v,value:v})),current?.effort??'high');if(!effort)return;
+  return {adapter,model:model.trim(),effort};
+ }
+ async function wizard(state){
+  const count=await select('Hybrid setup: reviewers',[{title:'Two reviewers',value:2,description:'Independent planning and review'},{title:'One reviewer',value:1,description:'A single premium planner/reviewer'}],state.reviewers.opus?2:1);if(!count)return;
+  const first=await reviewer('astra',state,state.reviewers.astra);if(!first)return;
+  const second=count===2?await reviewer('opus',state,state.reviewers.opus):null;if(count===2&&!second)return;
+  const lead=count===1?'astra':await select('Planning and design lead',[{title:first.model,value:'astra',description:'Reviewer 1'},{title:second.model,value:'opus',description:'Reviewer 2'}],state.designAuthor);if(!lead)return;
+  const confirmed=await context.ui.dialog.confirm({title:'Save Hybrid setup',message:`Reviewer 1: ${label(first)}\nReviewer 2: ${label(second)}\nPlanning/design lead: ${lead==='astra'?first.model:second.model}\n\nSave for all projects. Active tasks retain their existing reviewers.`,label:{confirm:'Save',cancel:'Cancel'}});
+  if(!confirmed)return;
+  const result=await invoke('save',{revision:state.revision,reviewers:{astra:first,opus:second},designAuthor:lead});
+  onSaved();await alert('Hybrid setup saved',result.message+(result.preservedCustomFiles?.length?'\nExisting customized agents and skills were preserved.':''));
+ }
+ async function browser(state){
+  const action=await select('Reviewer browser',[
+   {title:state.browserEnabled?'Disable browser access':'Enable existing browser',value:state.browserEnabled?'disable':'enable'},
+   {title:'Install browser support',value:'install',description:'Download managed Playwright MCP and Firefox; enable reviewer access'},
+  ]);if(!action)return;
+  if(action==='install'&&!await context.ui.dialog.confirm({title:'Install browser support',message:'Download Playwright MCP and Firefox on the OpenCode server machine? Existing browser settings and user profiles will be preserved.',label:{confirm:'Install',cancel:'Cancel'}}))return;
+  context.ui.toast.show({message:action==='install'?'Installing browser support…':'Updating browser settings…',variant:'info'});
+  const result=await invoke('browser',{action});onSaved();await alert('Reviewer browser',result.message);
+ }
+ async function dependencies(){
+  const action=await select('Tools and dependencies',[
+   {title:'Install pnpm for verification',value:'pnpm',description:'Managed installation; does not replace your global pnpm'},
+   {title:'Enable Context7 documentation',value:'context7',description:'Configure official remote documentation MCP'},
+   {title:'System prerequisites',value:'system',description:'Node, Git, Python and optional CLI login guidance'},
+  ]);if(!action)return;
+  if(action==='system'){await alert('System prerequisites','OpenCode and Node 22+ are required. Git is needed for projects; Python 3 supports design research. External CLI choices also require that CLI and its official login. Diagnostics identifies what is missing. System installers and account sign-in remain machine/account setup; the plugin never copies credentials.');return;}
+  if(!await context.ui.dialog.confirm({title:'Set up dependency',message:action==='pnpm'?'Install managed pnpm on the OpenCode server?':'Add the official Context7 documentation MCP? Existing settings are preserved.',label:{confirm:'Set up',cancel:'Cancel'}}))return;
+  context.ui.toast.show({message:'Setting up dependency…',variant:'info'});const result=await invoke('dependencies',{action});await alert('Dependency setup',result.message);
+ }
+ async function show(firstRun=false){
+  if(open||disposed)return;open=true;
+  try{
+   let state=await invoke('get');
+   if(firstRun&&state.configured)return;
+   if(!state.configured){await wizard(state);state=await invoke('get');}
+   while(!disposed){
+    const action=await select(`Hybrid Workflow ${state.version}`, [
+     {title:state.configured?'Reviewers and design lead':'Complete setup',value:'reviewers',description:label(state.reviewers.astra)+' | '+label(state.reviewers.opus)},
+     {title:'Connect provider',value:'connect',description:'Open OpenCode’s account connection menu'},
+     {title:'Implementation model',value:'models',description:'Select the model that builds your code in OpenCode'},
+     {title:'Reviewer browser',value:'browser',description:state.browserEnabled?'Enabled · isolated sessions':'Disabled'},
+     {title:'Tools and dependencies',value:'dependencies',description:'Browser installation is in Reviewer browser'},
+     {title:'Run diagnostics',value:'diagnostics',description:'Check setup and logins without model calls'},
+     {title:'About this setup',value:'about',description:'Global configuration and active-task behavior'},
+    ]);
+    if(!action)return;
+    try{
+     if(action==='reviewers')await wizard(state);
+     else if(action==='connect'||action==='models'){dispatch(action);return;}
+     else if(action==='browser')await browser(state);
+     else if(action==='dependencies')await dependencies();
+     else if(action==='diagnostics'){
+      context.ui.toast.show({message:'Checking Hybrid setup…',variant:'info'});
+      const report=await invoke('diagnostics');
+      while(!disposed){
+       const item=await select('Hybrid diagnostics',report.checks.map((c,i)=>({title:`${c.ok?'OK':'Needs attention'} · ${c.name}`,value:String(i),description:c.detail.split('\n')[0]})));
+       if(item===undefined||item===null)break;
+       const check=report.checks[Number(item)];await alert(check.name,check.detail);
+      }
+     }else if(action==='about')await alert('Hybrid Workflow',`Global settings: ${state.configFile}\nServer platform: ${state.host}\nNew tasks use saved defaults. Active tasks preserve assigned reviewers, findings and history.\nAt least one pass and no unresolved medium/high/critical findings are required.\nSkills and agent rules are installed when setup is saved. No separate dashboard is needed.`);
+    }catch(error){await alert('Hybrid settings',error.message);}
+    state=await invoke('get');
+   }
+  }catch(error){context.ui.toast.show({message:'Hybrid settings: '+error.message,variant:'error'});}
+  finally{open=false;}
+ }
+ return {show,dispose(){disposed=true;},rpc};
+}

package/tui.js

@@ -0,0 +1,303 @@
+// Generated by npm run build; edit tui.tsx.
+import { memo as _$memo } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { Plugin } from '@opencode/plugin/tui';
+import { For, Show, createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
+import { readSettings } from './lib/config.mjs';
+import { createReader, cards, number, money } from './sidebar/reader.mjs';
+import { captureTotals } from './core/dashboard-state.js';
+import { createSettingsUI } from './sidebar/settings.mjs';
+export default Plugin.define({
+  id: 'personal.hybrid-usage',
+  setup(context) {
+    const preferences = createSettingsUI(context);
+    context.keymap.layer(() => ({
+      mode: 'global',
+      commands: [{
+        id: 'hybrid.settings',
+        title: 'Hybrid Workflow: settings',
+        group: 'Hybrid Workflow',
+        palette: true,
+        slash: {
+          name: 'hybrid'
+        },
+        run: () => preferences.show()
+      }]
+    }));
+    const home = context.ui.slot({
+      append: 'home.footer',
+      render: () => (() => {
+        var _el$ = _$createElement("text");
+        _$insertNode(_el$, _$createTextNode(`[Hybrid Workflow settings]`));
+        _$setProp(_el$, "onMouseDown", () => preferences.show());
+        _$effect(_$p => _$setProp(_el$, "fg", context.theme.text.muted, _$p));
+        return _el$;
+      })()
+    });
+    const firstRun = setTimeout(() => {
+      void preferences.show(true);
+    }, 750);
+    const config = readSettings(context.options);
+    const settings = {
+      ...config,
+      efforts: {
+        astra: config.codex?.variant ?? config.codex?.effort ?? 'default',
+        opus: config.claude?.variant ?? config.claude?.effort ?? 'default'
+      },
+      models: {
+        astra: config.codex?.model,
+        opus: config.claude?.model
+      }
+    };
+    const read = createReader(settings);
+    const [saved, update] = context.storage.store('totals', {
+      initial: {
+        resets: {}
+      }
+    });
+    function Usage(props) {
+      const [snapshot, setSnapshot] = createSignal(null);
+      const [error, setError] = createSignal('');
+      const location = createMemo(() => context.data.session.get(props.sessionID)?.location);
+      createEffect(() => {
+        const directory = location()?.directory;
+        let disposed = false,
+          busy = false;
+        setSnapshot(null);
+        setError('');
+        const poll = async () => {
+          if (busy || !directory) return;
+          busy = true;
+          try {
+            const next = await read(directory);
+            if (!disposed) {
+              setSnapshot(next);
+              setError('');
+            }
+          } catch {
+            if (!disposed) {
+              setSnapshot(null);
+              setError('Telemetry unavailable');
+            }
+          } finally {
+            busy = false;
+          }
+        };
+        void poll();
+        const timer = setInterval(poll, 3000);
+        onCleanup(() => {
+          disposed = true;
+          clearInterval(timer);
+        });
+      });
+      const totals = createMemo(() => snapshot() ? cards(snapshot(), saved.resets[snapshot().key]) : []);
+      async function clear() {
+        const value = snapshot();
+        if (!value) return;
+        try {
+          await update(draft => {
+            draft.resets[value.key] = captureTotals(value.calls);
+          });
+        } catch {
+          context.ui.toast.show({
+            message: 'Could not save usage reset',
+            variant: 'error'
+          });
+        }
+      }
+      async function restore() {
+        const value = snapshot();
+        if (!value) return;
+        try {
+          await update(draft => {
+            delete draft.resets[value.key];
+          });
+        } catch {
+          context.ui.toast.show({
+            message: 'Could not restore usage totals',
+            variant: 'error'
+          });
+        }
+      }
+      context.keymap.layer(() => ({
+        mode: 'global',
+        commands: [{
+          id: 'hybrid-usage.clear',
+          title: 'Hybrid usage: clear totals for this project',
+          palette: true,
+          slash: {
+            name: 'hybrid-clear'
+          },
+          run: clear
+        }, {
+          id: 'hybrid-usage.restore',
+          title: 'Hybrid usage: restore totals for this project',
+          palette: true,
+          slash: {
+            name: 'hybrid-restore'
+          },
+          run: restore
+        }]
+      }));
+      return (() => {
+        var _el$3 = _$createElement("box"),
+          _el$4 = _$createElement("text");
+        _$insertNode(_el$3, _el$4);
+        _$setProp(_el$3, "flexDirection", "column");
+        _$setProp(_el$3, "gap", 1);
+        _$insertNode(_el$4, _$createTextNode(`[Hybrid Workflow settings]`));
+        _$setProp(_el$4, "onMouseDown", () => preferences.show());
+        _$insert(_el$3, _$createComponent(Show, {
+          get when() {
+            return error();
+          },
+          get children() {
+            var _el$6 = _$createElement("text");
+            _$insert(_el$6, error);
+            _$effect(_$p => _$setProp(_el$6, "fg", context.theme.text.muted, _$p));
+            return _el$6;
+          }
+        }), null);
+        _$insert(_el$3, _$createComponent(For, {
+          get each() {
+            return totals();
+          },
+          children: card => (() => {
+            var _el$11 = _$createElement("box"),
+              _el$12 = _$createElement("text"),
+              _el$13 = _$createElement("b"),
+              _el$14 = _$createTextNode(` · `),
+              _el$15 = _$createElement("text"),
+              _el$16 = _$createTextNode(` tokens · `),
+              _el$17 = _$createElement("text"),
+              _el$18 = _$createElement("text"),
+              _el$19 = _$createTextNode(`Input: `),
+              _el$20 = _$createElement("text"),
+              _el$21 = _$createTextNode(`Output: `),
+              _el$22 = _$createElement("text"),
+              _el$23 = _$createTextNode(`Cache: `);
+            _$insertNode(_el$11, _el$12);
+            _$insertNode(_el$11, _el$15);
+            _$insertNode(_el$11, _el$17);
+            _$insertNode(_el$11, _el$18);
+            _$insertNode(_el$11, _el$20);
+            _$insertNode(_el$11, _el$22);
+            _$setProp(_el$11, "flexDirection", "column");
+            _$insertNode(_el$12, _el$13);
+            _$insertNode(_el$13, _el$14);
+            _$insert(_el$13, () => card.model ?? settings.models[card.who], _el$14);
+            _$insert(_el$13, () => card.effort, null);
+            _$insertNode(_el$15, _el$16);
+            _$insert(_el$15, () => number(card.total), _el$16);
+            _$insert(_el$15, () => card.status, null);
+            _$insert(_el$17, () => money(card.cost));
+            _$insertNode(_el$18, _el$19);
+            _$insert(_el$18, () => number(card.input), null);
+            _$insertNode(_el$20, _el$21);
+            _$insert(_el$20, () => number(card.output), null);
+            _$insertNode(_el$22, _el$23);
+            _$insert(_el$22, () => number(card.cache), null);
+            _$insert(_el$11, _$createComponent(Show, {
+              get when() {
+                return card.partial;
+              },
+              get children() {
+                var _el$24 = _$createElement("text"),
+                  _el$25 = _$createTextNode(`Partial · `),
+                  _el$26 = _$createTextNode(`/`),
+                  _el$27 = _$createTextNode(` measured`);
+                _$insertNode(_el$24, _el$25);
+                _$insertNode(_el$24, _el$26);
+                _$insertNode(_el$24, _el$27);
+                _$insert(_el$24, () => card.measuredCalls, _el$26);
+                _$insert(_el$24, () => card.calls, _el$27);
+                _$effect(_$p => _$setProp(_el$24, "fg", context.theme.text.muted, _$p));
+                return _el$24;
+              }
+            }), null);
+            _$effect(_p$ => {
+              var _v$ = context.theme.text.base,
+                _v$2 = context.theme.text.base,
+                _v$3 = context.theme.text.base,
+                _v$4 = context.theme.text.muted,
+                _v$5 = context.theme.text.muted,
+                _v$6 = context.theme.text.muted;
+              _v$ !== _p$.e && (_p$.e = _$setProp(_el$12, "fg", _v$, _p$.e));
+              _v$2 !== _p$.t && (_p$.t = _$setProp(_el$15, "fg", _v$2, _p$.t));
+              _v$3 !== _p$.a && (_p$.a = _$setProp(_el$17, "fg", _v$3, _p$.a));
+              _v$4 !== _p$.o && (_p$.o = _$setProp(_el$18, "fg", _v$4, _p$.o));
+              _v$5 !== _p$.i && (_p$.i = _$setProp(_el$20, "fg", _v$5, _p$.i));
+              _v$6 !== _p$.n && (_p$.n = _$setProp(_el$22, "fg", _v$6, _p$.n));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined,
+              a: undefined,
+              o: undefined,
+              i: undefined,
+              n: undefined
+            });
+            return _el$11;
+          })()
+        }), null);
+        _$insert(_el$3, _$createComponent(Show, {
+          get when() {
+            return snapshot();
+          },
+          get children() {
+            return [(() => {
+              var _el$7 = _$createElement("text");
+              _$insert(_el$7, () => snapshot().task ? 'Project bridge usage · USD' : 'No bridge calls in this project');
+              _$effect(_$p => _$setProp(_el$7, "fg", context.theme.text.muted, _$p));
+              return _el$7;
+            })(), (() => {
+              var _el$8 = _$createElement("box"),
+                _el$9 = _$createElement("text");
+              _$insertNode(_el$8, _el$9);
+              _$setProp(_el$8, "flexDirection", "row");
+              _$setProp(_el$8, "gap", 2);
+              _$insertNode(_el$9, _$createTextNode(`[Clear totals]`));
+              _$setProp(_el$9, "onMouseDown", clear);
+              _$insert(_el$8, _$createComponent(Show, {
+                get when() {
+                  return saved.resets[snapshot()?.key];
+                },
+                get children() {
+                  var _el$1 = _$createElement("text");
+                  _$insertNode(_el$1, _$createTextNode(`[Restore]`));
+                  _$setProp(_el$1, "onMouseDown", restore);
+                  _$effect(_$p => _$setProp(_el$1, "fg", context.theme.text.muted, _$p));
+                  return _el$1;
+                }
+              }), null);
+              _$effect(_$p => _$setProp(_el$9, "fg", context.theme.text.muted, _$p));
+              return _el$8;
+            })()];
+          }
+        }), null);
+        _$effect(_$p => _$setProp(_el$4, "fg", context.theme.text.muted, _$p));
+        return _el$3;
+      })();
+    }
+    const sidebar = context.ui.slot({
+      append: 'sidebar.content',
+      render: props => _$createComponent(Usage, {
+        get sessionID() {
+          return props.sessionID;
+        }
+      })
+    });
+    return () => {
+      clearTimeout(firstRun);
+      preferences.dispose();
+      home?.();
+      sidebar?.();
+    };
+  }
+});