tewip-ai 0.12.0 → 0.13.0

package/README.md

@@ -185,6 +185,8 @@ defects were found before release - a Robot timestamp that is not a date, k6's n
 
 ```bash
 tewip build "naturalsize should take a sep argument that goes between the number and the unit"
+tewip build --issue PROJ-123    # build from the ticket's own description and acceptance criteria
+tewip build "..." --pr          # commit the proved work on its own branch, open a draft PR
 tewip build "..." --dry-run     # prove it, show the patch, leave nothing on disk
 ```
 
@@ -199,6 +201,12 @@ TypeScript, $0.18) and a `sep` argument to **python-humanize** (2 lines, Python,
 its own failing-then-passing test and the project's whole suite still green. Asked for something
 that already worked, it stopped after one model call and kept nothing.
 
+It also refuses a feature that does not belong here at all. Handed a real Apache ticket about a
+Flink HTTP sink, a URL library got an "HTTP sink" built into it - test passing, suite green, every
+proof rule held, because when Tewip writes *both* the test and the code it can always make a
+self-consistent pair pass. So before writing anything it now asks whether the words of the feature
+mean anything in this repository, and refuses for free when they do not.
+
 The old promise was *"it can't touch your code"*. The new one is *"it can't change your code without
 showing you it works"*.
 

package/dist/cli/tewip.js

@@ -67,11 +67,14 @@ Usage:
                                     the GitLab merge request, tells Slack or Teams only when a
                                     failure needs a person, and with --gate fails the build only on
                                     those failures.
-  tewip build "<what it should do>" [--dry-run] [--repairs 2] [--out feature.patch]
+  tewip build "<what it should do>" | --issue PROJ-123 [--dry-run] [--pr] [--out feature.patch]
                                     Writes a feature, test first: the test must fail without the
                                     code and pass with it, and every test that was passing must
                                     still pass - otherwise everything goes back byte for byte.
-                                    Nothing is committed.
+      --issue PROJ-123              Build from the ticket itself: its description and acceptance
+                                    criteria. Works with a public tracker without an account.
+      --pr                          Commit the proved work on a branch of its own and open a draft
+                                    pull request. Never merges, never commits to your branch.
   tewip review [--diff main...HEAD] [--out review.md]
                                     Before anyone reads the diff: which tests cover this change,
                                     which of them have flaked before, what has gone wrong in these
@@ -262,9 +265,24 @@ async function main() {
             return;
         }
         case 'build': {
-            const feature = args.filter((a, i) => !a.startsWith('--') && !['--repairs', '--out', '--max-lines'].includes(args[i - 1] ?? '')).join(' ').trim();
+            const typed = args.filter((a, i) => !a.startsWith('--') && !['--repairs', '--out', '--max-lines', '--issue'].includes(args[i - 1] ?? '')).join(' ').trim();
+            const issueKey = flag(args, 'issue');
+            let feature = typed;
+            let issueTitle = '';
+            if (issueKey) {
+                // A ticket says what was asked for better than a sentence typed twice.
+                const { Jira, jiraFromEnv, jiraHelp } = await import('../engine/work/jira.js');
+                const { featureFromIssue } = await import('../engine/work/jira-command.js');
+                const config = jiraFromEnv();
+                if (!config)
+                    throw new Error(jiraHelp());
+                const issue = await new Jira(config).issue(issueKey);
+                console.error(`Read ${issue.key} (${issue.type}, ${issue.status})${issue.acceptanceCriteria ? ' with its acceptance criteria' : ''}.`);
+                issueTitle = `${issue.key}: ${issue.summary}`;
+                feature = [featureFromIssue(issue), typed].filter(Boolean).join('\n\n');
+            }
             if (!feature)
-                throw new Error('usage: tewip build "<what the feature should do>" [--dry-run] [--repairs 2] [--out feature.patch]');
+                throw new Error('usage: tewip build "<what the feature should do>" | --issue PROJ-123 [--dry-run] [--pr] [--out feature.patch]');
             const { runBuild, renderBuild } = await import('../engine/build/build-command.js');
             const dryRun = args.includes('--dry-run');
             const result = await runBuild({
@@ -276,9 +294,27 @@ async function main() {
                 out: flag(args, 'out'),
             });
             console.log(`
-${renderBuild(result, feature, dryRun)}`);
-            if (result.status !== 'built')
+${renderBuild(result, issueTitle || feature, dryRun)}`);
+            if (result.status !== 'built') {
                 process.exitCode = 1;
+                return;
+            }
+            if (args.includes('--pr')) {
+                if (dryRun)
+                    throw new Error('--pr and --dry-run ask for opposite things: one keeps the work, the other puts it back.');
+                const { proposePullRequest } = await import('../engine/build/propose-pr.js');
+                const proposed = proposePullRequest({
+                    root: process.cwd(),
+                    files: result.files,
+                    title: (issueTitle || feature.split('\n')[0]).slice(0, 72),
+                    body: result.why,
+                    issue: issueKey,
+                });
+                console.log(`
+${proposed.status === 'opened' ? 'Opened a draft pull request.' : proposed.status === 'committed' ? `Committed on ${proposed.branch}.` : 'No pull request was opened.'}`);
+                for (const line of proposed.next)
+                    console.log(`  ${line}`);
+            }
             return;
         }
         case 'review': {

package/dist/engine/build/build-command.js

@@ -53,6 +53,57 @@ export function definingSources(root, feature, limit = 3) {
     }
     return scored.sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.file);
 }
+/**
+ * Does this feature belong in this project at all?
+ *
+ * Found by trying it: a real Apache ticket about a Flink HTTP sink was handed to a URL library, and
+ * Tewip built an "HTTP sink" into it - 28 lines, its own test passing, the suite green. Every proof
+ * rule held, because when Tewip writes both the test and the code it can always make a
+ * self-consistent pair pass. Nothing else referenced the invented API, so nothing else could break.
+ *
+ * The missing check is the obvious one: the words of the feature have to mean something here. A
+ * project's own vocabulary is its file names and what it exports, and a feature that shares almost
+ * none of it is a feature for some other repository.
+ */
+export function belongsHere(root, feature, sources, testNames) {
+    const stop = new Set(['should', 'when', 'with', 'that', 'this', 'from', 'into', 'have', 'been', 'will', 'must', 'also', 'able', 'given', 'then', 'there', 'their', 'which', 'while', 'where', 'after', 'before', 'value', 'values', 'return', 'returns', 'support', 'supports', 'accept', 'accepts', 'option', 'options', 'default', 'behaviour', 'behavior', 'feature', 'example', 'instead', 'without']);
+    const words = (text) => new Set((text.toLowerCase().match(/[a-z][a-z0-9]{3,}/g) ?? []).filter((w) => !stop.has(w)));
+    const asked = [...words(feature)];
+    if (asked.length < 3)
+        return { ok: true, why: '' };
+    const vocabulary = new Set();
+    for (const s of sources)
+        for (const w of words(`${s.file} ${s.content.slice(0, 20_000)}`))
+            vocabulary.add(w);
+    for (const name of testNames)
+        for (const w of words(name))
+            vocabulary.add(w);
+    // The names of a project's files are not its vocabulary: "naturalsize" lives inside filesize.py,
+    // not in its name, and judging by names alone refused a feature that really did belong here.
+    let read = 0;
+    for (const file of sourceFiles(root, 1200)) {
+        if (!CODE_FILE.test(file) || read >= 60)
+            continue;
+        read++;
+        try {
+            for (const w of words(`${basename(file)} ${readFileSync(file, 'utf8').slice(0, 20_000)}`))
+                vocabulary.add(w);
+        }
+        catch {
+            // unreadable here is simply one less file of vocabulary
+        }
+    }
+    if (vocabulary.size === 0)
+        return { ok: true, why: '' };
+    const shared = asked.filter((w) => vocabulary.has(w));
+    const share = shared.length / asked.length;
+    if (share >= 0.2)
+        return { ok: true, why: '' };
+    return {
+        ok: false,
+        why: `almost nothing in this project mentions what that describes (${shared.length} of ${asked.length} of its words appear here${shared.length ? `: ${shared.slice(0, 5).join(', ')}` : ''}). If this is the right repository, say the feature in its own words - the names of the functions and files it should change. Tewip can make a test of its own invention pass in any project, and that would prove nothing.`,
+    };
+}
 /** A test file name in the project's own shape, that does not collide with an existing one. */
 function testPathFor(framework, feature) {
     const stem = feature.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').split('-').slice(0, 4).join('-') || 'feature';
@@ -88,6 +139,10 @@ export async function runBuild(cmd) {
         testNames: tests.tests,
     };
     const log = [`framework: ${framework.label}`, `source files read: ${ctx.sources.map((s) => s.file).join(', ') || 'none found'}`];
+    // Before anything is written: is this even a feature for this repository?
+    const belongs = belongsHere(root, cmd.feature, ctx.sources, ctx.testNames);
+    if (!belongs.ok)
+        return { status: 'not-this-project', why: belongs.why, files: [], diff: '', log: [...log, belongs.why] };
     const workspace = new Workspace(root);
     const maxLines = cmd.maxLines ?? 120;
     const stop = (status, why) => {

package/dist/engine/build/propose-pr.js

@@ -0,0 +1,88 @@
+// Turning proved work into a pull request - the last step of the loop, and the one where Tewip
+// touches somebody's repository, so it is the most careful.
+//
+// Three rules, enforced here rather than promised:
+//   it only ever pushes a new branch of its own, never yours;
+//   it never merges, and opens the request as a draft so nobody can merge it by reflex;
+//   it describes exactly what was proved and what was not, because a pull request nobody can check
+//   is worse than a patch file.
+//
+// The work must already be proved before anything reaches this file. Nothing here runs a test or
+// decides anything; it commits what was verified and opens the request.
+import { spawnSync } from 'node:child_process';
+const run = (cwd, command, args) => {
+    const r = spawnSync(command, args, { cwd, encoding: 'utf8', timeout: 120_000, maxBuffer: 16 * 1024 * 1024 });
+    return { ok: r.status === 0, out: `${r.stdout ?? ''}${r.stderr ?? ''}`.trim() };
+};
+/** A branch name a person can read at a glance, and that cannot collide with an existing one. */
+export function branchNameFor(title, now = new Date()) {
+    const stem = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').split('-').slice(0, 6).join('-') || 'change';
+    return `tewip/${stem}-${now.toISOString().slice(2, 16).replace(/\D/g, '')}`;
+}
+/** The pull request body: what was built, and precisely how far the proof goes. */
+export function requestBody(body, files, issue) {
+    return [
+        body,
+        '',
+        `Files: ${files.map((f) => `\`${f}\``).join(', ')}`,
+        issue ? `From: ${issue}` : '',
+        '',
+        '---',
+        '',
+        'Written by Tewip and kept only because it was proved: the test failed without this change and',
+        'passes with it, and every test that was passing still passes.',
+        '',
+        'What that does **not** say: whether this is the design you want, whether it is the right place',
+        'for it, or whether it is complete. That is what your review is for. This is a draft on a branch',
+        'of its own; Tewip never merges anything.',
+    ]
+        .filter((line) => line !== '')
+        .join('\n');
+}
+/**
+ * Commits the proved files on a fresh branch and opens a draft pull request with the `gh` CLI the
+ * developer is already logged into. When there is no `gh`, the branch is still pushed and the
+ * command to open the request by hand is printed - half a job done is better than a silent failure.
+ */
+export function proposePullRequest(input) {
+    const { root, files } = input;
+    if (files.length === 0)
+        return { status: 'refused', next: ['there was nothing to commit'] };
+    if (!run(root, 'git', ['rev-parse', '--git-dir']).ok)
+        return { status: 'refused', next: ['this is not a git checkout, so there is no branch to open a request from'] };
+    const branch = branchNameFor(input.title);
+    const base = run(root, 'git', ['rev-parse', '--abbrev-ref', 'HEAD']).out.trim() || 'main';
+    // A branch of Tewip's own, from wherever the person is standing. Their branch is never committed to.
+    const made = run(root, 'git', ['checkout', '-b', branch]);
+    if (!made.ok)
+        return { status: 'refused', next: [`could not create the branch ${branch}: ${made.out.slice(0, 200)}`] };
+    const added = run(root, 'git', ['add', '--', ...files]);
+    if (!added.ok) {
+        run(root, 'git', ['checkout', base]);
+        return { status: 'refused', next: [`could not stage the files: ${added.out.slice(0, 200)}`] };
+    }
+    // Only Tewip's own files are committed: anything else the person had in progress stays theirs.
+    const committed = run(root, 'git', ['commit', '-m', input.title, '-m', requestBody(input.body, files, input.issue), '--only', '--', ...files]);
+    if (!committed.ok) {
+        run(root, 'git', ['checkout', base]);
+        return { status: 'refused', next: [`could not commit: ${committed.out.slice(0, 200)}`] };
+    }
+    const next = [];
+    const pushed = run(root, 'git', ['push', '-u', 'origin', branch]);
+    if (!pushed.ok) {
+        return {
+            status: 'committed',
+            branch,
+            next: [`the work is committed on ${branch}, but pushing failed: ${pushed.out.slice(0, 200)}`, `push it yourself with: git push -u origin ${branch}`],
+        };
+    }
+    const gh = run(root, 'gh', ['pr', 'create', '--draft', '--base', base, '--head', branch, '--title', input.title, '--body', requestBody(input.body, files, input.issue)]);
+    if (gh.ok) {
+        const url = (gh.out.match(/https:\/\/\S+/) ?? [])[0];
+        return { status: 'opened', branch, url, next: [`review it: ${url ?? branch}`, `back to where you were: git checkout ${base}`] };
+    }
+    next.push(`${branch} is pushed, but the pull request was not opened: ${gh.out.slice(0, 200)}`);
+    next.push(`open it with: gh pr create --draft --base ${base} --head ${branch}`);
+    next.push(`back to where you were: git checkout ${base}`);
+    return { status: 'committed', branch, next };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tewip-ai",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Tewip finds why each failing test failed - real bug, flaky test, environment, test data or changed selector - for any stack, from the command line, CI, or your editor.",
   "keywords": [
     "test-failures",