kaqing 2.0.184__py3-none-any.whl → 2.0.227__py3-none-any.whl

adam/commands/cql/cqlsh.py

@@ -3,9 +3,8 @@ import click
 from adam.commands import extract_trailing_options
 from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
-from adam.commands.cql.cql_completions import cql_completions
+from adam.commands.cql.completions_c import completions_c
 from adam.commands.cql.utils_cql import cassandra
-from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log
 
@@ -38,18 +37,15 @@ class Cqlsh(Command):
 
     def completion(self, state: ReplState) -> dict[str, any]:
         if state.device != state.C:
-            # conflicts with psql completions
             return {}
 
         if state.sts or state.pod:
-            c = cql_completions(state)
-            return c | \
-                   {f'@{p}': c for p in StatefulSets.pod_names(state.sts, state.namespace)}
+            return completions_c(state)
 
         return {}
 
-    def help(self, _: ReplState) -> str:
-        return f'<cql-statements> [&]\t run cqlsh with queries'
+    def help(self, state: ReplState) -> str:
+        return super().help(state, 'run cqlsh with queries', command='[cql] <cql-statement>;...', args='[&]')
 
 class CqlCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):

adam/commands/cql/utils_cql.py

@@ -7,11 +7,19 @@ from adam.commands.commands_utils import show_table
 from adam.utils_k8s.cassandra_clusters import CassandraClusters
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.utils_k8s.secrets import Secrets
-from adam.pod_exec_result import PodExecResult
+from adam.utils_k8s.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState
-from adam.utils import log2, log_timing, wait_log
+from adam.utils import ing, log2, log_timing, wait_log
 from adam.utils_k8s.statefulsets import StatefulSets
 
+def cd_dirs(state: ReplState) -> list[str]:
+    if state.pod:
+        return [".."]
+    elif state.sts:
+        return [".."] + StatefulSets.pod_names(state.sts, state.namespace)
+    else:
+        return StatefulSets.list_sts_names()
+
 @functools.lru_cache()
 def cassandra_keyspaces(state: ReplState, on_any=True):
     if state.pod:
@@ -47,7 +55,7 @@ def table_spec(state: ReplState, table: str, on_any=False) -> 'TableSpec':
 
     return parse_cql_desc_table(r.stdout if state.pod else r[0].stdout)
 
-def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, backgrounded=False, log_file=None) -> list[PodExecResult]:
+def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, show_query = False, use_single_quotes = False, on_any = False, backgrounded=False, log_file=None, history=True) -> list[PodExecResult]:
     if show_query:
         log2(cql)
 
@@ -61,7 +69,7 @@ def run_cql(state: ReplState, cql: str, opts: list = [], show_out = False, show_
 
     with log_timing(cql):
         with cassandra(state) as pods:
-            return pods.exec(command, action='cql', show_out=show_out, on_any=on_any, backgrounded=backgrounded, log_file=log_file)
+            return pods.exec(command, action='cql', show_out=show_out, on_any=on_any, backgrounded=backgrounded, log_file=log_file, history=history)
 
 def parse_cql_desc_tables(out: str):
     # Keyspace data_endpoint_auth
@@ -219,16 +227,26 @@ class CassandraPodService:
     def __init__(self, handler: 'CassandraExecHandler'):
         self.handler = handler
 
-    def exec(self, command: str, action='bash', show_out = True, on_any = False, throw_err = False, shell = '/bin/sh', backgrounded = False, log_file = None) -> Union[PodExecResult, list[PodExecResult]]:
+    def exec(self,
+             command: str,
+             action='bash',
+             show_out = True,
+             on_any = False,
+             throw_err = False,
+             shell = '/bin/sh',
+             backgrounded = False,
+             log_file = None,
+             history=True,
+             text_color: str = None) -> Union[PodExecResult, list[PodExecResult]]:
         state = self.handler.state
         pod = self.handler.pod
 
         if pod:
             return CassandraNodes.exec(pod, state.namespace, command,
-                                    show_out=show_out, throw_err=throw_err, shell=shell, backgrounded=backgrounded, log_file=log_file)
+                                    show_out=show_out, throw_err=throw_err, shell=shell, backgrounded=backgrounded, log_file=log_file, history=history, text_color=text_color)
         elif state.sts:
             return CassandraClusters.exec(state.sts, state.namespace, command, action=action,
-                                        show_out=show_out, on_any=on_any, shell=shell, backgrounded=backgrounded, log_file=log_file)
+                                        show_out=show_out, on_any=on_any, shell=shell, backgrounded=backgrounded, log_file=log_file, history=history, text_color=text_color)
 
         return []
 
@@ -259,16 +277,17 @@ class CassandraPodService:
 
         return run_cql(state, query, opts=opts, show_out=show_out, show_query=show_query, use_single_quotes=use_single_quotes, on_any=on_any, backgrounded=backgrounded, log_file=log_file)
 
-    def display_table(self, cols: str, header: str, show_out = True):
+    def display_table(self, cols: str, header: str, show_out = True, backgrounded = False, msg: str = None):
         state = self.handler.state
 
-        if state.pod:
-            show_table(state, [state.pod], cols, header, show_out=show_out)
-        elif state.sts:
-            pod_names = [pod.metadata.name for pod in StatefulSets.pods(state.sts, state.namespace)]
-            show_table(state, pod_names, cols, header, show_out=show_out)
+        with ing(msg=msg, condition=backgrounded and msg):
+            if state.pod:
+                return show_table(state, [state.pod], cols, header, show_out=show_out, backgrounded = backgrounded)
+            elif state.sts:
+                pod_names = [pod.metadata.name for pod in StatefulSets.pods(state.sts, state.namespace)]
+                return show_table(state, pod_names, cols, header, show_out=show_out, backgrounded = backgrounded)
 
-    def nodetool(self, args: str, status = False, show_out = True) -> Union[PodExecResult, list[PodExecResult]]:
+    def nodetool(self, args: str, status = False, show_out = True, backgrounded = False) -> Union[PodExecResult, list[PodExecResult]]:
         state = self.handler.state
         pod = self.handler.pod
 
@@ -276,9 +295,9 @@ class CassandraPodService:
         command = f"nodetool -u {user} -pw {pw} {args}"
 
         if pod:
-            return CassandraNodes.exec(pod, state.namespace, command, show_out=show_out)
+            return CassandraNodes.exec(pod, state.namespace, command, show_out=show_out, backgrounded=backgrounded)
         else:
-            return CassandraClusters.exec(state.sts, state.namespace, command, action='nodetool.status' if status else 'nodetool', show_out=show_out)
+            return CassandraClusters.exec(state.sts, state.namespace, command, action='nodetool.status' if status else 'nodetool', show_out=show_out, backgrounded=backgrounded)
 
 class CassandraExecHandler:
     def __init__(self, state: ReplState, pod: str = None):
@@ -294,4 +313,4 @@ class CassandraExecHandler:
         return False
 
 def cassandra(state: ReplState, pod: str=None):
-    return CassandraExecHandler(state, pod=pod)
+    return CassandraExecHandler(state, pod=pod)

adam/commands/debug/debug.py

@@ -0,0 +1,22 @@
+from adam.commands.command import Command
+from adam.commands.debug.debug_completes import DebugCompletes
+from adam.commands.debug.debug_timings import DebugTimings
+from adam.commands.intermediate_command import IntermediateCommand
+
+class Debug(IntermediateCommand):
+    COMMAND = 'debug'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Debug, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Debug.COMMAND
+
+    def cmd_list(self):
+        return [DebugTimings(), DebugCompletes()]

adam/commands/debug/debug_completes.py

@@ -0,0 +1,35 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.config import Config
+from adam.repl_state import ReplState
+
+class DebugCompletes(Command):
+    COMMAND = 'debug completes'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DebugCompletes, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DebugCompletes.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='on, off or file') as args:
+                Config().set('debugs.complete', args)
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {f: None for f in ['on', 'off', 'file']})
+
+    def help(self, state: ReplState):
+        return super().help(state, 'turn auto complete debug on or off', args='on|off|file')

adam/commands/debug/debug_timings.py

@@ -0,0 +1,35 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.config import Config
+from adam.repl_state import ReplState
+
+class DebugTimings(Command):
+    COMMAND = 'debug timings'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DebugTimings, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DebugTimings.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='on, off or file') as args:
+                Config().set('debugs.timings', args)
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {f: None for f in ['on', 'off', 'file']})
+
+    def help(self, state: ReplState):
+        return super().help(state, 'turn timing debug on or off', args='on|off|file')

adam/commands/debug/show_offloaded_completes.py

@@ -0,0 +1,45 @@
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.sql.async_executor import AsyncExecutor
+from adam.utils import tabulize
+
+class ShowOffloadedCompletes(Command):
+    COMMAND = 'show offloaded completes'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ShowOffloadedCompletes, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ShowOffloadedCompletes.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            pending, processed, first, last = AsyncExecutor.entries_in_queue()
+            lines = []
+            for k, v in processed.items():
+                lines.append(f'{k}\t{v:2.2f}')
+            for k in pending:
+                lines.append(f'{k}\tpending')
+            lines += [
+                f'---------------------------',
+                f'duration\t{last-first:2.2f}'
+            ]
+
+            tabulize(lines, header='key\tduration(in sec)', separator='\t')
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, state: ReplState):
+        return super().help(state, 'show offloaded completes')

adam/commands/deploy/code_start.py

@@ -42,5 +42,5 @@ class CodeStart(Command):
 
         return {}
 
-    def help(self, _: ReplState):
-        return f'{CodeStart.COMMAND}\t start code server'
+    def help(self, state: ReplState):
+        return super().help(state, 'start code server')

adam/commands/deploy/code_stop.py

@@ -36,5 +36,5 @@ class CodeStop(Command):
 
         return {}
 
-    def help(self, _: ReplState):
-        return f'{CodeStop.COMMAND}\t stop code server'
+    def help(self, state: ReplState):
+        return super().help(state, 'stop code server')

adam/commands/deploy/deploy_frontend.py

@@ -45,5 +45,5 @@ class DeployFrontend(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{DeployFrontend.COMMAND}\t deploy Web frontend'
+    def help(self, state: ReplState):
+        return super().help(state, 'deploy Web frontend')

adam/commands/deploy/deploy_pg_agent.py

@@ -31,5 +31,5 @@ class DeployPgAgent(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{DeployPgAgent.COMMAND}\t deploy Postgres agent'
+    def help(self, state: ReplState):
+        return super().help(state, 'deploy Postgres agent')

adam/commands/deploy/deploy_pod.py

@@ -102,5 +102,5 @@ class DeployPod(Command):
     def completion(self, state: ReplState):
         return super().completion(state, {'--force': None})
 
-    def help(self, _: ReplState):
-        return f'{DeployPod.COMMAND} [--force]\t deploy Ops pod, --force to undeploy first'
+    def help(self, state: ReplState):
+        return super().help(state, 'deploy Ops pod --force to undeploy first', args='[--force]')

adam/commands/deploy/undeploy_frontend.py

@@ -34,5 +34,5 @@ class UndeployFrontend(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{UndeployFrontend.COMMAND}\t undeploy Web frontend'
+    def help(self, state: ReplState):
+        return super().help(state, 'undeploy Web frontend')

adam/commands/deploy/undeploy_pg_agent.py

@@ -35,5 +35,5 @@ class UndeployPgAgent(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{UndeployPgAgent.COMMAND}\t undeploy Postgres agent'
+    def help(self, state: ReplState):
+        return super().help(state, 'undeploy Postgres agent')

adam/commands/deploy/undeploy_pod.py

@@ -44,5 +44,5 @@ class UndeployPod(Command):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{UndeployPod.COMMAND}\t undeploy Ops pod'
+    def help(self, state: ReplState):
+        return super().help(state, 'undeploy Ops pod')

adam/commands/devices/device.py

@@ -2,13 +2,23 @@ from abc import abstractmethod
 
 from adam.commands.command import Command
 from adam.config import Config
-from adam.pod_exec_result import PodExecResult
+from adam.utils_k8s.pod_exec_result import PodExecResult
 from adam.repl_state import BashSession, ReplState
 from adam.utils import log2
+from adam.utils_k8s.pods import Pods
 
 class Device:
-    def pods(self, state: ReplState) -> tuple[list[str], str]:
-        return self.pod_names(state), self.pod(state)
+    def pods(self, state: ReplState, me: str = None) -> tuple[list[str], str]:
+        return self.pod_names(state), me if me else self.pod(state)
+
+    def default_pod(self, state: ReplState) -> tuple[list[str], str]:
+        if me := self.pod(state):
+            return me
+
+        if pods := self.pod_names(state):
+            return pods[0]
+
+        return None
 
     def pod(self, state: ReplState) -> str:
         return None
@@ -32,6 +42,9 @@ class Device:
     def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
         return default
 
+    def direct_dirs(self, cmd: str, state: ReplState, default: dict = {}) -> list[str]:
+        return []
+
     @abstractmethod
     def pwd(self, state: ReplState):
         pass
@@ -70,12 +83,12 @@ class Device:
     def show_table_preview(self, state: ReplState, table: str, rows: int):
         pass
 
-    def bash(self, s0: ReplState, s1: ReplState, args: list[str]):
+    def bash(self, s0: ReplState, s1: ReplState, args: list[str], text_color: str = None):
         if s1.in_repl:
             if self.bash_target_changed(s0, s1):
-                r = self._exec_with_dir(s1, args)
+                r = self._exec_with_dir(s1, args, text_color=text_color)
             else:
-                r = self._exec_with_dir(s0, args)
+                r = self._exec_with_dir(s0, args, text_color=text_color)
 
             if not r:
                 s1.exit_bash()
@@ -88,7 +101,7 @@ class Device:
 
             return s1
 
-    def _exec_with_dir(self, state: ReplState, args: list[str]) -> list[PodExecResult]:
+    def _exec_with_dir(self, state: ReplState, args: list[str], text_color: str = None) -> list[PodExecResult]:
         session_just_created = False
         if not args:
             session_just_created = True
@@ -105,19 +118,32 @@ class Device:
                 if pwd := state.bash_session.pwd(state):
                     args = ['cd', pwd, '&&'] + args
 
-        return self.exec_with_dir(' '.join(args), session_just_created, state)
+        return self.exec_with_dir(' '.join(args), session_just_created, state, text_color=text_color)
 
     @abstractmethod
     def bash_target_changed(self, s0: ReplState, s1: ReplState):
         pass
 
     @abstractmethod
-    def exec_no_dir(self, command: str, state: ReplState):
+    def exec_no_dir(self, command: str, state: ReplState, text_color: str = None):
         pass
 
     @abstractmethod
-    def exec_with_dir(self, command: str, session_just_created: bool, state: ReplState):
+    def exec_with_dir(self, command: str, session_just_created: bool, state: ReplState, text_color: str = None):
         pass
 
     def bash_completion(self, cmd: str, state: ReplState, default: dict = {}):
-        return default
+        return default
+
+    def files(self, state: ReplState):
+        r: PodExecResult = Pods.exec(self.default_pod(state), self.default_container(state), state.namespace, f'find -maxdepth 1 -type f', show_out=Config().is_debug(), shell='bash')
+
+        log_files = []
+        for line in r.stdout.split('\n'):
+            line = line.strip(' \r')
+            if line:
+                if line.startswith('./'):
+                    line = line[2:]
+                log_files.append(line)
+
+        return log_files

adam/commands/devices/device_app.py

@@ -35,8 +35,8 @@ class DeviceApp(Command, Device):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{DeviceApp.COMMAND}\t move to App Operations device'
+    def help(self, state: ReplState):
+        return super().help(state, 'move to App Operations device')
 
     def pod(self, state: ReplState) -> str:
         return state.app_pod
@@ -116,7 +116,7 @@ class DeviceApp(Command, Device):
         if state.app_app:
             words.append(f'app/{state.app_app}')
 
-        return '\t'.join([f'{ReplState.X}:>'] + (words if words else ['/']))
+        return '\t'.join([f'{ReplState.A}:>'] + (words if words else ['/']))
 
     def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
         if state.app_app:
@@ -150,13 +150,13 @@ class DeviceApp(Command, Device):
     def bash_target_changed(self, s0: ReplState, s1: ReplState):
         return s0.app_env != s1.app_env or s0.app_app != s1.app_app or s0.app_pod != s1.app_pod
 
-    def exec_no_dir(self, command: str, state: ReplState):
+    def exec_no_dir(self, command: str, state: ReplState, text_color: str = None):
         with app(state) as pods:
-            return pods.exec(command)
+            return pods.exec(command, text_color=text_color)
 
-    def exec_with_dir(self, command: str, session_just_created: bool, state: ReplState):
+    def exec_with_dir(self, command: str, session_just_created: bool, state: ReplState, text_color: str = None):
         with app(state) as pods:
-            return pods.exec(command, not session_just_created)
+            return pods.exec(command, not session_just_created, text_color=text_color)
 
     def bash_completion(self, cmd: str, state: ReplState, default: dict = {}):
         return {cmd: BashCompleter(lambda: [])} | \

adam/commands/devices/device_auit_log.py

@@ -30,8 +30,8 @@ class DeviceAuditLog(Command, Device):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{DeviceAuditLog.COMMAND}\t move to Audit Log Operations device'
+    def help(self, state: ReplState):
+        return super().help(state, 'move to Audit Log Operations device')
 
     def ls(self, cmd: str, _: ReplState):
         tabulize(Athena.table_names(), header='NAME', separator=',')

adam/commands/devices/device_cass.py

@@ -43,8 +43,8 @@ class DeviceCass(Command, Device):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{DeviceCass.COMMAND}\t move to Cassandra Operations device'
+    def help(self, state: ReplState):
+        return super().help(state, 'move to Cassandra Operations device')
 
     def default_container(self, _: ReplState) -> str:
         return 'cassandra'
@@ -161,13 +161,13 @@ class DeviceCass(Command, Device):
     def bash_target_changed(self, s0: ReplState, s1: ReplState):
         return s0.sts != s1.sts or s0.pod != s1.pod
 
-    def exec_no_dir(self, command: str, state: ReplState):
+    def exec_no_dir(self, command: str, state: ReplState, text_color: str = None):
         with cassandra(state) as pods:
-            return pods.exec(command, action='bash', show_out=True, shell='bash')
+            return pods.exec(command, action='bash', show_out=True, shell='bash', text_color=text_color)
 
-    def exec_with_dir(self, command: str, session_just_created: bool, state: ReplState):
+    def exec_with_dir(self, command: str, session_just_created: bool, state: ReplState, text_color: str = None):
         with cassandra(state) as pods:
-            return pods.exec(command, action='bash', show_out=not session_just_created, shell='bash')
+            return pods.exec(command, action='bash', show_out=not session_just_created, shell='bash', text_color=text_color)
 
     def bash_completion(self, cmd: str, state: ReplState, default: dict = {}):
         completions = {cmd: BashCompleter(lambda: [])}

adam/commands/devices/device_export.py

@@ -3,7 +3,7 @@ from adam.commands.devices.device import Device
 from adam.commands.export.export_databases import ExportDatabases, export_db
 from adam.config import Config
 from adam.repl_state import ReplState
-from adam.utils import tabulize, log, log2, wait_log
+from adam.utils import tabulize, log2, wait_log
 
 class DeviceExport(Command, Device):
     COMMAND = f'{ReplState.X}:'
@@ -31,8 +31,8 @@ class DeviceExport(Command, Device):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{DeviceExport.COMMAND}\t move to Export Database Operations device'
+    def help(self, state: ReplState):
+        return super().help(state, 'Export Database Operations device')
 
     def ls(self, cmd: str, state: ReplState):
         if state.export_session:
@@ -66,7 +66,10 @@ class DeviceExport(Command, Device):
         return '\t'.join([f'{ReplState.X}:>'] + (words if words else ['/']))
 
     def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
-        result = chain.run(f'.{cmd}', state)
+        if cmd.startswith('select '):
+            cmd = f'xelect {cmd[7:]}'
+
+        result = chain.run(cmd, state)
         if type(result) is ReplState:
             if state.export_session and not result.export_session:
                 state.export_session = None

adam/commands/devices/device_postgres.py

@@ -32,8 +32,8 @@ class DevicePostgres(Command, Device):
     def completion(self, state: ReplState):
         return super().completion(state)
 
-    def help(self, _: ReplState):
-        return f'{DevicePostgres.COMMAND}\t move to Postgres Operations device'
+    def help(self, state: ReplState):
+        return super().help(state, 'move to Postgres Operations device')
 
     def pod(self, state: ReplState) -> str:
         pod, _ = PostgresDatabases.pod_and_container(state.namespace)
@@ -47,6 +47,10 @@ class DevicePostgres(Command, Device):
         return container
 
     def ls(self, cmd: str, state: ReplState):
+        if state.pod_targetted:
+            self.bash(state, state, ['ls'])
+            return
+
         with pg_path(state) as (host, database):
             if database:
                 tabulize(pg_table_names(state), header='NAME', separator=',')
@@ -94,13 +98,16 @@ class DevicePostgres(Command, Device):
                 state.pg_path = host
 
     def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
+        return {cmd: {d: None for d in self.direct_dirs(cmd, state, default=default)}}
+
+    def direct_dirs(self, cmd: str, state: ReplState, default: dict = {}) -> list[str]:
         with pg_path(state) as (host, database):
             if database:
-                return {cmd: {'..': None}}
+                return ['..']
             elif host:
-                return {cmd: {'..': None} | {p: None for p in pg_database_names(state)}}
+                return ['..'] + [p for p in pg_database_names(state)]
             else:
-                return {cmd: {p: None for p in PostgresDatabases.host_names(state.namespace)}}
+                return [p for p in PostgresDatabases.host_names(state.namespace)]
 
     def pwd(self, state: ReplState):
         words = []
@@ -115,6 +122,9 @@ class DevicePostgres(Command, Device):
 
     def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
         with pg_path(state) as (_, database):
+            if not database:
+                database = PostgresDatabases.default_db()
+
             if database:
                 return True, chain.run(f'pg {cmd}', state)
 
@@ -138,13 +148,13 @@ class DevicePostgres(Command, Device):
     def bash_target_changed(self, s0: ReplState, s1: ReplState):
         return s0.pg_path != s1.pg_path
 
-    def exec_no_dir(self, command: str, state: ReplState):
+    def exec_no_dir(self, command: str, state: ReplState, text_color: str = None):
         with postgres(state) as pod:
-            return pod.exec(command, show_out=True)
+            return pod.exec(command, show_out=True, text_color=text_color)
 
-    def exec_with_dir(self, command: str, session_just_created: bool, state: ReplState):
+    def exec_with_dir(self, command: str, session_just_created: bool, state: ReplState, text_color: str = None):
         with postgres(state) as pod:
-            return pod.exec(command, show_out=not session_just_created)
+            return pod.exec(command, show_out=not session_just_created, text_color=text_color)
 
     def bash_completion(self, cmd: str, state: ReplState, default: dict = {}):
         return {cmd: BashCompleter(lambda: [])}

adam/commands/devices/devices.py

@@ -7,7 +7,7 @@ from adam.commands.devices.device_postgres import DevicePostgres
 from adam.repl_state import ReplState
 
 class Devices:
-    def device(state: ReplState) -> Device:
+    def of(state: ReplState) -> Device:
         if state.device == ReplState.A:
             return DeviceApp()
         elif state.device == ReplState.C: