Release extension version 0.4.0

Correctly indent completion options

.github/CODEOWNERS

@@ -1 +1 @@
-* @actions/actions-experience
+* @actions/actions-workflow-development-reviewers

.github/workflows/publish.yml

@@ -1,13 +1,18 @@
 name: Create release PR
 
-run-name: Create release PR for v${{ github.event.inputs.version }}
+run-name: Create release PR for new ${{ github.event.inputs.version }} version
 
 on:
   workflow_dispatch:
     inputs:
       version:
         required: true
-        description: "Version to bump `package.json` to (format: x.y.z)"
+        type: choice
+        description: "What type of release is this"
+        options:
+          - "major"
+          - "minor"
+          - "patch"
 
 jobs:
   create-release-pr:
@@ -31,21 +36,27 @@ jobs:
           git config --global user.email "github-actions@github.com"
           git config --global user.name "GitHub Actions"
 
-          git checkout -b release/${{ inputs.version }}
+          NEW_VERSION=$(./script/workflows/increment-version.sh ${{ inputs.version }})
 
-          npx lerna version ${{ inputs.version }} --yes --no-push --no-git-tag-version --force-publish
+          git checkout -b release/$NEW_VERSION
+
+          npx lerna version $NEW_VERSION --yes --no-push --no-git-tag-version --force-publish
 
           git add **/package.json package-lock.json lerna.json
-          git commit -m "Release extension version ${{ inputs.version }}"
+          git commit -m "Release extension version $NEW_VERSION"
 
-          git push --set-upstream origin release/${{ inputs.version }}
+          git push --set-upstream origin release/$NEW_VERSION
+
+          echo "new_version=$NEW_VERSION" >> $GITHUB_ENV
 
       - name: Create PR
         run: |
+          LAST_PR=$(gh pr list --repo ${{ github.repository }} --limit 1 --state merged --search "Release version" --json number | jq -r '.[0].number')
+          ./script/workflows/generate-release-notes.sh $LAST_PR ${{ env.new_version }}
           gh pr create \
-            --title "Release version ${{ inputs.version }}" \
-            --body "Release version ${{ inputs.version }}" \
+            --title "Release version ${{ env.new_version }}" \
+            --body-file releasenotes.md \
             --base main \
-            --head release/${{ inputs.version }}
+            --head release/${{ env.new_version }}
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1,5 +1,5 @@
 */node_modules
 */dist
-
+lerna-debug.log
 node_modules
 .DS_Store

CONTRIBUTING.md

@@ -8,6 +8,8 @@ Hi there! We're thrilled that you'd like to contribute to this project. Your hel
 
 We accept pull requests for bug fixes and features where we've discussed the approach in an issue and given the go-ahead for a community member to work on it. We'd also love to hear about ideas for new features as issues.
 
+We track issues on our project board [here](https://github.com/orgs/github/projects/9557/views/1).
+
 Please do:
 
 * Check existing issues to verify that the [bug][bug issues] or [feature request][feature request issues] has not already been submitted.
@@ -21,7 +23,7 @@ Please avoid:
 
 * Opening pull requests for issues marked `needs-design`, `needs-investigation`, or `blocked`.
 
-Contributions to this project are [released](https://help.github.com/articles/github-terms-of-service/#6-contributions-under-repository-license) to the public under the [project's open source license](LICENSE.md).
+Contributions to this project are [released](https://help.github.com/articles/github-terms-of-service/#6-contributions-under-repository-license) to the public under the [project's open source license](LICENSE).
 
 Please note that this project is released with a [Contributor Code of Conduct][code-of-conduct]. By participating in this project you agree to abide by its terms.
 
@@ -60,4 +62,10 @@ Please also look at the `README.md` files for each package for additional notes
 
 - [How to Contribute to Open Source](https://opensource.guide/how-to-contribute/)
 - [Using Pull Requests](https://help.github.com/articles/about-pull-requests/)
-- [GitHub Help](https://help.github.com)
+- [GitHub Help](https://help.github.com)
+
+
+[bug issues]: https://github.com/actions/languageservices/labels/bug
+[feature request issues]: https://github.com/actions/languageservices/labels/enhancement
+[hw]: https://github.com/actions/languageservices/labels/help%20wanted
+[gfi]: https://github.com/actions/languageservices/labels/good%20first%20issue

expressions/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actions/expressions",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "license": "MIT",
   "type": "module",
   "source": "./src/index.ts",

expressions/src/evaluator.ts

@@ -32,7 +32,7 @@ export class Evaluator implements ExprVisitor<data.ExpressionData> {
     return this.eval(this.n);
   }
 
-  private eval(n: Expr): data.ExpressionData {
+  protected eval(n: Expr): data.ExpressionData {
     return n.accept(this);
   }
 

languageserver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actions/languageserver",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Language server for GitHub Actions",
   "license": "MIT",
   "type": "module",
@@ -43,8 +43,8 @@
     "watch": "tsc --build tsconfig.build.json --watch"
   },
   "dependencies": {
-    "@actions/languageservice": "^0.3.1",
-    "@actions/workflow-parser": "^0.3.1",
+    "@actions/languageservice": "^0.4.0",
+    "@actions/workflow-parser": "^0.4.0",
     "@octokit/rest": "^19.0.7",
     "@octokit/types": "^9.0.0",
     "vscode-languageserver": "^8.0.2",

languageserver/src/client.ts

@@ -1,8 +1,9 @@
 import {Octokit} from "@octokit/rest";
 
-export function getClient(token: string, userAgent?: string): Octokit {
+export function getClient(token: string, userAgent?: string, apiUrl?: string): Octokit {
   return new Octokit({
     auth: token,
-    userAgent: userAgent || `GitHub Actions Language Server`
+    userAgent: userAgent || `GitHub Actions Language Server`,
+    baseUrl: apiUrl
   });
 }

languageserver/src/connection.ts

@@ -51,7 +51,7 @@ export function initConnection(connection: Connection) {
     const options = params.initializationOptions as InitializationOptions;
 
     if (options.sessionToken) {
-      client = getClient(options.sessionToken, options.userAgent);
+      client = getClient(options.sessionToken, options.userAgent, options.gitHubApiUrl);
     }
 
     if (options.repos) {

languageserver/src/context-providers/secrets.ts

@@ -28,6 +28,7 @@ export async function getSecrets(
   }
 
   const eventsConfig = workflowContext?.template?.events;
+
   if (eventsConfig?.workflow_call) {
     // Unpredictable secrets may be passed in via a workflow_call trigger
     secretsContext.complete = false;
@@ -38,6 +39,7 @@ export async function getSecrets(
   }
 
   let environmentName: string | undefined;
+
   if (workflowContext?.job?.environment) {
     if (isString(workflowContext.job.environment)) {
       environmentName = workflowContext.job.environment.value;
@@ -46,10 +48,17 @@ export async function getSecrets(
         if (isString(x.key) && x.key.value === "name") {
           if (isString(x.value)) {
             environmentName = x.value.value;
+          } else {
+            // this means we have a dynamic enviornment, in those situations we
+            // want to make sure we skip doing secret validation
+            secretsContext.complete = false;
           }
           break;
         }
       }
+    } else {
+      // if the expression is something like environment: ${{ ... }} then we want to skip validation
+      secretsContext.complete = false;
     }
   }
 

languageserver/src/context-providers/variables.ts

@@ -2,9 +2,10 @@ import {data, DescriptionDictionary} from "@actions/expressions";
 import {Pair} from "@actions/expressions/data/expressiondata";
 import {StringData} from "@actions/expressions/data/index";
 import {WorkflowContext} from "@actions/languageservice/context/workflow-context";
-import {warn} from "@actions/languageservice/log";
+import {log, warn} from "@actions/languageservice/log";
 import {isMapping, isString} from "@actions/workflow-parser";
 import {Octokit} from "@octokit/rest";
+import {RequestError} from "@octokit/request-error";
 
 import {RepositoryContext} from "../initializationOptions";
 import {TTLCache} from "../utils/cache";
@@ -42,50 +43,58 @@ export async function getVariables(
   }
 
   const variablesContext = defaultContext || new DescriptionDictionary();
-  const variables = await getRemoteVariables(octokit, cache, repo, environmentName);
+  try {
+    const variables = await getRemoteVariables(octokit, cache, repo, environmentName);
 
-  // Build combined map of variables
-  const variablesMap = new Map<
-    string,
-    {
-      key: string;
-      value: data.StringData;
-      description?: string;
-    }
-  >();
+    // Build combined map of variables
+    const variablesMap = new Map<
+      string,
+      {
+        key: string;
+        value: data.StringData;
+        description?: string;
+      }
+    >();
 
-  variables.organizationVariables.forEach(variable =>
-    variablesMap.set(variable.key.toLowerCase(), {
-      key: variable.key,
-      value: new data.StringData(variable.value.coerceString()),
-      description: `${variable.value.coerceString()} - Organization variable`
-    })
-  );
+    variables.organizationVariables.forEach(variable =>
+      variablesMap.set(variable.key.toLowerCase(), {
+        key: variable.key,
+        value: new data.StringData(variable.value.coerceString()),
+        description: `${variable.value.coerceString()} - Organization variable`
+      })
+    );
 
-  // Override org variables with repo variables
-  variables.repoVariables.forEach(variable =>
-    variablesMap.set(variable.key.toLowerCase(), {
-      key: variable.key,
-      value: new data.StringData(variable.value.coerceString()),
-      description: `${variable.value.coerceString()} - Repository variable`
-    })
-  );
+    // Override org variables with repo variables
+    variables.repoVariables.forEach(variable =>
+      variablesMap.set(variable.key.toLowerCase(), {
+        key: variable.key,
+        value: new data.StringData(variable.value.coerceString()),
+        description: `${variable.value.coerceString()} - Repository variable`
+      })
+    );
 
-  // Override repo variables with environment veriables (if defined)
-  variables.environmentVariables.forEach(variable =>
-    variablesMap.set(variable.key.toLowerCase(), {
-      key: variable.key,
-      value: new data.StringData(variable.value.coerceString()),
-      description: `${variable.value.coerceString()} - Variable for environment \`${environmentName || ""}\``
-    })
-  );
+    // Override repo variables with environment veriables (if defined)
+    variables.environmentVariables.forEach(variable =>
+      variablesMap.set(variable.key.toLowerCase(), {
+        key: variable.key,
+        value: new data.StringData(variable.value.coerceString()),
+        description: `${variable.value.coerceString()} - Variable for environment \`${environmentName || ""}\``
+      })
+    );
 
-  // Sort variables by key and add to context
-  Array.from(variablesMap.values())
-    .sort((a, b) => a.key.localeCompare(b.key))
-    .forEach(variable => variablesContext?.add(variable.key, variable.value, variable.description));
+    // Sort variables by key and add to context
+    Array.from(variablesMap.values())
+      .sort((a, b) => a.key.localeCompare(b.key))
+      .forEach(variable => variablesContext?.add(variable.key, variable.value, variable.description));
 
-  return variablesContext;
+    return variablesContext;
+  } catch (e) {
+    if (!(e instanceof RequestError)) throw e;
+    if (e.name == "HttpError" && e.status == 404) {
+      log("Failure to request variables. Ignore if you're using GitHub Enterprise Server below version 3.8");
+      return variablesContext;
+    } else throw e;
+  }
 }
 
 export async function getRemoteVariables(

languageserver/src/file-provider.ts

@@ -2,8 +2,8 @@ import {File} from "@actions/workflow-parser/workflows/file";
 import {FileProvider} from "@actions/workflow-parser/workflows/file-provider";
 import {fileIdentifier} from "@actions/workflow-parser/workflows/file-reference";
 import {Octokit} from "@octokit/rest";
-import path from "path";
 import {TTLCache} from "./utils/cache";
+import vscodeURI from "vscode-uri/lib/umd";
 
 export function getFileProvider(
   client: Octokit | undefined,
@@ -31,7 +31,10 @@ export function getFileProvider(
         throw new Error("Local file references are not supported with this configuration");
       }
 
-      const file = await readFile(path.join(workspace, ref.path));
+      const workspaceURI = vscodeURI.URI.parse(workspace);
+      const refURI = vscodeURI.Utils.joinPath(workspaceURI, ref.path);
+      const file = await readFile(refURI.toString());
+
       if (!file) {
         throw new Error(`File not found: ${ref.path}`);
       }

languageserver/src/initializationOptions.ts

@@ -23,6 +23,11 @@ export interface InitializationOptions {
    * Desired log level
    */
   logLevel?: LogLevel;
+
+  /**
+   * If a GitHub Enterprise Server should be used, the URL of the API endpoint, eg "https://ghe.my-company.com/api/v3"
+   */
+  gitHubApiUrl?: string;
 }
 
 export interface RepositoryContext {

languageservice/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actions/languageservice",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Language service for GitHub Actions",
   "license": "MIT",
   "type": "module",
@@ -44,8 +44,8 @@
     "watch": "tsc --build tsconfig.build.json --watch"
   },
   "dependencies": {
-    "@actions/expressions": "^0.3.1",
-    "@actions/workflow-parser": "^0.3.1",
+    "@actions/expressions": "^0.4.0",
+    "@actions/workflow-parser": "^0.4.0",
     "vscode-languageserver-textdocument": "^1.0.7",
     "vscode-languageserver-types": "^3.17.2",
     "vscode-uri": "^3.0.7",

languageservice/src/complete.test.ts

@@ -4,8 +4,8 @@ import {complete} from "./complete";
 import {registerLogger} from "./log";
 import {getPositionFromCursor} from "./test-utils/cursor-position";
 import {TestLogger} from "./test-utils/logger";
-import {ValueProviderConfig, ValueProviderKind} from "./value-providers/config";
 import {clearCache} from "./utils/workflow-cache";
+import {ValueProviderConfig, ValueProviderKind} from "./value-providers/config";
 
 registerLogger(new TestLogger());
 
@@ -406,7 +406,7 @@ jobs:
     expect(result.map(e => e.label)).toContain("runs-on");
 
     const textEdit = result.filter(e => e.label === "runs-on")[0].textEdit as TextEdit;
-    expect(textEdit.newText).toEqual("runs-on");
+    expect(textEdit.newText).toEqual("runs-on: ");
     expect(textEdit.range).toEqual({
       start: {line: 3, character: 4},
       end: {line: 3, character: 10}
@@ -421,7 +421,7 @@ jobs:
     expect(result.map(e => e.label)).toContain("runs-on");
 
     const textEdit = result.filter(e => e.label === "runs-on")[0].textEdit as TextEdit;
-    expect(textEdit.newText).toEqual("runs-on");
+    expect(textEdit.newText).toEqual("runs-on: ");
     expect(textEdit.range).toEqual({
       start: {line: 3, character: 4},
       end: {line: 3, character: 4}
@@ -448,7 +448,7 @@ jobs:
       ]);
 
       // One-of
-      expect(result.filter(x => x.label === "concurrency").map(x => x.textEdit?.newText)).toEqual(["concurrency"]);
+      expect(result.filter(x => x.label === "concurrency").map(x => x.textEdit?.newText)).toEqual(["concurrency: "]);
     });
 
     it("custom indentation", async () => {
@@ -471,7 +471,50 @@ jobs:
       ]);
 
       // One-of
-      expect(result.filter(x => x.label === "concurrency").map(x => x.textEdit?.newText)).toEqual(["concurrency"]);
+      expect(result.filter(x => x.label === "concurrency").map(x => x.textEdit?.newText)).toEqual(["concurrency: "]);
     });
   });
+
+  it("adds a new line and indentation for mapping keys when the key is given", async () => {
+    const input = "concurrency: |";
+
+    const result = await complete(...getPositionFromCursor(input));
+
+    expect(result.filter(x => x.label === "cancel-in-progress").map(x => x.textEdit?.newText)).toEqual([
+      "\n  cancel-in-progress: "
+    ]);
+    expect(result.filter(x => x.label === "group").map(x => x.textEdit?.newText)).toEqual(["\n  group: "]);
+  });
+
+  it("does not add new line if no key in line", async () => {
+    const input = "run-n|";
+
+    const result = await complete(...getPositionFromCursor(input));
+
+    expect(result.filter(x => x.label === "run-name").map(x => x.textEdit?.newText)).toEqual(["run-name: "]);
+  });
+
+  it("adds new line for nested mapping", async () => {
+    const input = "on:\n  workflow_dispatch: in|";
+
+    const result = await complete(...getPositionFromCursor(input));
+
+    expect(result.filter(x => x.label === "inputs").map(x => x.textEdit?.newText)).toEqual(["\n  inputs:\n    "]);
+  });
+
+  it("adds : for one-of", async () => {
+    const input = "on:\n  check_run:\n    ty|";
+
+    const result = await complete(...getPositionFromCursor(input));
+
+    expect(result.filter(x => x.label === "types").map(x => x.textEdit?.newText)).toEqual(["types: "]);
+  });
+
+  it("does not add : for one-of in key mode", async () => {
+    const input = "on:\n  check_run: ty|";
+
+    const result = await complete(...getPositionFromCursor(input));
+
+    expect(result.filter(x => x.label === "types").map(x => x.textEdit?.newText)).toEqual(["types"]);
+  });
 });

languageservice/src/complete.ts

@@ -24,7 +24,7 @@ import {isPlaceholder, transform} from "./utils/transform";
 import {fetchOrConvertWorkflowTemplate, fetchOrParseWorkflow} from "./utils/workflow-cache";
 import {Value, ValueProviderConfig} from "./value-providers/config";
 import {defaultValueProviders} from "./value-providers/default";
-import {definitionValues} from "./value-providers/definition";
+import {DefinitionValueMode, definitionValues} from "./value-providers/definition";
 
 export function getExpressionInput(input: string, pos: number): string {
   // Find start marker around the cursor position
@@ -180,7 +180,7 @@ async function getValues(
     return [];
   }
 
-  const values = definitionValues(def, indentation);
+  const values = definitionValues(def, indentation, keyToken ? DefinitionValueMode.Key : DefinitionValueMode.Parent);
   return filterAndSortCompletionOptions(values, existingValues);
 }
 

languageservice/src/expression-validation/evaluator.ts

@@ -0,0 +1,61 @@
+import {Evaluator, ExpressionEvaluationError, data} from "@actions/expressions";
+import {Expr, Logical} from "@actions/expressions/ast";
+import {ExpressionData} from "@actions/expressions/data/expressiondata";
+import {TokenType} from "@actions/expressions/lexer";
+import {falsy, truthy} from "@actions/expressions/result";
+import {AccessError} from "./error-dictionary";
+
+export type ValidationError = {
+  message: string;
+  severity: "error" | "warning";
+};
+
+export class ValidationEvaluator extends Evaluator {
+  public readonly errors: ValidationError[] = [];
+
+  public validate() {
+    super.evaluate();
+  }
+
+  protected override eval(n: Expr): ExpressionData {
+    try {
+      return super.eval(n);
+    } catch (e) {
+      // Record error
+      if (e instanceof AccessError) {
+        this.errors.push({
+          message: `Context access might be invalid: ${e.keyName}`,
+          severity: "warning"
+        });
+      } else if (e instanceof ExpressionEvaluationError) {
+        this.errors.push({
+          message: `Expression might be invalid: ${e.message}`,
+          severity: "error"
+        });
+      }
+    }
+
+    // Return null but continue with the validation
+    return new data.Null();
+  }
+
+  override visitLogical(logical: Logical): ExpressionData {
+    let result: data.ExpressionData | undefined;
+
+    for (const arg of logical.args) {
+      const r = this.eval(arg);
+
+      // Simulate short-circuit behavior but continue to evalute all arguments for validation purposes
+      if (
+        !result &&
+        ((logical.operator.type === TokenType.AND && falsy(r)) || (logical.operator.type === TokenType.OR && truthy(r)))
+      ) {
+        result = r;
+      }
+    }
+
+    // result is always assigned before we return here
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return result!;
+  }
+}

languageservice/src/validate.expressions.test.ts

@@ -46,6 +46,52 @@ jobs:
     ]);
   });
 
+  it("access invalid context field in short-circuited expression", async () => {
+    const result = await validate(
+      createDocument(
+        "wf.yaml",
+        `on: push
+run-name: name-\${{ github.does-not-exist || github.does-not-exist2 }}
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo`
+      )
+    );
+
+    expect(result).toEqual([
+      {
+        message: "Context access might be invalid: does-not-exist",
+        range: {
+          end: {
+            character: 69,
+            line: 1
+          },
+          start: {
+            character: 15,
+            line: 1
+          }
+        },
+        severity: DiagnosticSeverity.Warning
+      },
+      {
+        message: "Context access might be invalid: does-not-exist2",
+        range: {
+          end: {
+            character: 69,
+            line: 1
+          },
+          start: {
+            character: 15,
+            line: 1
+          }
+        },
+        severity: DiagnosticSeverity.Warning
+      }
+    ]);
+  });
+
   it("partial skip access invalid context on incomplete", async () => {
     const contextProviderConfig: ContextProviderConfig = {
       getContext: (context: string) => {

languageservice/src/validate.ts

@@ -1,6 +1,6 @@
-import {Evaluator, ExpressionEvaluationError, Lexer, Parser} from "@actions/expressions";
+import {Lexer, Parser} from "@actions/expressions";
 import {Expr} from "@actions/expressions/ast";
-import {isBasicExpression, isString, ParseWorkflowResult, WorkflowTemplate} from "@actions/workflow-parser";
+import {ParseWorkflowResult, WorkflowTemplate, isBasicExpression, isString} from "@actions/workflow-parser";
 import {ErrorPolicy} from "@actions/workflow-parser/model/convert";
 import {splitAllowedContext} from "@actions/workflow-parser/templates/allowed-context";
 import {BasicExpressionToken} from "@actions/workflow-parser/templates/tokens/basic-expression-token";
@@ -13,9 +13,10 @@ import {TextDocument} from "vscode-languageserver-textdocument";
 import {Diagnostic, DiagnosticSeverity, URI} from "vscode-languageserver-types";
 import {ActionMetadata, ActionReference} from "./action";
 import {ContextProviderConfig} from "./context-providers/config";
-import {getContext, Mode} from "./context-providers/default";
-import {getWorkflowContext, WorkflowContext} from "./context/workflow-context";
-import {AccessError, wrapDictionary} from "./expression-validation/error-dictionary";
+import {Mode, getContext} from "./context-providers/default";
+import {WorkflowContext, getWorkflowContext} from "./context/workflow-context";
+import {wrapDictionary} from "./expression-validation/error-dictionary";
+import {ValidationEvaluator} from "./expression-validation/evaluator";
 import {validatorFunctions} from "./expression-validation/functions";
 import {error} from "./log";
 import {findToken} from "./utils/find-token";
@@ -202,28 +203,17 @@ async function validateExpression(
       continue;
     }
 
-    try {
-      const context = await getContext(namedContexts, contextProviderConfig, workflowContext, Mode.Validation);
+    const context = await getContext(namedContexts, contextProviderConfig, workflowContext, Mode.Validation);
 
-      const e = new Evaluator(expr, wrapDictionary(context), validatorFunctions);
-      e.evaluate();
+    const e = new ValidationEvaluator(expr, wrapDictionary(context), validatorFunctions);
+    e.validate();
 
-      // Any invalid context access would've thrown an error via the `ErrorDictionary`, for now we don't have to check the actual
-      // result of the evaluation.
-    } catch (e) {
-      if (e instanceof AccessError) {
-        diagnostics.push({
-          message: `Context access might be invalid: ${e.keyName}`,
-          severity: DiagnosticSeverity.Warning,
-          range: mapRange(expression.range)
-        });
-      } else if (e instanceof ExpressionEvaluationError) {
-        diagnostics.push({
-          message: `Expression might be invalid: ${e.message}`,
-          severity: DiagnosticSeverity.Error,
-          range: mapRange(expression.range)
-        });
-      }
-    }
+    diagnostics.push(
+      ...e.errors.map(e => ({
+        message: e.message,
+        range: mapRange(expression.range),
+        severity: e.severity === "error" ? DiagnosticSeverity.Error : DiagnosticSeverity.Warning
+      }))
+    );
   }
 }

languageservice/src/value-providers/definition.ts

@@ -9,15 +9,30 @@ import {getWorkflowSchema} from "@actions/workflow-parser/workflows/workflow-sch
 import {Value} from "./config";
 import {stringsToValues} from "./strings-to-values";
 
-export function definitionValues(def: Definition, indentation: string): Value[] {
+export enum DefinitionValueMode {
+  /**
+   * We're getting completion options for a parent token
+   * foo:
+   *   ba|
+   */
+  Parent,
+
+  /**
+   * We're getting completion options for a key token. For example:
+   * foo: |
+   */
+  Key
+}
+
+export function definitionValues(def: Definition, indentation: string, mode: DefinitionValueMode): Value[] {
   const schema = getWorkflowSchema();
 
   if (def instanceof MappingDefinition) {
-    return mappingValues(def, schema.definitions, indentation);
+    return mappingValues(def, schema.definitions, indentation, mode);
   }
 
   if (def instanceof OneOfDefinition) {
-    return oneOfValues(def, schema.definitions, indentation);
+    return oneOfValues(def, schema.definitions, indentation, mode);
   }
 
   if (def instanceof BooleanDefinition) {
@@ -36,7 +51,7 @@ export function definitionValues(def: Definition, indentation: string): Value[]
   if (def instanceof SequenceDefinition) {
     const itemDef = schema.getDefinition(def.itemType);
     if (itemDef) {
-      return definitionValues(itemDef, indentation);
+      return definitionValues(itemDef, indentation, mode);
     }
   }
 
@@ -46,7 +61,8 @@ export function definitionValues(def: Definition, indentation: string): Value[]
 function mappingValues(
   mappingDefinition: MappingDefinition,
   definitions: {[key: string]: Definition},
-  indentation: string
+  indentation: string,
+  mode: DefinitionValueMode
 ): Value[] {
   const properties: Value[] = [];
   for (const [key, value] of Object.entries(mappingDefinition.properties)) {
@@ -60,15 +76,36 @@ function mappingValues(
       if (typeDef) {
         switch (typeDef.definitionType) {
           case DefinitionType.Sequence:
-            insertText = `${key}:\n${indentation}- `;
+            if (mode == DefinitionValueMode.Key) {
+              insertText = `\n${indentation}${key}:\n${indentation}${indentation}- `;
+            } else {
+              insertText = `${key}:\n${indentation}- `;
+            }
             break;
 
           case DefinitionType.Mapping:
-            insertText = `${key}:\n${indentation}`;
+            if (mode == DefinitionValueMode.Key) {
+              insertText = `\n${indentation}${key}:\n${indentation}${indentation}`;
+            } else {
+              insertText = `${key}:\n${indentation}`;
+            }
             break;
 
           case DefinitionType.OneOf:
-            // No special insertText in this case
+            if (mode == DefinitionValueMode.Parent) {
+              insertText = `${key}: `;
+            } else {
+              // No special insertText in this case
+            }
+            break;
+
+          case DefinitionType.String:
+          case DefinitionType.Boolean:
+            if (mode == DefinitionValueMode.Key) {
+              insertText = `\n${indentation}${key}: `;
+            } else {
+              insertText = `${key}: `;
+            }
             break;
 
           default:
@@ -89,11 +126,12 @@ function mappingValues(
 function oneOfValues(
   oneOfDefinition: OneOfDefinition,
   definitions: {[key: string]: Definition},
-  indentation: string
+  indentation: string,
+  mode: DefinitionValueMode
 ): Value[] {
   const values: Value[] = [];
   for (const key of oneOfDefinition.oneOf) {
-    values.push(...definitionValues(definitions[key], indentation));
+    values.push(...definitionValues(definitions[key], indentation, mode));
   }
   return distinctValues(values);
 }

lerna.json

@@ -1,5 +1,10 @@
 {
   "$schema": "node_modules/lerna/schemas/lerna-schema.json",
-  "useWorkspaces": true,
-  "version": "0.3.1"
+  "packages": [
+    "expressions",
+    "workflow-parser",
+    "languageservice",
+    "languageserver"
+  ],
+  "version": "0.4.0"
 }

package-lock.json

@@ -135,7 +135,7 @@
     },
     "expressions": {
       "name": "@actions/expressions",
-      "version": "0.3.1",
+      "version": "0.4.0",
       "license": "MIT",
       "devDependencies": {
         "@types/jest": "^29.0.3",
@@ -395,11 +395,11 @@
     },
     "languageserver": {
       "name": "@actions/languageserver",
-      "version": "0.3.1",
+      "version": "0.4.0",
       "license": "MIT",
       "dependencies": {
-        "@actions/languageservice": "^0.3.1",
-        "@actions/workflow-parser": "^0.3.1",
+        "@actions/languageservice": "^0.4.0",
+        "@actions/workflow-parser": "^0.4.0",
         "@octokit/rest": "^19.0.7",
         "@octokit/types": "^9.0.0",
         "vscode-languageserver": "^8.0.2",
@@ -678,11 +678,11 @@
     },
     "languageservice": {
       "name": "@actions/languageservice",
-      "version": "0.3.1",
+      "version": "0.4.0",
       "license": "MIT",
       "dependencies": {
-        "@actions/expressions": "^0.3.1",
-        "@actions/workflow-parser": "^0.3.1",
+        "@actions/expressions": "^0.4.0",
+        "@actions/workflow-parser": "^0.4.0",
         "vscode-languageserver-textdocument": "^1.0.7",
         "vscode-languageserver-types": "^3.17.2",
         "vscode-uri": "^3.0.7",
@@ -6652,9 +6652,10 @@
       "license": "MIT"
     },
     "node_modules/http-cache-semantics": {
-      "version": "4.1.0",
-      "dev": true,
-      "license": "BSD-2-Clause"
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz",
+      "integrity": "sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==",
+      "dev": true
     },
     "node_modules/http-proxy-agent": {
       "version": "5.0.0",
@@ -11667,8 +11668,9 @@
       "license": "ISC"
     },
     "node_modules/yaml": {
-      "version": "2.1.3",
-      "license": "ISC",
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.2.2.tgz",
+      "integrity": "sha512-CBKFWExMn46Foo4cldiChEzn7S7SRV+wqiluAb6xmueD/fGyRHIhX8m14vVGgeFWjN540nKCNVj6P21eQjgTuA==",
       "engines": {
         "node": ">= 14"
       }
@@ -11719,10 +11721,10 @@
     },
     "workflow-parser": {
       "name": "@actions/workflow-parser",
-      "version": "0.3.1",
+      "version": "0.4.0",
       "license": "MIT",
       "dependencies": {
-        "@actions/expressions": "^0.3.1",
+        "@actions/expressions": "^0.4.0",
         "cronstrue": "^2.21.0",
         "yaml": "^2.0.0-8"
       },

releasenotes.md

@@ -0,0 +1 @@
+Release 0.3.5

script/workflows/generate-release-notes.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# this script is used to generate release notes for a given release
+# first argument is the pull request id for the last release
+# the second is the new release number
+
+# the script then grabs every pull request merged since that pull request
+# and outputs a string of release notes
+
+# get the new release number
+NEW_RELEASE=$2
+
+echo "Generating release notes for $NEW_RELEASE"
+
+# get the last release pull request id
+LAST_RELEASE_PR=$1
+
+
+
+#get when the last release was merged
+LAST_RELEASE_MERGED_AT=$(gh pr view $LAST_RELEASE_PR --repo actions/languageservices --json mergedAt  | jq -r '.mergedAt')
+
+CHANGELIST=$(gh pr list --repo actions/languageservices --base main --state merged --json title --search "merged:>$LAST_RELEASE_MERGED_AT -label:no-release")
+
+# store the release notes in a variable so we can use it later
+
+echo "Release $NEW_RELEASE" >> releasenotes.md
+
+echo $CHANGELIST | jq -r '.[].title' | while read line; do
+  echo " - $line" >> releasenotes.md
+done
+
+echo " "

script/workflows/increment-version.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+VERSION=$(cat lerna.json | jq -r '.version')
+
+MAJOR=$(echo $VERSION | cut -d. -f1) 
+MINOR=$(echo $VERSION | cut -d. -f2)
+PATCH=$(echo $VERSION | cut -d. -f3)
+
+if [ "$1" == "major" ]; then
+  MAJOR=$((MAJOR+1))
+  MINOR=0
+  PATCH=0
+elif [ "$1" == "minor" ]; then
+  MINOR=$((MINOR+1))
+  PATCH=0
+elif [ "$1" == "patch" ]; then
+  PATCH=$((PATCH+1))
+else
+  echo "Invalid version type. Use 'major', 'minor' or 'patch'"
+  exit 1
+fi
+
+NEW_VERSION="$MAJOR.$MINOR.$PATCH"
+echo $NEW_VERSION 

workflow-parser/README.md

@@ -35,7 +35,7 @@ jobs:
 );
 ```
 
-`convertWorkflowTemplate` then takes that intermediate representation and converts it to a [`WorkflowTemplate`](./src/workflow-template.ts) object, which is a more convenient representation for working with workflows.
+`convertWorkflowTemplate` then takes that intermediate representation and converts it to a [`WorkflowTemplate`](./src/model/workflow-template.ts) object, which is a more convenient representation for working with workflows.
 
 ```typescript
 const workflowTemplate = await convertWorkflowTemplate(result.context, result.value);

workflow-parser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actions/workflow-parser",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "license": "MIT",
   "type": "module",
   "source": "./src/index.ts",
@@ -43,7 +43,7 @@
     "watch": "tsc --build tsconfig.build.json --watch"
   },
   "dependencies": {
-    "@actions/expressions": "^0.3.1",
+    "@actions/expressions": "^0.4.0",
     "cronstrue": "^2.21.0",
     "yaml": "^2.0.0-8"
   },

workflow-parser/src/model/converter/events.ts

@@ -59,17 +59,24 @@ export function convertOn(context: TemplateContext, token: TemplateToken): Event
 
       // All other events are defined as mappings. During schema validation we already ensure that events
       // receive only known keys, so here we can focus on the values and whether they are valid.
+
       const eventToken = item.value.assertMapping(`event ${eventName}`);
+      if (eventName === "workflow_call") {
+        result.workflow_call = convertEventWorkflowCall(context, eventToken);
+        continue;
+      }
+
+      if (eventName === "workflow_dispatch") {
+        result.workflow_dispatch = convertEventWorkflowDispatchInputs(context, eventToken);
+        continue;
+      }
 
       result[eventName] = {
         ...convertPatternFilter("branches", eventToken),
         ...convertPatternFilter("tags", eventToken),
         ...convertPatternFilter("paths", eventToken),
         ...convertFilter("types", eventToken),
-        ...convertFilter("workflows", eventToken),
-        // workflow_call and workflow_dispatch share input parsing
-        ...convertEventWorkflowDispatchInputs(context, eventToken),
-        ...convertEventWorkflowCall(context, eventToken)
+        ...convertFilter("workflows", eventToken)
       };
     }
 

workflow-parser/src/model/converter/steps.ts

@@ -50,7 +50,7 @@ function convertStep(context: TemplateContext, idBuilder: IdBuilder, step: Templ
   let id: StringToken | undefined;
   let name: ScalarToken | undefined;
   let uses: StringToken | undefined;
-  let continueOnError: boolean | undefined;
+  let continueOnError: boolean | ScalarToken | undefined;
   let env: MappingToken | undefined;
   const ifCondition = new BasicExpressionToken(undefined, undefined, "success()", undefined, undefined, undefined);
   for (const item of mapping) {
@@ -78,7 +78,11 @@ function convertStep(context: TemplateContext, idBuilder: IdBuilder, step: Templ
         env = item.value.assertMapping("step env");
         break;
       case "continue-on-error":
-        continueOnError = item.value.assertBoolean("steps item continue-on-error").value;
+        if (!item.value.isExpression) {
+          continueOnError = item.value.assertBoolean("steps item continue-on-error").value;
+        } else {
+          continueOnError = item.value.assertScalar("steps item continue-on-error");
+        }
     }
   }
 

workflow-parser/src/model/converter/workflow-call.ts

@@ -1,7 +1,9 @@
 import {TemplateContext} from "../../templates/template-context";
 import {MappingToken, TemplateToken} from "../../templates/tokens";
 import {isMapping} from "../../templates/tokens/type-guards";
-import {SecretConfig, WorkflowCallConfig} from "../workflow-template";
+import {SecretConfig, WorkflowCallConfig, InputConfig, InputType} from "../workflow-template";
+import {convertStringList} from "./string-list";
+import {ScalarToken} from "../../templates/tokens/scalar-token";
 
 export function convertEventWorkflowCall(context: TemplateContext, token: MappingToken): WorkflowCallConfig {
   const result: WorkflowCallConfig = {};
@@ -11,7 +13,7 @@ export function convertEventWorkflowCall(context: TemplateContext, token: Mappin
 
     switch (key.value) {
       case "inputs":
-        // Ignore, these are handled by convertEventWorkflowDispatchInputs
+        result.inputs = convertWorkflowInputs(context, item.value.assertMapping("workflow dispatch inputs"));
         break;
 
       case "secrets":
@@ -27,6 +29,94 @@ export function convertEventWorkflowCall(context: TemplateContext, token: Mappin
   return result;
 }
 
+export function convertWorkflowInputs(
+  context: TemplateContext,
+  token: MappingToken
+): {
+  [inputName: string]: InputConfig;
+} {
+  const result: {[inputName: string]: InputConfig} = {};
+
+  for (const item of token) {
+    const inputName = item.key.assertString("input name");
+    const inputMapping = item.value.assertMapping("input configuration");
+
+    result[inputName.value] = convertWorkflowInput(context, inputMapping);
+  }
+
+  return result;
+}
+
+export function convertWorkflowInput(context: TemplateContext, token: MappingToken): InputConfig {
+  const result: InputConfig = {
+    type: InputType.string // Default to string
+  };
+
+  let defaultValue: undefined | ScalarToken;
+
+  for (const item of token) {
+    const key = item.key.assertString("workflow dispatch input key");
+
+    switch (key.value) {
+      case "description":
+        result.description = item.value.assertString("input description").value;
+        break;
+
+      case "required":
+        result.required = item.value.assertBoolean("input required").value;
+        break;
+
+      case "default":
+        defaultValue = item.value.assertScalar("input default");
+        break;
+
+      case "type":
+        result.type = InputType[item.value.assertString("input type").value as keyof typeof InputType];
+        break;
+
+      case "options":
+        result.options = convertStringList("input options", item.value.assertSequence("input options"));
+        break;
+
+      default:
+        context.error(item.key, `Invalid key '${key.value}'`);
+    }
+  }
+
+  // Validate default value
+  if (defaultValue !== undefined && !defaultValue.isExpression) {
+    try {
+      switch (result.type) {
+        case InputType.boolean:
+          result.default = defaultValue.assertBoolean("input default").value;
+
+          break;
+
+        case InputType.string:
+        case InputType.choice:
+        case InputType.environment:
+          result.default = defaultValue.assertString("input default").value;
+          break;
+      }
+    } catch (e) {
+      context.error(defaultValue, e);
+    }
+  }
+
+  // Validate `options` for `choice` type
+  if (result.type === InputType.choice) {
+    if (result.options === undefined || result.options.length === 0) {
+      context.error(token, "Missing 'options' for choice input");
+    }
+  } else {
+    if (result.options !== undefined) {
+      context.error(token, "Input type is not 'choice', but 'options' is defined");
+    }
+  }
+
+  return result;
+}
+
 function convertWorkflowCallSecrets(
   context: TemplateContext,
   token: MappingToken

workflow-parser/src/model/workflow-template.ts

@@ -86,7 +86,7 @@ type BaseStep = {
   id: string;
   name?: ScalarToken;
   if: BasicExpressionToken;
-  "continue-on-error"?: boolean;
+  "continue-on-error"?: boolean | ScalarToken;
   env?: MappingToken;
 };
 
@@ -158,7 +158,7 @@ export type WorkflowDispatchConfig = {
 };
 
 export type WorkflowCallConfig = {
-  inputs?: {[inputName: string]: InputConfig};
+  inputs?: {[inputName: string]: InputConfig & {default?: string | boolean | number | ScalarToken}};
   secrets?: {[secretName: string]: SecretConfig};
   // TODO - these are supported in C# and Go but not in TS yet
   // outputs: { [outputName: string]: OutputConfig }

workflow-parser/src/workflow-v1.0.json

@@ -576,7 +576,9 @@
     "merge-group-mapping": {
       "mapping": {
         "properties": {
-          "types": "merge-group-activity"
+          "types": "merge-group-activity",
+          "branches": "event-branches",
+          "branches-ignore": "event-branches-ignore"
         }
       }
     },
@@ -1181,7 +1183,7 @@
       ]
     },
     "workflow-run-activity": {
-      "description": "The types of workflow run activity that trigger the workflow. Suupported activity types: `completed`, `requested`, `in_progress`.",
+      "description": "The types of workflow run activity that trigger the workflow. Supported activity types: `completed`, `requested`, `in_progress`.",
       "one-of": [
         "workflow-run-activity-type",
         "workflow-run-activity-types"
@@ -2487,7 +2489,7 @@
       "string": {
         "require-non-empty": true
       },
-      "description": "Use `shell` to override the default shell settings in the runner's operating system. You can use built-in shell keywords, or you can define a custom set of shell options. The shell command that is run internally executes a temporary file that contains the comands specified in `run`."
+      "description": "Use `shell` to override the default shell settings in the runner's operating system. You can use built-in shell keywords, or you can define a custom set of shell options. The shell command that is run internally executes a temporary file that contains the commands specified in `run`."
     },
     "working-directory": {
       "string": {

workflow-parser/testdata/reader/events-mapping-all.yml

@@ -72,7 +72,13 @@ on:
       - edited
       - deleted
   merge_group:
-    types: checks_requested
+    branches: 
+      - master 
+      - main
+    branches-ignore:
+      - develop
+    types: 
+      - checks_requested
   milestone:
     types:
       - created
@@ -313,6 +319,13 @@ jobs:
       ]
     },
     "merge_group": {
+      "branches": [
+        "master",
+        "main"
+      ],
+      "branches-ignore": [
+        "develop"
+      ],
       "types": [
         "checks_requested"
       ]