profclaw 0.0.1-beta.3 → 2.3.0

package/dist/cli/commands/init.js

@@ -0,0 +1,381 @@
+/**
+ * CLI Init Command
+ *
+ * Scans the current project directory and generates a `.profclaw/context.md`
+ * file describing the tech stack, structure, build/test commands, and conventions.
+ *
+ * Usage:
+ *   profclaw init          # interactive (asks before overwriting)
+ *   profclaw init --force  # overwrite without prompting
+ */
+import { Command } from 'commander';
+import { existsSync, readFileSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { confirm } from '@inquirer/prompts';
+import { success, error, info, spinner } from '../utils/output.js';
+// ── Manifest readers ──────────────────────────────────────────────────────────
+function readJson(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function readText(filePath) {
+    try {
+        return readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function fileExists(filePath) {
+    return existsSync(filePath);
+}
+// ── Detectors ─────────────────────────────────────────────────────────────────
+function detectLanguage(cwd) {
+    if (fileExists(path.join(cwd, 'Cargo.toml')))
+        return 'Rust';
+    if (fileExists(path.join(cwd, 'go.mod')))
+        return 'Go';
+    if (fileExists(path.join(cwd, 'pyproject.toml')) || fileExists(path.join(cwd, 'setup.py')))
+        return 'Python';
+    if (fileExists(path.join(cwd, 'tsconfig.json')))
+        return 'TypeScript';
+    if (fileExists(path.join(cwd, 'package.json')))
+        return 'JavaScript';
+    if (fileExists(path.join(cwd, 'pom.xml')) || fileExists(path.join(cwd, 'build.gradle')))
+        return 'Java';
+    if (fileExists(path.join(cwd, 'mix.exs')))
+        return 'Elixir';
+    if (fileExists(path.join(cwd, 'Gemfile')))
+        return 'Ruby';
+    return 'Unknown';
+}
+function detectPackageManager(cwd) {
+    if (fileExists(path.join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (fileExists(path.join(cwd, 'yarn.lock')))
+        return 'yarn';
+    if (fileExists(path.join(cwd, 'bun.lockb')))
+        return 'bun';
+    if (fileExists(path.join(cwd, 'package-lock.json')))
+        return 'npm';
+    return 'npm';
+}
+function detectFramework(cwd, pkg) {
+    const deps = {
+        ...(pkg?.dependencies ?? {}),
+        ...(pkg?.devDependencies ?? {}),
+    };
+    const hasDep = (name) => name in deps;
+    if (hasDep('next'))
+        return 'Next.js';
+    if (hasDep('nuxt'))
+        return 'Nuxt';
+    if (hasDep('astro'))
+        return 'Astro';
+    if (hasDep('remix'))
+        return 'Remix';
+    if (hasDep('@sveltejs/kit'))
+        return 'SvelteKit';
+    if (hasDep('svelte'))
+        return 'Svelte';
+    if (hasDep('react'))
+        return 'React';
+    if (hasDep('vue'))
+        return 'Vue';
+    if (hasDep('express'))
+        return 'Express';
+    if (hasDep('fastify'))
+        return 'Fastify';
+    if (hasDep('hono'))
+        return 'Hono';
+    if (hasDep('@nestjs/core'))
+        return 'NestJS';
+    if (hasDep('commander'))
+        return 'CLI (commander)';
+    if (hasDep('ink'))
+        return 'CLI (ink/TUI)';
+    if (fileExists(path.join(cwd, 'pyproject.toml'))) {
+        const content = readText(path.join(cwd, 'pyproject.toml')) ?? '';
+        if (content.includes('fastapi'))
+            return 'FastAPI';
+        if (content.includes('flask'))
+            return 'Flask';
+        if (content.includes('django'))
+            return 'Django';
+    }
+    if (fileExists(path.join(cwd, 'Cargo.toml'))) {
+        const content = readText(path.join(cwd, 'Cargo.toml')) ?? '';
+        if (content.includes('axum'))
+            return 'Axum';
+        if (content.includes('actix-web'))
+            return 'Actix-web';
+        if (content.includes('rocket'))
+            return 'Rocket';
+    }
+    if (fileExists(path.join(cwd, 'go.mod'))) {
+        const content = readText(path.join(cwd, 'go.mod')) ?? '';
+        if (content.includes('gin-gonic'))
+            return 'Gin';
+        if (content.includes('echo'))
+            return 'Echo';
+        if (content.includes('fiber'))
+            return 'Fiber';
+    }
+    return 'None detected';
+}
+function detectBuildAndTestCommands(cwd, pkg, pm, language) {
+    const scripts = pkg?.scripts ?? {};
+    const run = (script) => `${pm} run ${script}`;
+    const build = scripts['build'] ? run('build') :
+        language === 'Rust' ? 'cargo build --release' :
+            language === 'Go' ? 'go build ./...' :
+                language === 'Python' ? (fileExists(path.join(cwd, 'pyproject.toml')) ? 'python -m build' : 'python setup.py build') :
+                    scripts['compile'] ? run('compile') :
+                        'N/A';
+    const test = scripts['test'] ? run('test') :
+        language === 'Rust' ? 'cargo test' :
+            language === 'Go' ? 'go test ./...' :
+                language === 'Python' ? 'pytest' :
+                    scripts['check'] ? run('check') :
+                        'N/A';
+    const dev = scripts['dev'] ? run('dev') :
+        scripts['start'] ? run('start') :
+            scripts['serve'] ? run('serve') :
+                'N/A';
+    return { build, test, dev };
+}
+function detectKeyDirs(cwd) {
+    const candidates = [
+        { name: 'src', purpose: 'Source code' },
+        { name: 'app', purpose: 'Application code' },
+        { name: 'lib', purpose: 'Library / shared utilities' },
+        { name: 'packages', purpose: 'Monorepo packages' },
+        { name: 'apps', purpose: 'Monorepo applications' },
+        { name: 'tests', purpose: 'Test files' },
+        { name: 'test', purpose: 'Test files' },
+        { name: '__tests__', purpose: 'Jest test files' },
+        { name: 'docs', purpose: 'Documentation' },
+        { name: 'scripts', purpose: 'Build / utility scripts' },
+        { name: 'public', purpose: 'Static assets' },
+        { name: 'assets', purpose: 'Static assets' },
+        { name: 'api', purpose: 'API layer' },
+        { name: 'components', purpose: 'UI components' },
+        { name: 'pages', purpose: 'Page components / routes' },
+        { name: 'hooks', purpose: 'React hooks' },
+        { name: 'services', purpose: 'Service / business logic layer' },
+        { name: 'utils', purpose: 'Utility functions' },
+        { name: 'config', purpose: 'Configuration files' },
+        { name: 'migrations', purpose: 'Database migrations' },
+        { name: 'prisma', purpose: 'Prisma schema and migrations' },
+        { name: 'drizzle', purpose: 'Drizzle ORM schema' },
+        { name: '.github', purpose: 'GitHub Actions / workflows' },
+        { name: 'docker', purpose: 'Docker configuration' },
+        { name: 'infra', purpose: 'Infrastructure / IaC' },
+        { name: 'k8s', purpose: 'Kubernetes manifests' },
+    ];
+    return candidates
+        .filter(c => fileExists(path.join(cwd, c.name)))
+        .map(c => ({ path: c.name, purpose: c.purpose }));
+}
+function detectConventions(cwd, pkg) {
+    const conventions = [];
+    // Linting
+    if (fileExists(path.join(cwd, '.eslintrc.js')) ||
+        fileExists(path.join(cwd, '.eslintrc.json')) ||
+        fileExists(path.join(cwd, 'eslint.config.js')) ||
+        fileExists(path.join(cwd, 'eslint.config.ts'))) {
+        conventions.push('ESLint for linting');
+    }
+    if (fileExists(path.join(cwd, '.prettierrc')) ||
+        fileExists(path.join(cwd, '.prettierrc.json')) ||
+        fileExists(path.join(cwd, 'prettier.config.js')) ||
+        fileExists(path.join(cwd, 'prettier.config.ts'))) {
+        conventions.push('Prettier for formatting');
+    }
+    if (fileExists(path.join(cwd, 'biome.json')) || fileExists(path.join(cwd, 'biome.jsonc'))) {
+        conventions.push('Biome for linting and formatting');
+    }
+    // Editor config
+    if (fileExists(path.join(cwd, '.editorconfig'))) {
+        const content = readText(path.join(cwd, '.editorconfig')) ?? '';
+        const indentMatch = content.match(/indent_style\s*=\s*(\w+)/);
+        const sizeMatch = content.match(/indent_size\s*=\s*(\d+)/);
+        if (indentMatch && sizeMatch) {
+            conventions.push(`${indentMatch[1] === 'tab' ? 'Tabs' : `${sizeMatch[1]}-space`} indentation (from .editorconfig)`);
+        }
+    }
+    // TypeScript strictness
+    if (fileExists(path.join(cwd, 'tsconfig.json'))) {
+        const tsconfig = readJson(path.join(cwd, 'tsconfig.json'));
+        const co = tsconfig?.compilerOptions;
+        if (co?.strict === true)
+            conventions.push('TypeScript strict mode enabled');
+        if (co?.noUncheckedIndexedAccess === true)
+            conventions.push('noUncheckedIndexedAccess enforced');
+    }
+    // Git hooks
+    if (fileExists(path.join(cwd, '.husky')))
+        conventions.push('Husky git hooks');
+    // Commit conventions
+    if (fileExists(path.join(cwd, 'commitlint.config.js')) ||
+        fileExists(path.join(cwd, 'commitlint.config.ts'))) {
+        conventions.push('commitlint for conventional commits');
+    }
+    const scripts = pkg?.scripts ?? {};
+    if (scripts['lint'])
+        conventions.push(`Lint command: \`${scripts['lint']}\``);
+    if (scripts['format'])
+        conventions.push(`Format command: \`${scripts['format']}\``);
+    if (scripts['typecheck'] || scripts['type-check']) {
+        conventions.push(`Type-check command: \`${scripts['typecheck'] ?? scripts['type-check']}\``);
+    }
+    return conventions;
+}
+function detectRecentActivity(cwd) {
+    try {
+        const log = execSync('git log --oneline --no-merges -10', { cwd, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        if (!log)
+            return 'No git history found.';
+        return log;
+    }
+    catch {
+        return 'No git repository or git unavailable.';
+    }
+}
+function extractDescription(cwd, pkg) {
+    if (pkg?.description && typeof pkg.description === 'string' && pkg.description.trim()) {
+        return pkg.description.trim();
+    }
+    const readme = readText(path.join(cwd, 'README.md')) ?? readText(path.join(cwd, 'readme.md'));
+    if (readme) {
+        // Take the first non-heading paragraph (strip markdown headings)
+        const lines = readme.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('!') && trimmed.length > 20) {
+                return trimmed.replace(/[*_`]/g, '').slice(0, 200);
+            }
+        }
+    }
+    return 'No description found. Add one in README.md or package.json.';
+}
+// ── Main scan function ────────────────────────────────────────────────────────
+async function scanProject(cwd) {
+    const pkg = readJson(path.join(cwd, 'package.json'));
+    const language = detectLanguage(cwd);
+    const pm = detectPackageManager(cwd);
+    const framework = detectFramework(cwd, pkg);
+    const { build, test, dev } = detectBuildAndTestCommands(cwd, pkg, pm, language);
+    const keyDirs = detectKeyDirs(cwd);
+    const conventions = detectConventions(cwd, pkg);
+    const recentActivity = detectRecentActivity(cwd);
+    const description = extractDescription(cwd, pkg);
+    const name = pkg?.name ?? path.basename(cwd);
+    return {
+        name,
+        description,
+        language,
+        framework,
+        buildCommand: build,
+        testCommand: test,
+        devCommand: dev,
+        keyDirs,
+        conventions,
+        recentActivity,
+        packageManager: pm,
+    };
+}
+// ── Context file generator ────────────────────────────────────────────────────
+function generateContextMarkdown(info) {
+    const now = new Date().toISOString().slice(0, 10);
+    const structureLines = info.keyDirs.length > 0
+        ? info.keyDirs.map(d => `- \`${d.path}/\` — ${d.purpose}`).join('\n')
+        : '- No key directories detected automatically.';
+    const conventionLines = info.conventions.length > 0
+        ? info.conventions.map(c => `- ${c}`).join('\n')
+        : '- No convention files detected.';
+    return `# Project Context
+> Auto-generated by \`profclaw init\` on ${now}. Edit freely — this file is yours.
+
+## Overview
+
+${info.description}
+
+**Project name:** \`${info.name}\`
+
+## Tech Stack
+
+- **Language:** ${info.language}
+- **Framework:** ${info.framework}
+- **Package manager:** ${info.packageManager}
+- **Build:** \`${info.buildCommand}\`
+- **Test:** \`${info.testCommand}\`
+- **Dev server:** \`${info.devCommand}\`
+
+## Structure
+
+${structureLines}
+
+## Conventions
+
+${conventionLines}
+
+## Recent Activity
+
+\`\`\`
+${info.recentActivity}
+\`\`\`
+`;
+}
+// ── Command ───────────────────────────────────────────────────────────────────
+export function initCommand() {
+    const cmd = new Command('init')
+        .description('Scan the project and generate .profclaw/context.md')
+        .option('-f, --force', 'Overwrite existing context.md without prompting')
+        .option('--dir <path>', 'Project directory to scan (default: cwd)')
+        .action(async (options) => {
+        const cwd = options.dir ? path.resolve(options.dir) : process.cwd();
+        const outputDir = path.join(cwd, '.profclaw');
+        const outputPath = path.join(outputDir, 'context.md');
+        // Check for existing file
+        if (fileExists(outputPath) && !options.force) {
+            const overwrite = await confirm({
+                message: '.profclaw/context.md already exists. Overwrite?',
+                default: false,
+            });
+            if (!overwrite) {
+                info('Aborted. Use --force to overwrite without prompting.');
+                return;
+            }
+        }
+        const spin = spinner('Scanning project...').start();
+        try {
+            const projectInfo = await scanProject(cwd);
+            spin.stop();
+            const markdown = generateContextMarkdown(projectInfo);
+            await fs.mkdir(outputDir, { recursive: true });
+            await fs.writeFile(outputPath, markdown, 'utf-8');
+            success(`Context written to .profclaw/context.md`);
+            console.log('');
+            console.log(`  Project : ${projectInfo.name}`);
+            console.log(`  Language: ${projectInfo.language}`);
+            console.log(`  Framework: ${projectInfo.framework}`);
+            console.log(`  Dirs scanned: ${projectInfo.keyDirs.length}`);
+            console.log('');
+            info('Edit .profclaw/context.md to add your own notes and conventions.');
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Init failed');
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=init.js.map

package/dist/cli/commands/models.js

@@ -16,6 +16,13 @@ function formatCostPair(input, output) {
         return chalk.dim('-');
     return `$${input.toFixed(2)}/$${output.toFixed(2)}`;
 }
+/**
+ * Extract the provider type from a model ID (e.g. "anthropic/claude-3" -> "anthropic")
+ */
+function extractProvider(modelId) {
+    const slash = modelId.indexOf('/');
+    return slash > 0 ? modelId.slice(0, slash) : undefined;
+}
 export function modelsCommands() {
     const cmd = new Command('models')
         .description('Manage AI model configuration');
@@ -29,13 +36,13 @@ export function modelsCommands() {
         const spin = spinner('Fetching models...').start();
         try {
             const params = options.provider ? `?provider=${encodeURIComponent(options.provider)}` : '';
-            const result = await api.get(`/api/providers/models${params}`);
+            const result = await api.get(`/api/chat/models${params}`);
             spin.stop();
             if (!result.ok) {
                 error(result.error || 'Failed to fetch models');
                 process.exit(1);
             }
-            const { models, default: defaultModel } = result.data;
+            const { models } = result.data;
             if (options.json) {
                 console.log(JSON.stringify(result.data, null, 2));
                 return;
@@ -44,21 +51,17 @@ export function modelsCommands() {
                 info('No models available.');
                 return;
             }
-            const table = createTable(['Model', 'Provider', 'Context', 'Cost (in/out)', 'Default']);
+            const table = createTable(['Model', 'Provider', 'Context', 'Cost (in/out)']);
             for (const m of models) {
-                const isDefault = m.id === defaultModel || m.isDefault;
                 table.push([
-                    isDefault ? chalk.cyan(truncate(m.id, 35)) + chalk.yellow(' *') : truncate(m.id, 35),
+                    truncate(m.id, 40),
                     m.provider,
                     formatContext(m.contextWindow),
                     formatCostPair(m.costPer1MInput, m.costPer1MOutput),
-                    isDefault ? chalk.yellow('yes') : chalk.dim('no'),
                 ]);
             }
             console.log(table.toString());
             console.log(chalk.dim(`\n${models.length} model${models.length !== 1 ? 's' : ''}`));
-            if (defaultModel)
-                console.log(chalk.dim(`Default: ${defaultModel}`));
         }
         catch (err) {
             spin.stop();
@@ -73,13 +76,17 @@ export function modelsCommands() {
         .action(async (model, options) => {
         const spin = spinner(`Fetching info for ${model}...`).start();
         try {
-            const result = await api.get(`/api/providers/models/${encodeURIComponent(model)}`);
+            const result = await api.get('/api/chat/models');
             spin.stop();
             if (!result.ok) {
-                error(result.error || `Model ${model} not found`);
+                error(result.error || 'Failed to fetch models');
+                process.exit(1);
+            }
+            const m = result.data.models.find((entry) => entry.id === model || entry.id.endsWith(`/${model}`));
+            if (!m) {
+                error(`Model ${model} not found`);
                 process.exit(1);
             }
-            const m = result.data;
             if (options.json) {
                 console.log(JSON.stringify(m, null, 2));
                 return;
@@ -102,12 +109,18 @@ export function modelsCommands() {
     });
     cmd
         .command('set-default <model>')
-        .description('Set the default model')
+        .description('Set the default model for a provider')
         .option('--json', 'Output as JSON')
         .action(async (model, options) => {
+        const provider = extractProvider(model);
+        if (!provider) {
+            error('Model must include provider prefix (e.g. anthropic/claude-sonnet-4-20250514)');
+            process.exit(1);
+        }
         const spin = spinner(`Setting default model to ${model}...`).start();
         try {
-            const result = await api.post('/api/providers/models/default', { model });
+            const modelName = model.slice(provider.length + 1);
+            const result = await api.post(`/api/chat/providers/${encodeURIComponent(provider)}/configure`, { defaultModel: modelName });
             spin.stop();
             if (!result.ok) {
                 error(result.error || 'Failed to set default model');
@@ -132,7 +145,7 @@ export function modelsCommands() {
         .action(async (options) => {
         const spin = spinner('Fetching aliases...').start();
         try {
-            const result = await api.get('/api/providers/models/aliases');
+            const result = await api.get('/api/chat/models');
             spin.stop();
             if (!result.ok) {
                 error(result.error || 'Failed to fetch aliases');
@@ -143,14 +156,13 @@ export function modelsCommands() {
                 console.log(JSON.stringify(aliases, null, 2));
                 return;
             }
-            const entries = Object.entries(aliases);
-            if (entries.length === 0) {
+            if (!aliases || aliases.length === 0) {
                 info('No model aliases configured.');
                 return;
             }
-            const table = createTable(['Alias', 'Resolves To']);
-            for (const [alias, target] of entries) {
-                table.push([chalk.cyan(alias), target]);
+            const table = createTable(['Alias', 'Provider', 'Model']);
+            for (const entry of aliases) {
+                table.push([chalk.cyan(entry.alias), entry.provider, entry.model]);
             }
             console.log(table.toString());
         }
@@ -162,15 +174,16 @@ export function modelsCommands() {
     });
     cmd
         .command('test <model>')
-        .description('Test a model with a quick prompt')
+        .description('Test a model provider health check')
         .option('--json', 'Output as JSON')
         .action(async (model, options) => {
-        const spin = spinner(`Testing ${model}...`).start();
+        const provider = extractProvider(model) ?? model;
+        const spin = spinner(`Testing ${provider}...`).start();
         try {
-            const result = await api.post(`/api/providers/models/${encodeURIComponent(model)}/test`);
+            const result = await api.post(`/api/chat/providers/${encodeURIComponent(provider)}/health`);
             spin.stop();
             if (!result.ok) {
-                error(result.error || `Failed to test ${model}`);
+                error(result.error || `Failed to test ${provider}`);
                 process.exit(1);
             }
             const data = result.data;
@@ -178,12 +191,12 @@ export function modelsCommands() {
                 console.log(JSON.stringify(data, null, 2));
                 return;
             }
-            if (data.ok) {
+            if (data.healthy) {
                 const latency = data.latencyMs != null ? chalk.dim(` (${data.latencyMs}ms)`) : '';
-                success(`${chalk.cyan(model)} responded successfully${latency}`);
+                success(`${chalk.cyan(provider)} is healthy${latency}`);
             }
             else {
-                error(`${chalk.cyan(model)} test failed: ${data.error || 'Unknown error'}`);
+                error(`${chalk.cyan(provider)} health check failed: ${data.message || 'Unknown error'}`);
             }
         }
         catch (err) {