codz-cli 0.0.0-stage → 0.1.2

package/dist/skills/completion.js

@@ -0,0 +1,142 @@
+// Shell completion. `codz completion bash|zsh|fish` prints a script that calls
+// the hidden `codz __complete <words...>` command, so all three shells share
+// one implementation, including endpoint names, plan ids and config keys.
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadMap, setCacheWrites, TOOL_DIR } from "../core/cache.js";
+import { CONFIG_FILE, loadConfig } from "../core/config.js";
+import { exists } from "../core/fsutil.js";
+import { ALLOWED, knownKeys } from "../core/validateConfig.js";
+import { CHANGE_FLAGS, COMMAND_LIST, FLAGS, GLOBAL_FLAGS } from "../core/commands.js";
+import { TEMPLATES } from "../core/templates.js";
+export const SHELLS = ['bash', 'zsh', 'fish'];
+/** Commands, their subcommands and the flags each takes, from the command table. */
+export const COMMANDS = {};
+for (const c of COMMAND_LIST) {
+    const flags = [...c.flags, ...(c.change ? CHANGE_FLAGS : [])].filter((f) => f.length > 1).map((f) => `--${f}`);
+    const entry = (COMMANDS[c.cmd] ??= {});
+    if (c.sub)
+        (entry.subs ??= {})[c.sub] = flags;
+    else
+        entry.flags = flags;
+}
+const GLOBAL = GLOBAL_FLAGS.filter((f) => f.length > 1).map((f) => `--${f}`);
+/** Flags whose value is a file or folder (the shell completes paths). */
+const PATH_FLAGS = new Set(Object.entries(FLAGS).filter(([, f]) => f.path).map(([n]) => `--${n}`));
+const VALUE_FLAGS = new Set(Object.entries(FLAGS).filter(([, f]) => f.value).map(([n]) => `--${n}`));
+export const FILES = '__files__';
+function endpointNames(root, adapter) {
+    return loadMap(root, adapter, loadConfig(root).conventions)
+        .then(({ map }) => map.endpoints.map((e) => e.name))
+        .catch(() => []);
+}
+function planIds(root) {
+    try {
+        return readdirSync(join(root, TOOL_DIR, 'plans')).filter((n) => n.endsWith('.json')).map((n) => n.slice(0, -5)).sort().reverse();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Candidates for the last word. `words` are the words after "codz", the last
+ * one being the word under the cursor (possibly empty).
+ */
+export async function complete(words, root, adapter) {
+    setCacheWrites(false);
+    const cur = words[words.length - 1] ?? '';
+    const prev = words[words.length - 2];
+    const positional = words.slice(0, -1).filter((w, i, a) => !w.startsWith('-') && !(i > 0 && VALUE_FLAGS.has(a[i - 1])));
+    const [cmd, sub] = positional;
+    const spec = cmd ? COMMANDS[cmd] : undefined;
+    const hasProject = exists(join(root, CONFIG_FILE));
+    if (prev && VALUE_FLAGS.has(prev)) {
+        if (PATH_FLAGS.has(prev))
+            return [FILES];
+        const choices = FLAGS[prev.slice(2)]?.choices;
+        if (choices)
+            return choices;
+        if (prev === '--architecture')
+            return adapter.id === 'flutter' ? ['getx', 'riverpod', 'get_it'] : ['fetch-helper', 'plain-fetch'];
+        if (prev === '--only' && cmd === 'doctor')
+            return ['locales', 'api', 'urls', 'models'];
+        if (prev === '--api' && hasProject)
+            return endpointNames(root, adapter);
+        return [];
+    }
+    if (cur.startsWith('-')) {
+        const own = spec?.subs ? (sub ? spec.subs[sub] ?? [] : []) : spec?.flags ?? [];
+        return [...new Set([...own, ...GLOBAL])];
+    }
+    if (!cmd)
+        return Object.keys(COMMANDS);
+    if (spec?.subs && !sub)
+        return Object.keys(spec.subs);
+    const argIndex = positional.length - (spec?.subs ? 2 : 1); // 0 = first argument after the (sub)command
+    const kind = COMMAND_LIST.find((c) => c.cmd === cmd && c.sub === (spec?.subs ? sub : undefined))?.args;
+    if (kind === 'template')
+        return TEMPLATES.map((t) => t.id);
+    if (kind === 'shell')
+        return argIndex === 0 ? ['bash', 'zsh', 'fish'] : [];
+    if (kind === 'endpoints' && hasProject)
+        return endpointNames(root, adapter);
+    if (cmd === 'api' && ['show', 'remove', 'rename', 'update', 'wire'].includes(sub) && argIndex === 0 && hasProject)
+        return endpointNames(root, adapter);
+    if (cmd === 'api' && (sub === 'import' || sub === 'sync') && argIndex === 0)
+        return [FILES];
+    if (cmd === 'mock' && sub === 'add' && hasProject)
+        return endpointNames(root, adapter);
+    if ((cmd === 'plans' && sub === 'show') || cmd === 'apply')
+        return argIndex === 0 ? planIds(root) : [];
+    if (cmd === 'config' && (sub === 'get' || sub === 'set') && argIndex === 0)
+        return Object.keys(knownKeys(adapter.id));
+    if (cmd === 'config' && sub === 'set' && argIndex === 1)
+        return ALLOWED[adapter.id]?.[positional[2]] ?? [];
+    if (cmd === 'theme' && sub === 'set' && argIndex % 2 === 0)
+        return ['primary', 'secondary', 'accent', 'background', 'surface', 'error', 'radius', 'spacing', 'font'];
+    return [];
+}
+export function completionScript(shell) {
+    if (shell === 'bash') {
+        return `# codz completion for bash. Add to ~/.bashrc:  eval "$(codz completion bash)"
+_codz() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}" out
+  out=$(codz __complete "\${COMP_WORDS[@]:1:COMP_CWORD}" 2>/dev/null)
+  if [ "$out" = "${FILES}" ]; then
+    COMPREPLY=($(compgen -f -- "$cur"))
+  else
+    local IFS=$'\\n'
+    COMPREPLY=($(compgen -W "$out" -- "$cur"))
+  fi
+}
+complete -o default -F _codz codz
+`;
+    }
+    if (shell === 'zsh') {
+        return `#compdef codz
+# codz completion for zsh. Add to ~/.zshrc (after compinit):  source <(codz completion zsh)
+_codz() {
+  local -a out
+  out=("\${(@f)$(codz __complete "\${words[@]:1:$((CURRENT-1))}" 2>/dev/null)}")
+  if [[ "\${out[1]}" == "${FILES}" ]]; then
+    _files
+  else
+    compadd -a out
+  fi
+}
+compdef _codz codz
+`;
+    }
+    return `# codz completion for fish. Save as ~/.config/fish/completions/codz.fish:
+#   codz completion fish > ~/.config/fish/completions/codz.fish
+function __codz_complete
+  set -l out (codz __complete (commandline -opc)[2..-1] (commandline -ct) 2>/dev/null)
+  if test "$out" = "${FILES}"
+    __fish_complete_path (commandline -ct)
+  else
+    printf '%s\\n' $out
+  end
+end
+complete -c codz -f -a '(__codz_complete)'
+`;
+}

package/dist/skills/config.js

@@ -0,0 +1,93 @@
+// codz config: view, get and set conventions, and check the config file.
+// `config set` edits codz.config.yaml in place (comments and order stay) and
+// goes through the usual preview → apply → undo pipeline.
+import { join } from 'node:path';
+import { loadMap } from "../core/cache.js";
+import { buildChangeSet } from "../core/changeset.js";
+import { CONFIG_FILE, loadConfig } from "../core/config.js";
+import { readText } from "../core/fsutil.js";
+import { ToolError } from "../core/types.js";
+import { ALLOWED, checkValue, closest, knownKeys, validateConfig } from "../core/validateConfig.js";
+import { scalar } from "../core/yaml.js";
+export async function configView(root, adapter) {
+    const cfg = loadConfig(root);
+    const { map } = await loadMap(root, adapter, cfg.conventions);
+    const docs = knownKeys(adapter.id);
+    const keys = [...new Set([...Object.keys(docs), ...Object.keys(map.conventions)])];
+    const rows = keys
+        .filter((k) => k in docs || map.conventions[k] !== undefined)
+        .map((key) => ({
+        key,
+        value: cfg.conventions[key] ?? map.conventions[key] ?? '',
+        source: (key in cfg.conventions ? 'config' : 'detected'),
+        description: docs[key] ?? '',
+        allowed: ALLOWED[adapter.id]?.[key],
+    }));
+    return { framework: adapter.id, file: cfg.exists ? CONFIG_FILE : null, rows };
+}
+export function configCheck(root) {
+    const text = readText(join(root, CONFIG_FILE));
+    if (text === null)
+        throw new ToolError('no_config', `There is no ${CONFIG_FILE} here.`, 'Create one with: codz init');
+    return { issues: validateConfig(text, root), file: CONFIG_FILE };
+}
+export function planConfigSet(root, adapter, key, value, opts = {}) {
+    const text = readText(join(root, CONFIG_FILE));
+    if (text === null)
+        throw new ToolError('no_config', `There is no ${CONFIG_FILE} here.`, 'Create one with: codz init');
+    const docs = knownKeys(adapter.id);
+    if (!(key in docs) && !opts.force) {
+        const close = closest(key, Object.keys(docs));
+        throw new ToolError('unknown_key', `"${key}" is not a ${adapter.id} convention.`, close ? `Did you mean ${close}?` : `Known keys: ${Object.keys(docs).join(', ')}. Pass --force to set it anyway.`);
+    }
+    const issue = checkValue(adapter.id, key, value, root);
+    if (issue?.level === 'error')
+        throw new ToolError('bad_value', issue.message, issue.hint);
+    const eol = text.includes('\r\n') ? '\r\n' : '\n';
+    const lines = text.split(/\r?\n/);
+    let convAt = lines.findIndex((l) => /^conventions:\s*(#.*)?$/.test(l) || /^conventions:\s*\{\}\s*$/.test(l));
+    if (convAt === -1) {
+        // No conventions block yet: add one at the end.
+        if (lines[lines.length - 1] === '')
+            lines.pop();
+        lines.push('conventions:');
+        convAt = lines.length - 1;
+        lines.push('');
+    }
+    else if (/\{\}/.test(lines[convAt]))
+        lines[convAt] = 'conventions:';
+    // The block runs while lines are indented (or blank/comment lines inside it).
+    let end = convAt + 1;
+    let found = -1;
+    let indent = '  ';
+    while (end < lines.length && (/^\s+\S/.test(lines[end]) || lines[end].trim() === '')) {
+        const m = /^(\s+)([^#\s][^:]*):/.exec(lines[end]);
+        if (m) {
+            indent = m[1];
+            if (m[2].trim() === key)
+                found = end;
+        }
+        end++;
+    }
+    // Do not swallow blank lines that follow the block.
+    while (end > convAt + 1 && lines[end - 1].trim() === '')
+        end--;
+    const rendered = `${indent}${key}: ${scalar(value)}`;
+    let before = null;
+    if (found !== -1) {
+        const old = /:\s*(.*)$/.exec(lines[found])?.[1] ?? '';
+        before = old.replace(/^'(.*)'$/, '$1');
+        const trailing = /\s+#.*$/.exec(lines[found].slice(lines[found].indexOf(':') + 1));
+        lines[found] = rendered + (trailing && !/['"]/.test(trailing[0]) ? trailing[0] : '');
+    }
+    else {
+        const insert = docs[key] ? [`${indent}# ${docs[key]}`, rendered] : [rendered];
+        lines.splice(end, 0, ...insert);
+    }
+    const next = lines.join(eol);
+    const summary = [found !== -1 ? `Set ${key}: ${before || "''"} → ${value || "'' (detect)"} in ${CONFIG_FILE}` : `Add ${key}: ${value || "''"} to ${CONFIG_FILE}`];
+    const warnings = issue ? [issue.message + (issue.hint ? ` ${issue.hint}` : '')] : [];
+    if (value === '')
+        warnings.push(`An empty ${key} means codz detects it from the code again.`);
+    return buildChangeSet(root, 'config set', { files: new Map([[CONFIG_FILE, next]]), summary, warnings, generated: [] });
+}