npcsh 1.1.21__py3-none-any.whl → 1.1.23__py3-none-any.whl

npcsh/npc_team/jinxs/modes/kg.jinx

@@ -1,7 +1,11 @@
 jinx_name: kg
 description: Interactive knowledge graph browser - explore facts, concepts, and links
 interactive: true
-inputs: []
+inputs:
+  - action: ""
+  - dream: false
+  - backfill: false
+  - ops: ""
 steps:
   - name: kg_browser
     engine: python
@@ -12,7 +16,70 @@ steps:
       import termios
       import select
 
-      if not sys.stdin.isatty():
+      _kg_action = (context.get('action') or '').strip().lower()
+
+      if _kg_action in ('sleep', 'evolve', 'dream'):
+          # Route to KG evolution operations
+          import traceback
+          from npcpy.memory.command_history import CommandHistory, load_kg_from_db, save_kg_to_db
+          from npcpy.memory.knowledge_graph import kg_sleep_process, kg_dream_process, kg_backfill_from_memories
+
+          _npc = context.get('npc')
+          _team = context.get('team')
+          _msgs = context.get('messages', [])
+          _do_dream = _kg_action == 'dream' or str(context.get('dream', '')).lower() in ('true', '1', 'yes')
+          _do_backfill = str(context.get('backfill', '')).lower() in ('true', '1', 'yes')
+          _ops_str = context.get('ops', '')
+          _ops_config = [op.strip() for op in _ops_str.split(',') if op.strip()] if _ops_str else None
+
+          _model = (_npc.model if _npc and hasattr(_npc, 'model') else None) or (state.chat_model if state else 'llama3.2')
+          _provider = (_npc.provider if _npc and hasattr(_npc, 'provider') else None) or (state.chat_provider if state else 'ollama')
+
+          _team_name = _team.name if _team else '__none__'
+          _npc_name = _npc.name if _npc else '__none__'
+          _cur_path = os.getcwd()
+
+          try:
+              _db_path = os.getenv('NPCSH_DB_PATH', os.path.expanduser('~/npcsh_history.db'))
+              _ch = CommandHistory(_db_path)
+              _eng = _ch.engine
+
+              _result = ''
+              if _do_backfill:
+                  print('Backfilling from approved memories...')
+                  _stats = kg_backfill_from_memories(_eng, model=_model, provider=_provider, npc=_npc, get_concepts=True, dry_run=False)
+                  _result += f"Backfill: +{_stats['facts_after'] - _stats['facts_before']} facts, +{_stats['concepts_after'] - _stats['concepts_before']} concepts\n"
+
+              _kg = load_kg_from_db(_eng, _team_name, _npc_name, _cur_path)
+              if not _kg or not _kg.get('facts'):
+                  context['output'] = _result + 'Knowledge graph is empty. Use /kg backfill=true or have conversations first.'
+                  context['messages'] = _msgs
+                  _ch.close()
+                  exit()
+
+              _f0 = len(_kg.get('facts', []))
+              _c0 = len(_kg.get('concepts', []))
+              _label = 'Sleep'
+
+              _kg, _ = kg_sleep_process(existing_kg=_kg, model=_model, provider=_provider, npc=_npc, operations_config=_ops_config)
+
+              if _do_dream:
+                  _label += ' & Dream'
+                  _kg, _ = kg_dream_process(existing_kg=_kg, model=_model, provider=_provider, npc=_npc)
+
+              save_kg_to_db(_eng, _kg, _team_name, _npc_name, _cur_path)
+              _f1 = len(_kg.get('facts', []))
+              _c1 = len(_kg.get('concepts', []))
+              _result += f"{_label} complete. Facts: {_f0} -> {_f1} ({_f1-_f0:+}), Concepts: {_c0} -> {_c1} ({_c1-_c0:+})"
+              context['output'] = _result
+              context['messages'] = _msgs
+              _ch.close()
+          except Exception as e:
+              traceback.print_exc()
+              context['output'] = f'KG evolution error: {e}'
+              context['messages'] = _msgs
+
+      elif not sys.stdin.isatty():
           context['output'] = "KG browser requires an interactive terminal."
 
       else:

npcsh/npc_team/jinxs/modes/plonk.jinx

@@ -24,6 +24,25 @@ steps:
 
       from npcpy.llm_funcs import get_llm_response
 
+      # Helper to log jinx executions to DB
+      def _log_jinx(trigger_id, npc_name, inputs, output, status="success", error_msg=None):
+          try:
+              if state and hasattr(state, 'command_history') and state.command_history is not None and hasattr(state.command_history, 'save_jinx_execution'):
+                  _conv_id = getattr(state, 'conversation_id', None) or ''
+                  state.command_history.save_jinx_execution(
+                      triggering_message_id=f"{_conv_id}-{trigger_id}",
+                      conversation_id=_conv_id,
+                      npc_name=npc_name,
+                      jinx_name="plonk",
+                      jinx_inputs=inputs,
+                      jinx_output=str(output) if output else "",
+                      status=status,
+                      team_name=state.team.name if state and hasattr(state, 'team') and state.team else None,
+                      error_message=error_msg,
+                  )
+          except Exception:
+              pass
+
       try:
           from npcpy.data.image import capture_screenshot
           from npcpy.work.desktop import perform_action
@@ -123,7 +142,7 @@ steps:
           render_screen()
 
           try:
-              ss = capture_screenshot()
+              ss = capture_screenshot(full=True)
               if not ss or 'file_path' not in ss:
                   task['actions'].append({"action": "fail", "reason": "Screenshot failed"})
                   task['status'] = 'failed'
@@ -136,23 +155,43 @@ steps:
               history_context = ""
               if task['actions']:
                   history_context = "\nPrevious actions:\n"
-                  for i, act in enumerate(task['actions'][-5:], 1):
+                  for i, act in enumerate(task['actions'][-8:], 1):
                       history_context += "  " + str(i) + ". " + act.get('action', '?')
                       if act.get('x'):
                           history_context += " at (" + str(act.get('x', '?')) + ", " + str(act.get('y', '?')) + ")"
+                      if act.get('text'):
+                          history_context += ' "' + act.get('text', '')[:50] + '"'
+                      if act.get('command'):
+                          history_context += ' [' + act.get('command', '')[:30] + ']'
                       history_context += " - " + act.get('reason', '') + "\n"
+                  # Detect repetition: if last 3 actions are the same type, warn
+                  recent = task['actions'][-3:]
+                  if len(recent) == 3 and all(a.get('action') == recent[0].get('action') for a in recent):
+                      history_context += "\n*** WARNING: You have repeated '" + recent[0].get('action', '?') + "' 3 times. "
+                      history_context += "This is NOT working. You MUST try a completely different approach. ***\n"
 
               prompt = "You are a GUI automation assistant. Analyze this screenshot and determine the next action.\n\n"
+              prompt += "CRITICAL RULES:\n"
+              prompt += "1. VERIFY: Check the screenshot BEFORE acting. Does it show the result of your last action? If not, wait.\n"
+              prompt += "2. NO REPEATS: If an action failed or had no effect, try a DIFFERENT approach. Never repeat the same action.\n"
+              prompt += "3. FULL TEXT: Always type the COMPLETE text in a single 'type' action. Never truncate or split text.\n"
+              prompt += "4. FOCUS FIRST: Before typing, make sure the target field is focused (click it or use keyboard shortcut).\n\n"
+              prompt += "KEYBOARD SHORTCUTS (use 'key' action with these):\n"
+              prompt += "- ctrl+l or F6: Focus browser address/search bar\n"
+              prompt += "- ctrl+a: Select all text in current field\n"
+              prompt += "- ctrl+t: New browser tab\n"
+              prompt += "- tab/shift+tab: Move between form fields\n"
+              prompt += "- escape: Close popups, cancel autocomplete\n\n"
               prompt += "TASK: " + task['text'] + "\n"
               prompt += history_context + "\n"
               prompt += "Available actions:\n"
-              prompt += "- click: Click at x,y coordinates (0-100 percentage of screen)\n"
-              prompt += "- type: Type text (use 'text' field)\n"
-              prompt += "- key: Press key like enter, tab, escape (use 'text' field)\n"
-              prompt += "- launch: Launch application (use 'command' field, e.g. " + app_examples + ")\n"
-              prompt += "- wait: Wait for 'duration' seconds\n"
-              prompt += "- done: Task completed successfully\n"
-              prompt += "- fail: Task cannot be completed\n\n"
+              prompt += "- click: Click at x,y (0-100 % of screen). Fields: x, y\n"
+              prompt += "- type: Type text into focused field. Fields: text (MUST be complete text)\n"
+              prompt += "- key: Press key(s). Fields: text (e.g. 'enter', 'ctrl+l', 'tab', 'escape')\n"
+              prompt += "- launch: Launch application. Fields: command (e.g. " + app_examples + ")\n"
+              prompt += "- wait: Wait seconds. Fields: duration\n"
+              prompt += "- done: Task completed\n"
+              prompt += "- fail: Task impossible\n\n"
               prompt += "Respond with JSON, e.g.: " + json_schema_example
 
               ui.status = "Thinking... (iter " + str(ui.iteration) + "/" + str(ui.max_iter) + ")"
@@ -173,21 +212,38 @@ steps:
                       action_response = json.loads(action_response)
                   except:
                       task['actions'].append({"action": "error", "reason": "Invalid JSON from model"})
+                      _log_jinx(f"plonk-task-{ui.current_task}-iter-{ui.iteration}",
+                                npc.name if npc and hasattr(npc, 'name') else "plonk",
+                                {"task": task['text'], "iteration": ui.iteration, "type": "analysis"},
+                                str(resp.get('response', '')), status="error", error_msg="Invalid JSON from model")
                       ui.status = "Bad response, retrying..."
                       return
 
               action = action_response.get('action', 'fail')
               reason = action_response.get('reason', '')
 
+              _npc_name = npc.name if npc and hasattr(npc, 'name') else "plonk"
+              _log_jinx(f"plonk-task-{ui.current_task}-iter-{ui.iteration}",
+                        _npc_name,
+                        {"task": task['text'], "iteration": ui.iteration, "screenshot": screenshot_path,
+                         "type": "analysis"},
+                        json.dumps(action_response))
+
               if action == 'done':
                   task['status'] = 'done'
                   task['actions'].append({"action": "done", "reason": reason})
+                  _log_jinx(f"plonk-task-{ui.current_task}-done", _npc_name,
+                            {"task": task['text'], "type": "task_complete", "total_actions": len(task['actions'])},
+                            reason)
                   advance_to_next_task()
                   return
 
               if action == 'fail':
                   task['status'] = 'failed'
                   task['actions'].append({"action": "fail", "reason": reason})
+                  _log_jinx(f"plonk-task-{ui.current_task}-fail", _npc_name,
+                            {"task": task['text'], "type": "task_failed", "total_actions": len(task['actions'])},
+                            reason, status="error", error_msg=reason)
                   advance_to_next_task()
                   return
 
@@ -196,20 +252,25 @@ steps:
 
               if action == 'click':
                   x, y = action_response.get('x', 50), action_response.get('y', 50)
-                  perform_action('click', x=x, y=y)
+                  perform_action({"type": "click", "x": x, "y": y})
                   act_record['x'] = x
                   act_record['y'] = y
               elif action == 'type':
                   txt = action_response.get('text', '')
-                  perform_action('type', text=txt)
+                  perform_action({"type": "type", "text": txt})
                   act_record['text'] = txt
               elif action == 'key':
                   key = action_response.get('text', 'enter')
-                  perform_action('key', key=key)
+                  # Detect combo keys like ctrl+l, ctrl+a, shift+tab
+                  if '+' in key:
+                      parts = [k.strip() for k in key.split('+')]
+                      perform_action({"type": "hotkey", "keys": parts})
+                  else:
+                      perform_action({"type": "key", "keys": key})
                   act_record['key'] = key
               elif action == 'launch':
                   cmd = action_response.get('command', '')
-                  perform_action('launch', command=cmd)
+                  perform_action({"type": "shell", "command": cmd})
                   act_record['command'] = cmd
                   time.sleep(2)
               elif action == 'wait':
@@ -219,7 +280,13 @@ steps:
 
               task['actions'].append(act_record)
               ui.status = action + " - " + reason[:40]
-              time.sleep(0.3)
+              # Wait for UI to settle after state-changing actions
+              if action in ('key', 'click'):
+                  time.sleep(2.0)
+              elif action == 'type':
+                  time.sleep(0.5)
+              else:
+                  time.sleep(0.3)
 
               if ui.mode == 'step':
                   ui.mode = 'paused'
@@ -227,6 +294,10 @@ steps:
 
           except Exception as e:
               task['actions'].append({"action": "error", "reason": str(e)})
+              _log_jinx(f"plonk-task-{ui.current_task}-iter-{ui.iteration}-error",
+                        npc.name if npc and hasattr(npc, 'name') else "plonk",
+                        {"task": task['text'] if task else "unknown", "iteration": ui.iteration, "type": "error"},
+                        str(e), status="error", error_msg=str(e))
               ui.status = "Error: " + str(e)[:40]
 
       def advance_to_next_task():
@@ -363,7 +434,7 @@ steps:
                   if a.get('x') is not None:
                       coords = "(" + str(a.get('x', '')) + "," + str(a.get('y', '')) + ") "
                   elif a.get('text'):
-                      coords = '"' + str(a['text'])[:15] + '" '
+                      coords = '"' + str(a['text'])[:40] + '" '
                   elif a.get('key'):
                       coords = '[' + str(a['key']) + '] '
                   elif a.get('command'):