@tarunspandit/codexflow 0.29.0

package/scripts/pro-apply.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+
+function usage() {
+  console.log(`Apply a planning-model response to the agent handoff file
+
+Usage:
+  codexflow pro-apply --root /path/to/repo --file plan.md
+  cat plan.md | codexflow pro-apply --root /path/to/repo --stdin
+
+Options:
+  --root <dir>       Workspace root. Default: current directory.
+  --file <path>      Plan file to read.
+  --stdin            Read the plan from stdin.
+  --title <text>     Add a heading when the plan does not already start with one.
+  --append           Append to .ai-bridge/current-plan.md instead of overwriting.
+  --help             Show this message.
+`);
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const raw = argv[i];
+    if (!raw.startsWith('--')) continue;
+    const eq = raw.indexOf('=');
+    const key = eq === -1 ? raw.slice(2) : raw.slice(2, eq);
+    const inlineValue = eq === -1 ? undefined : raw.slice(eq + 1);
+    if (key === 'help') out.help = true;
+    else if (key === 'stdin') out.stdin = true;
+    else if (key === 'append') out.append = true;
+    else {
+      const next = inlineValue ?? argv[i + 1];
+      if (!next || next.startsWith('--')) throw new Error(`Missing value for --${key}`);
+      if (inlineValue === undefined) i += 1;
+      out[key.replace(/-([a-z])/g, (_, c) => c.toUpperCase())] = next;
+    }
+  }
+  return out;
+}
+
+function requireBuild() {
+  const distPath = path.resolve('dist/fsOps.js');
+  if (!fs.existsSync(distPath)) {
+    throw new Error('Missing dist/fsOps.js. Run npm install && npm run build first.');
+  }
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+function resolvePlanPath(args) {
+  const callerCwd = process.env.CODEXFLOW_CALLER_CWD || process.cwd();
+  return path.isAbsolute(args.file) ? args.file : path.resolve(callerCwd, args.file);
+}
+
+async function readPlan(args) {
+  if (args.stdin && args.file) throw new Error('Use either --stdin or --file, not both.');
+  if (args.stdin) return readStdin();
+  if (!args.file) throw new Error('Missing --file <path> or --stdin.');
+  return fsp.readFile(resolvePlanPath(args), 'utf8');
+}
+
+function normalizePlan(rawPlan, title) {
+  const trimmed = rawPlan.trim();
+  if (!trimmed) throw new Error('Plan is empty.');
+  if (trimmed.startsWith('#')) return `${trimmed}\n`;
+  return `# ${title || 'Planning Model Handoff'}\n\nUpdated: ${new Date().toISOString()}\n\n${trimmed}\n`;
+}
+
+function jsonlEvent(event, data) {
+  return `${JSON.stringify({ ts: new Date().toISOString(), event, ...data })}\n`;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    usage();
+    return;
+  }
+  requireBuild();
+
+  const [{ loadConfig }, { WorkspaceManager, PathGuard }, { ensureAiBridge, readTextFile, writeTextFile }] = await Promise.all([
+    import('../dist/config.js'),
+    import('../dist/guard.js'),
+    import('../dist/fsOps.js')
+  ]);
+
+  const config = loadConfig(process.argv.slice(2));
+  const guard = new PathGuard(config);
+  const workspaces = new WorkspaceManager(config);
+  const workspace = workspaces.openWorkspace(config.defaultRoot);
+
+  const planPath = `${config.contextDir}/current-plan.md`;
+  const rawPlan = await readPlan(args);
+  const newPlan = normalizePlan(rawPlan, args.title);
+  await ensureAiBridge(config, guard, workspace);
+  let content = newPlan;
+
+  if (args.append) {
+    const resolved = guard.resolve(workspace, planPath);
+    const existing = await readTextFile(config, guard, workspace, planPath, { maxBytes: config.maxReadBytes });
+    const rawExisting = await fsp.readFile(resolved.absPath, 'utf8');
+    content = `${rawExisting.trimEnd()}\n\n---\n\n${newPlan}`;
+    void existing;
+  }
+
+  const result = await writeTextFile(config, guard, workspace, planPath, content, {
+    createDirs: true,
+    overwrite: true
+  });
+
+  const logRel = `${config.contextDir}/session-log.jsonl`;
+  const executionLogRel = `${config.contextDir}/execution-log.jsonl`;
+  const logResolved = guard.resolve(workspace, logRel, { forWrite: true });
+  const executionLogResolved = guard.resolve(workspace, executionLogRel, { forWrite: true });
+  const event = jsonlEvent('pro_apply', {
+    plan_path: planPath,
+    source_file: args.file ? resolvePlanPath(args) : 'stdin',
+    append: Boolean(args.append)
+  });
+  await fsp.appendFile(logResolved.absPath, event, 'utf8');
+  await fsp.appendFile(executionLogResolved.absPath, event, 'utf8');
+
+  console.log(`Wrote ${path.join(workspace.root, planPath)}`);
+  console.log(`Bytes: ${result.bytes}`);
+  console.log(`Diff stats: +${result.diff.additions} -${result.diff.deletions}`);
+  console.log(`Session log: ${path.join(workspace.root, logRel)}`);
+  console.log(`Execution log: ${path.join(workspace.root, executionLogRel)}`);
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+  process.exit(1);
+});

package/scripts/pro-bundle.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+function usage() {
+  console.log(`CodexFlow context bundle
+
+Usage:
+  codexflow pro-bundle --root /path/to/repo --copy
+  codexflow pro-bundle --root /path/to/repo --path src/App.tsx --glob "src/**/*.ts"
+
+Options:
+  --root <dir>              Workspace root. Default: current directory.
+  --path <file>             Extra file to include. Can be repeated.
+  --glob <pattern>          Extra glob to include. Can be repeated.
+  --title <text>            Context title.
+  --max-files <n>           Maximum file contents to include. Default: 24.
+  --max-file-bytes <n>      Maximum bytes per included file. Default: 60000.
+  --max-total-bytes <n>     Maximum bytes in .ai-bridge/pro-context.md.
+  --no-important-files      Do not auto-include root config/docs such as AGENTS.md, README.md, package.json.
+  --no-changed-files        Do not auto-include currently changed files from git status.
+  --no-diff                 Do not include git diff.
+  --no-ai-bridge            Do not include existing .ai-bridge files.
+  --copy                    Copy generated context to the macOS clipboard with pbcopy.
+  --help                    Show this message.
+`);
+}
+
+function parseArgs(argv) {
+  const out = { paths: [], globs: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const raw = argv[i];
+    if (!raw.startsWith('--')) continue;
+    const eq = raw.indexOf('=');
+    const key = eq === -1 ? raw.slice(2) : raw.slice(2, eq);
+    const inlineValue = eq === -1 ? undefined : raw.slice(eq + 1);
+    if (key === 'help') out.help = true;
+    else if (key === 'copy') out.copy = true;
+    else if (key === 'no-important-files') out.noImportantFiles = true;
+    else if (key === 'no-changed-files') out.noChangedFiles = true;
+    else if (key === 'no-diff') out.noDiff = true;
+    else if (key === 'no-ai-bridge') out.noAiBridge = true;
+    else {
+      const next = inlineValue ?? argv[i + 1];
+      if (!next || next.startsWith('--')) throw new Error(`Missing value for --${key}`);
+      if (inlineValue === undefined) i += 1;
+      if (key === 'path') out.paths.push(next);
+      else if (key === 'glob') out.globs.push(next);
+      else out[key.replace(/-([a-z])/g, (_, c) => c.toUpperCase())] = next;
+    }
+  }
+  return out;
+}
+
+function requireBuild() {
+  const distPath = path.resolve('dist/proContext.js');
+  if (!fs.existsSync(distPath)) {
+    throw new Error('Missing dist/proContext.js. Run npm install && npm run build first.');
+  }
+}
+
+function numberArg(value) {
+  if (value === undefined) return undefined;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) throw new Error(`Invalid number: ${value}`);
+  return parsed;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    usage();
+    return;
+  }
+  requireBuild();
+
+  const [{ loadConfig }, { WorkspaceManager, PathGuard }, { exportProContext }] = await Promise.all([
+    import('../dist/config.js'),
+    import('../dist/guard.js'),
+    import('../dist/proContext.js')
+  ]);
+
+  const config = loadConfig(process.argv.slice(2));
+  const guard = new PathGuard(config);
+  const workspaces = new WorkspaceManager(config);
+  const workspace = workspaces.openWorkspace(config.defaultRoot);
+  const result = await exportProContext(config, guard, workspace, {
+    title: args.title,
+    selectedPaths: args.paths,
+    extraGlobs: args.globs,
+    includeImportantFiles: !args.noImportantFiles,
+    includeChangedFiles: !args.noChangedFiles,
+    includeDiff: !args.noDiff,
+    includeAiBridge: !args.noAiBridge,
+    maxFiles: numberArg(args.maxFiles),
+    maxFileBytes: numberArg(args.maxFileBytes),
+    maxTotalBytes: numberArg(args.maxTotalBytes)
+  });
+
+  const absPath = path.join(workspace.root, result.path);
+  console.log(`Wrote ${absPath}`);
+  console.log(`Bytes: ${result.bytes}`);
+  console.log(`Files included: ${result.filesIncluded.length}`);
+  console.log(`Files skipped: ${result.filesSkipped.length}`);
+  console.log(`Truncated: ${result.truncated}`);
+
+  if (args.copy) {
+    const copied = spawnSync('pbcopy', { input: result.markdown, encoding: 'utf8' });
+    if (copied.status !== 0) {
+      throw new Error(`pbcopy failed: ${copied.stderr || copied.error?.message || `exit ${copied.status}`}`);
+    }
+    console.log('Copied Pro context to clipboard.');
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+  process.exit(1);
+});

package/scripts/pro-smoke.mjs

@@ -0,0 +1,95 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+function run(args, options = {}) {
+  const result = spawnSync(process.execPath, args, {
+    cwd: path.resolve('.'),
+    encoding: 'utf8',
+    ...options
+  });
+  if (result.status !== 0) {
+    throw new Error(`${args.join(' ')} failed\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+  }
+  return result;
+}
+
+function runFail(args, options = {}) {
+  const result = spawnSync(process.execPath, args, {
+    cwd: path.resolve('.'),
+    encoding: 'utf8',
+    ...options
+  });
+  if (result.status === 0) {
+    throw new Error(`${args.join(' ')} unexpectedly passed\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+  }
+  return result;
+}
+
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'codexflow-pro-smoke-'));
+const codexflowCli = path.resolve('scripts/codexflow.mjs');
+await fs.writeFile(path.join(root, 'README.md'), '# Demo\n', 'utf8');
+await fs.writeFile(path.join(root, 'demo.txt'), 'alpha\nbeta\n', 'utf8');
+
+run(['scripts/pro-bundle.mjs', `--root=${root}`, '--path=demo.txt', '--max-files', '4', '--max-total-bytes', '80000']);
+const proContext = await fs.readFile(path.join(root, '.ai-bridge', 'pro-context.md'), 'utf8');
+if (!proContext.includes('CodexFlow Context Bundle') || !proContext.includes('demo.txt')) {
+  throw new Error('pro context bundle did not include expected content');
+}
+
+const selectedRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'codexflow-pro-selected-'));
+await fs.writeFile(path.join(selectedRoot, 'README.md'), '# Selected\n', 'utf8');
+await fs.writeFile(path.join(selectedRoot, 'demo.txt'), 'selected only\n', 'utf8');
+run([
+  'scripts/pro-bundle.mjs',
+  `--root=${selectedRoot}`,
+  '--path=demo.txt',
+  '--no-important-files',
+  '--no-changed-files',
+  '--no-diff',
+  '--no-ai-bridge',
+  '--max-files', '4',
+  '--max-total-bytes', '80000'
+]);
+const selectedBridgeFiles = await fs.readdir(path.join(selectedRoot, '.ai-bridge'));
+if (selectedBridgeFiles.join(',') !== 'pro-context.md') {
+  throw new Error(`selected-only pro context created unexpected bridge files: ${selectedBridgeFiles.join(', ')}`);
+}
+const exactProContext = await fs.readFile(path.join(selectedRoot, '.ai-bridge', 'pro-context.md'), 'utf8');
+if (!exactProContext.includes('Auto-include important root files: no') || !exactProContext.includes('Auto-include changed files: no')) {
+  throw new Error('selected-only pro context did not record disabled auto-inclusion settings');
+}
+if (!exactProContext.includes('### demo.txt') || exactProContext.includes('### README.md')) {
+  throw new Error('selected-only pro context did not include exactly the requested file');
+}
+
+run([codexflowCli, 'pro-bundle', `--root=${root}`, '--path=demo.txt', '--max-files=4', '--max-total-bytes=80000']);
+
+const planFile = path.join(root, 'plan.md');
+await fs.writeFile(planFile, 'Inspect demo.txt and keep changes narrow.\n', 'utf8');
+run(['scripts/pro-apply.mjs', `--root=${root}`, `--file=${planFile}`, '--title', 'Smoke Pro Plan']);
+run([codexflowCli, 'pro-apply', `--root=${root}`, '--file=plan.md', '--title', 'Relative Pro Plan'], { cwd: root });
+const currentPlan = await fs.readFile(path.join(root, '.ai-bridge', 'current-plan.md'), 'utf8');
+if (!currentPlan.includes('Relative Pro Plan') || !currentPlan.includes('Inspect demo.txt')) {
+  throw new Error('pro apply did not write expected current-plan content');
+}
+const executionLog = await fs.readFile(path.join(root, '.ai-bridge', 'execution-log.jsonl'), 'utf8');
+if (!executionLog.includes('"event":"pro_apply"')) {
+  throw new Error('pro apply did not append execution-log event');
+}
+const proApplyEvents = executionLog.trim().split('\n').map((line) => JSON.parse(line));
+if (!proApplyEvents.some((event) => event.source_file === planFile)) {
+  throw new Error(`pro apply logged the wrong source file\n${executionLog}`);
+}
+
+const missingRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'codexflow-pro-missing-'));
+runFail(['scripts/pro-apply.mjs', `--root=${missingRoot}`, '--file=missing-plan.md'], { env: { ...process.env, CODEXFLOW_CALLER_CWD: missingRoot } });
+try {
+  await fs.stat(path.join(missingRoot, '.ai-bridge'));
+  throw new Error('failed pro-apply created .ai-bridge before validating input');
+} catch (error) {
+  if (error?.code !== 'ENOENT') throw error;
+}
+
+console.log('✓ pro CLI smoke test passed');