codz-cli 0.0.0-stage → 0.1.0

package/dist/core/validateConfig.js

@@ -0,0 +1,172 @@
+// Checks codz.config.yaml: it parses, uses spaces, names a known framework,
+// has known keys with allowed values, and its paths exist inside the project.
+// Used by `codz config check`, `codz config set` and `codz doctor --setup`.
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { FLUTTER_CONVENTION_DOCS } from "../adapters/flutter.js";
+import { NEXT_CONVENTION_DOCS } from "../adapters/nextjs.js";
+import { RN_CONVENTION_DOCS } from "../adapters/reactNative.js";
+import { REACT_CONVENTION_DOCS } from "../adapters/react.js";
+import { IOS_CONVENTION_DOCS } from "../adapters/ios.js";
+import { ANDROID_CONVENTION_DOCS } from "../adapters/android.js";
+import { exists } from "./fsutil.js";
+import { parse } from "./yaml.js";
+const FRAMEWORKS = ['nextjs', 'flutter', 'react-native', 'react', 'android', 'ios', 'generic'];
+/** Allowed values for keys that take one of a few words. Empty is always allowed (= detect). */
+export const ALLOWED = {
+    nextjs: {
+        apiFileNaming: ['kebab', 'camel', 'pascal', 'snake'],
+        modelFileNaming: ['kebab', 'camel', 'pascal', 'snake'],
+        apiFileResource: ['plural', 'singular'],
+        modelsLayout: ['per-file', 'single'],
+        importStyle: ['alias', 'relative'],
+        quote: ['single', 'double'],
+        semicolons: ['true', 'false'],
+        indent: ['2', '4', 'tab'],
+        http: ['fetch', 'axios'],
+        dataFetching: ['react-query', 'none'],
+    },
+    'react-native': {
+        apiFileNaming: ['kebab', 'camel', 'pascal', 'snake'],
+        modelFileNaming: ['kebab', 'camel', 'pascal', 'snake'],
+        apiFileResource: ['plural', 'singular'],
+        modelsLayout: ['per-file', 'single'],
+        importStyle: ['alias', 'relative'],
+        quote: ['single', 'double'],
+        semicolons: ['true', 'false'],
+        indent: ['2', '4', 'tab'],
+        http: ['fetch', 'axios'],
+        dataFetching: ['react-query', 'none'],
+        flavor: ['expo', 'bare'],
+        router: ['react-navigation', 'expo-router', 'none'],
+    },
+    react: {
+        apiFileNaming: ['kebab', 'camel', 'pascal', 'snake'],
+        modelFileNaming: ['kebab', 'camel', 'pascal', 'snake'],
+        apiFileResource: ['plural', 'singular'],
+        modelsLayout: ['per-file', 'single'],
+        importStyle: ['alias', 'relative'],
+        quote: ['single', 'double'],
+        semicolons: ['true', 'false'],
+        indent: ['2', '4', 'tab'],
+        http: ['fetch', 'axios'],
+        dataFetching: ['react-query', 'none'],
+        bundler: ['vite', 'cra'],
+        router: ['react-router', 'none'],
+        routerStyle: ['jsx', 'data'],
+    },
+    ios: {
+        ui: ['swiftui', 'uikit'],
+        fileSync: ['synchronized', 'groups'],
+        indent: ['2', '4'],
+    },
+    android: {
+        http: ['retrofit', 'ktor', 'none'],
+        serialization: ['kotlinx', 'moshi', 'gson'],
+        di: ['hilt', 'koin', 'manual', 'none'],
+        ui: ['compose', 'views'],
+        indent: ['2', '4'],
+    },
+    flutter: {
+        http: ['dio', 'http'],
+        serialization: ['manual', 'json_serializable', 'freezed'],
+        freezedClass: ['abstract', 'plain'],
+        apiStyle: ['repository', 'retrofit'],
+        repoKind: ['repository', 'service', 'api'],
+        di: ['getx', 'riverpod', 'get_it', 'none'],
+        importStyle: ['package', 'relative'],
+        indent: ['2', '4'],
+    },
+};
+/** Keys whose values are paths inside the project. */
+export const PATH_KEYS = new Set(['appDir', 'apiFolder', 'httpHelperFile', 'modelsFolder', 'modelsFile', 'repoFolder', 'dioProviderFile', 'diFile', 'networkFile', 'modulesFolder', 'routesFile', 'axiosInstanceFile', 'hooksFolder', 'templatesFolder', 'screensFolder', 'navigatorFile', 'routerDir', 'configFile', 'srcDir', 'navFile', 'module']);
+/** Path keys that codz creates when missing (a fresh project), so a missing one is fine. */
+const CREATED_ON_DEMAND = new Set(['screensFolder', 'navigatorFile', 'configFile', 'templatesFolder', 'hooksFolder', 'apiFolder', 'modelsFolder', 'repoFolder', 'modulesFolder', 'routesFile', 'modelsFile']);
+/** The candidate closest to a misspelled word (at most two edits away), if any. */
+export function closest(word, candidates) {
+    const dist = (a, b) => {
+        const d = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+        for (let j = 1; j <= b.length; j++)
+            d[0][j] = j;
+        for (let i = 1; i <= a.length; i++)
+            for (let j = 1; j <= b.length; j++)
+                d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1), i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1] ? d[i - 2][j - 2] + 1 : Infinity);
+        return d[a.length][b.length];
+    };
+    let best;
+    let bestD = 3;
+    for (const c of candidates) {
+        const n = dist(word.toLowerCase(), c.toLowerCase());
+        if (n < bestD)
+            [best, bestD] = [c, n];
+    }
+    return best;
+}
+export function knownKeys(framework) {
+    return framework === 'nextjs' ? NEXT_CONVENTION_DOCS : framework === 'flutter' ? FLUTTER_CONVENTION_DOCS : framework === 'react-native' ? RN_CONVENTION_DOCS : framework === 'react' ? REACT_CONVENTION_DOCS : framework === 'ios' ? IOS_CONVENTION_DOCS : framework === 'android' ? ANDROID_CONVENTION_DOCS : {};
+}
+/** Checks one value; returns an issue or null. */
+export function checkValue(framework, key, value, root) {
+    if (value === '')
+        return null;
+    const allowed = ALLOWED[framework]?.[key];
+    if (allowed && !allowed.includes(value)) {
+        return { level: 'error', key, message: `${key} is "${value}", which is not one of: ${allowed.join(', ')}.`, hint: `codz config set ${key} ${allowed[0]}` };
+    }
+    if (PATH_KEYS.has(key) && root) {
+        if (isAbsolute(value) || value.split(/[\\/]/).includes('..')) {
+            const outside = relative(resolve(root), resolve(root, value)).startsWith('..') || isAbsolute(value);
+            if (outside)
+                return { level: 'error', key, message: `${key} (${value}) points outside the project.`, hint: 'Use a path relative to the folder that holds codz.config.yaml.' };
+        }
+        if (!exists(join(root, value)) && !CREATED_ON_DEMAND.has(key)) {
+            return { level: 'warning', key, message: `${key} (${value}) does not exist.`, hint: `Fix it with codz config set ${key} <path>, or rescan with codz init --force.` };
+        }
+    }
+    return null;
+}
+export function validateConfig(text, root) {
+    const issues = [];
+    const tabLine = text.split(/\r?\n/).findIndex((l) => /^\s*\t/.test(l));
+    if (tabLine !== -1) {
+        return [{ level: 'error', message: `Line ${tabLine + 1} is indented with a tab.`, hint: 'YAML needs spaces; replace the tab with two spaces.' }];
+    }
+    let data;
+    try {
+        data = parse(text);
+    }
+    catch (e) {
+        return [{ level: 'error', message: e.message.replace(/^codz\.config\.yaml /, ''), hint: 'Fix the line, or recreate the file with codz init --force.' }];
+    }
+    for (const key of Object.keys(data)) {
+        if (key !== 'framework' && key !== 'conventions')
+            issues.push({ level: 'warning', key, message: `Unknown top-level key "${key}"; codz ignores it.` });
+    }
+    const framework = typeof data.framework === 'string' ? data.framework : '';
+    if (!framework)
+        issues.push({ level: 'error', key: 'framework', message: 'framework is missing.', hint: 'Add framework: nextjs or framework: flutter.' });
+    else if (!FRAMEWORKS.includes(framework))
+        issues.push({ level: 'error', key: 'framework', message: `framework "${framework}" is not one of: ${FRAMEWORKS.join(', ')}.` });
+    const conv = data.conventions;
+    if (conv === undefined)
+        return issues;
+    if (typeof conv !== 'object' || Array.isArray(conv)) {
+        issues.push({ level: 'error', key: 'conventions', message: 'conventions must be a list of key: value lines.' });
+        return issues;
+    }
+    const known = knownKeys(framework);
+    for (const [key, value] of Object.entries(conv)) {
+        if (typeof value !== 'string') {
+            issues.push({ level: 'error', key, message: `${key} must be a single value.` });
+            continue;
+        }
+        if (Object.keys(known).length && !(key in known)) {
+            const close = closest(key, Object.keys(known));
+            issues.push({ level: 'warning', key, message: `Unknown convention "${key}"; codz ignores it.`, hint: close ? `Did you mean ${close}?` : undefined });
+            continue;
+        }
+        const issue = checkValue(framework, key, value, root);
+        if (issue)
+            issues.push(issue);
+    }
+    return issues;
+}

package/dist/core/workflow.js

@@ -0,0 +1,72 @@
+// Workflow helpers around a change: commit it, open its diff in an editor, read
+// input from the clipboard, and summarize a change set in one line.
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { TOOL_DIR } from "./cache.js";
+import { diffStats, unifiedDiff } from "./diff.js";
+import { isGitRepo } from "./git.js";
+import { ToolError } from "./types.js";
+/** "3 files: 1 created, 2 changed, 0 deleted (+40 −3 lines)". */
+export function changeSummaryLine(cs) {
+    let created = 0;
+    let changed = 0;
+    let deleted = 0;
+    let added = 0;
+    let removed = 0;
+    for (const c of cs.changes) {
+        if (c.before === null)
+            created++;
+        else if (c.after === null)
+            deleted++;
+        else
+            changed++;
+        const s = diffStats(c.before, c.after);
+        added += s.added;
+        removed += s.removed;
+    }
+    const n = cs.changes.length;
+    const parts = [created && `${created} created`, changed && `${changed} changed`, deleted && `${deleted} deleted`].filter(Boolean).join(', ');
+    return `${n} file${n === 1 ? '' : 's'}: ${parts} (+${added} −${removed} lines)`;
+}
+/** Commits exactly the files of a change. Returns the commit hash. */
+export function commitChange(root, cs, message) {
+    if (!isGitRepo(root))
+        throw new ToolError('not_a_repo', '--commit needs a git repository.', 'Run git init first, or leave out --commit.');
+    const paths = cs.changes.map((c) => c.path);
+    const add = spawnSync('git', ['add', '-A', '--', ...paths], { cwd: root, encoding: 'utf8' });
+    if (add.status !== 0)
+        throw new ToolError('commit_failed', `git add failed: ${add.stderr.trim()}`);
+    const msg = message?.trim() || `codz ${cs.skill}: ${cs.summary[0] ?? cs.id}`.slice(0, 200);
+    const body = message?.trim() ? '' : `\n\n${cs.summary.slice(1, 15).map((s) => `- ${s.trim()}`).join('\n')}\n\ncodz change ${cs.id}`;
+    const commit = spawnSync('git', ['commit', '-m', msg + body, '--', ...paths], { cwd: root, encoding: 'utf8' });
+    if (commit.status !== 0)
+        throw new ToolError('commit_failed', `The change was applied, but git commit failed: ${(commit.stderr || commit.stdout).trim().split('\n')[0]}`, 'Commit it yourself, or undo it with codz undo.');
+    return spawnSync('git', ['rev-parse', '--short', 'HEAD'], { cwd: root, encoding: 'utf8' }).stdout.trim();
+}
+/** Writes the diff to a file and opens it in $VISUAL / $EDITOR; returns false when no editor is set. */
+export function openDiffInEditor(root, cs) {
+    const editor = process.env.VISUAL || process.env.EDITOR;
+    if (!editor)
+        return false;
+    const dir = join(root, TOOL_DIR, 'tmp');
+    mkdirSync(dir, { recursive: true });
+    const file = join(dir, `${cs.id}.diff`);
+    writeFileSync(file, cs.changes.map((c) => unifiedDiff(c.path, c.before, c.after)).join('\n'));
+    const r = spawnSync(editor, [file], { stdio: 'inherit', shell: true });
+    return r.status === 0 || r.status === null;
+}
+/** Reads text from the system clipboard. */
+export function readClipboard() {
+    const tries = process.platform === 'darwin'
+        ? [['pbpaste', []]]
+        : process.platform === 'win32'
+            ? [['powershell', ['-NoProfile', '-Command', 'Get-Clipboard -Raw']]]
+            : [['wl-paste', ['--no-newline']], ['xclip', ['-selection', 'clipboard', '-o']], ['xsel', ['--clipboard', '--output']]];
+    for (const [cmd, args] of tries) {
+        const r = spawnSync(cmd, args, { encoding: 'utf8', timeout: 5000 });
+        if (r.status === 0 && r.stdout.trim())
+            return r.stdout;
+    }
+    throw new ToolError('no_clipboard', 'Could not read the clipboard, or it is empty.', process.platform === 'linux' ? 'Install wl-clipboard, xclip or xsel, or paste on standard input instead.' : 'Copy the cURL command first, or paste it on standard input instead.');
+}

package/dist/core/workspace.js

@@ -0,0 +1,80 @@
+// A private copy of the project for commands that chain several generators
+// (feature add, auth add). Each step plans and applies against the copy, so a
+// later step sees what earlier steps wrote; at the end the copy is compared
+// with the real project and the difference becomes ONE change set, previewed
+// and undone like any other. The real project is never touched while planning.
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, relative, sep } from 'node:path';
+import { applyChangeSet, buildChangeSet } from "./changeset.js";
+import { TOOL_DIR } from "./cache.js";
+/** Folders that are generated, installed or huge; never copied and never compared. */
+const SKIP = new Set(['node_modules', '.git', '.dart_tool', 'build', '.gradle', '.next', 'Pods', '.expo', 'dist', 'out', '.idea', 'coverage', '.turbo', '.cache', TOOL_DIR, '.kotlin', '.cxx', '.externalNativeBuild']);
+/** Files larger than this are copied but never read as text for the comparison. */
+const MAX_TEXT = 2 * 1024 * 1024;
+const keep = (root) => (src) => {
+    const rel = relative(root, src);
+    if (!rel)
+        return true;
+    return !rel.split(sep).some((part) => SKIP.has(part));
+};
+function walk(root, dir = root, out = []) {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+        if (SKIP.has(e.name))
+            continue;
+        const abs = join(dir, e.name);
+        if (e.isDirectory())
+            walk(root, abs, out);
+        else if (e.isFile())
+            out.push(relative(root, abs).split(sep).join('/'));
+    }
+    return out;
+}
+export function openWorkspace(realRoot) {
+    const root = mkdtempSync(join(tmpdir(), 'codz-ws-'));
+    cpSync(realRoot, root, { recursive: true, filter: keep(realRoot), verbatimSymlinks: true });
+    const generated = [];
+    const rewrites = new Set();
+    return {
+        root,
+        apply(cs) {
+            if (!cs.changes.length)
+                return false;
+            applyChangeSet(root, cs, { allowDirty: true, format: false, verify: false });
+            generated.push(...cs.generated);
+            for (const r of cs.rewrites ?? [])
+                rewrites.add(r);
+            return true;
+        },
+        read(rel) {
+            const abs = join(root, rel);
+            return existsSync(abs) ? readFileSync(abs, 'utf8') : null;
+        },
+        write(rel, text) {
+            mkdirSync(dirname(join(root, rel)), { recursive: true });
+            writeFileSync(join(root, rel), text);
+        },
+        finish(skill, summary, warnings) {
+            const files = new Map();
+            const deletes = new Set();
+            for (const rel of walk(root)) {
+                const copy = join(root, rel);
+                if (statSync(copy).size > MAX_TEXT)
+                    continue;
+                const after = readFileSync(copy);
+                const real = join(realRoot, rel);
+                const before = existsSync(real) ? readFileSync(real) : null;
+                if (before && before.equals(after))
+                    continue;
+                files.set(rel, after.toString('utf8'));
+            }
+            for (const rel of walk(realRoot))
+                if (!existsSync(join(root, rel)))
+                    deletes.add(rel);
+            return buildChangeSet(realRoot, skill, { files, deletes, summary, warnings, generated, rewrites: [...rewrites] });
+        },
+        dispose() {
+            rmSync(root, { recursive: true, force: true });
+        },
+    };
+}

package/dist/core/yaml.js

@@ -0,0 +1,126 @@
+import { ToolError } from "./types.js";
+const PLAIN = /^[A-Za-z0-9_./{}+-][A-Za-z0-9_ ./@{}:+-]*$/;
+export function scalar(value) {
+    if (value === '')
+        return "''";
+    if (PLAIN.test(value) && !value.includes(': ') && !value.endsWith(':') && !/^(true|false|null|~|yes|no)$/i.test(value)) {
+        return value;
+    }
+    return `'${value.replace(/'/g, "''")}'`;
+}
+export function stringify(value, comments = {}, indent = 0, prefix = '') {
+    const pad = ' '.repeat(indent);
+    let out = '';
+    for (const [key, v] of Object.entries(value)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (comments[path])
+            out += `${pad}# ${comments[path]}\n`;
+        if (typeof v === 'string') {
+            out += `${pad}${key}: ${scalar(v)}\n`;
+        }
+        else if (Array.isArray(v)) {
+            if (v.length === 0) {
+                out += `${pad}${key}: []\n`;
+            }
+            else {
+                out += `${pad}${key}:\n`;
+                for (const item of v)
+                    out += `${pad}  - ${scalar(String(item))}\n`;
+            }
+        }
+        else {
+            const entries = Object.keys(v);
+            out += entries.length === 0 ? `${pad}${key}: {}\n` : `${pad}${key}:\n${stringify(v, comments, indent + 2, path)}`;
+        }
+    }
+    return out;
+}
+function unquote(raw) {
+    const s = raw.trim();
+    if (s.startsWith("'") && s.endsWith("'") && s.length >= 2)
+        return s.slice(1, -1).replace(/''/g, "'");
+    if (s.startsWith('"') && s.endsWith('"') && s.length >= 2) {
+        return s.slice(1, -1).replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+    }
+    return s;
+}
+function stripComment(line) {
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (c === "'" && !inDouble)
+            inSingle = !inSingle;
+        else if (c === '"' && !inSingle)
+            inDouble = !inDouble;
+        else if (c === '#' && !inSingle && !inDouble && (i === 0 || /\s/.test(line[i - 1])))
+            return line.slice(0, i);
+    }
+    return line;
+}
+export function parse(source) {
+    const lines = [];
+    source.split(/\r?\n/).forEach((raw, i) => {
+        const noComment = stripComment(raw).replace(/\s+$/, '');
+        if (noComment.trim() === '')
+            return;
+        if (/\t/.test(noComment.match(/^\s*/)[0]))
+            throw new ToolError('bad_config', `codz.config.yaml line ${i + 1}: use spaces, not tabs`);
+        lines.push({ indent: noComment.length - noComment.trimStart().length, text: noComment.trim(), no: i + 1 });
+    });
+    let pos = 0;
+    function parseMap(indent) {
+        const out = {};
+        while (pos < lines.length && lines[pos].indent === indent && !lines[pos].text.startsWith('- ')) {
+            const line = lines[pos];
+            const m = line.text.match(/^([^:]+?):(?:\s+(.*))?$/);
+            if (!m)
+                throw new ToolError('bad_config', `codz.config.yaml line ${line.no}: expected "key: value"`);
+            const key = unquote(m[1]);
+            const rest = m[2];
+            pos++;
+            if (rest === undefined || rest === '') {
+                if (pos < lines.length && lines[pos].indent > indent) {
+                    out[key] = lines[pos].text.startsWith('- ') ? parseList(lines[pos].indent) : parseMap(lines[pos].indent);
+                }
+                else {
+                    out[key] = '';
+                }
+            }
+            else if (rest === '[]') {
+                out[key] = [];
+            }
+            else if (rest === '{}') {
+                out[key] = {};
+            }
+            else if (rest.startsWith('[') && rest.endsWith(']')) {
+                out[key] = rest
+                    .slice(1, -1)
+                    .split(',')
+                    .map((s) => unquote(s))
+                    .filter((s) => s !== '');
+            }
+            else {
+                out[key] = unquote(rest);
+            }
+        }
+        if (pos < lines.length && lines[pos].indent > indent) {
+            throw new ToolError('bad_config', `codz.config.yaml line ${lines[pos].no}: unexpected indentation`);
+        }
+        return out;
+    }
+    function parseList(indent) {
+        const out = [];
+        while (pos < lines.length && lines[pos].indent === indent && lines[pos].text.startsWith('- ')) {
+            out.push(unquote(lines[pos].text.slice(2)));
+            pos++;
+        }
+        return out;
+    }
+    if (lines.length === 0)
+        return {};
+    const result = parseMap(lines[0].indent);
+    if (pos < lines.length)
+        throw new ToolError('bad_config', `codz.config.yaml line ${lines[pos].no}: could not parse`);
+    return result;
+}